DEV Community: cloudteachable

Python : Object-Oriented Programming (OOP)

Srinivasulu Paranduru — Thu, 16 Oct 2025 06:42:40 +0000

Object-Oriented Programming (OOP) in Python is a programming paradigm that organizes code using "objects"-Instances of classes that encapsulate data (attributes) and behaviour (methods). OOP helps structure complex programs, making them easier to manage, extend, and maintain.

OOP concepts are needed because they:

Promote code reusability through inheritance.
Improve code organization and readability.
Enable encapsulation, protecting data from unintended access.
Support polymorphism, allowing flexible and interchangeable code.
Make it easier to model real-world entities and relationships.

DRY Principle in OOP

DRY stands for "Don't Repeat Yourself".
It is a software development principle aimed at reducing repetition of code.
In Object-Oriented Programming (OOP), DRY encourages the use of classes, inheritance, and methods to encapsulate behavior and data, so that code is not duplicated.

# Example:
class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

By using inheritance, we avoid repeating common code and follow the DRY principle.

Class
Important concepts in classes and objects
- Getter and Setter Methods
- Method Overriding
- Static Methods and Class Methods
- Abstract Classes and Interfaces
- class-variables-vs-instance-variables
Python Inheritance

Class :

In Python, a class is a blueprint for creating objects (instances).
Classes are created using class keyword
It defines attributes (variables) and methods (functions) that the objects will have.
Attributes can be accessed using dot . operator (e.g., MyClass.my_attribute).
Example: Defining a simple class

# define a class
class Dog:
    sound = "bark"  # class attribute

Object: An object is a specific instance of a class. It holds its own set of data (instance variables) and can invoke methods defined by its class. Multiple objects can be created from same class, each with its own unique attributes.

class Dog:
    sound = "bark"

dog1 = Dog() # Creating object from class
print(dog1.sound) # Accessing the class

The init() Method

init() is a special method in Python classes. It’s called the constructor and runs automatically when you create a new instance of a class. Its main job is to initialize the object’s attributes.

Example:

class Dog:
    def __init__(self, name):
        self.name = name

my_dog = Dog("Rex")
print(my_dog.name)  # Output: Rex

Self Parameter
The self parameter in Python is used in instance methods of classes. It refers to the object (instance) itself, allowing you to access its attributes and other methods.

Key points:

self is always the first parameter in instance methods.
It is not a keyword; you could name it anything, but self is the convention.
It lets you distinguish between instance variables and local variables.

class Dog:
    def __init__(self, name):
        self.name = name  # 'self.name' is an instance variable

    def bark(self):
        print(f"{self.name} says woof!")

dog1 = Dog("Buddy")
dog1.bark()  # Output: Buddy says woof!

class Person:
def init(self, name):
self._name = name # private attribute

# Getter method
def get_name(self):
    return self._name

# Setter method
def set_name(self, name):
    self._name = name

Important concepts in classes and objects

Getter and setter methods:

-Getter and Setter methods provide controlled access to an object's attributes. In Python, these methods are used to retrieve(getter) or modify(setter) values of private attributes, allowing for data encapsulation.
-Python doesn't have explicit get and set methods like other languages, but it supports this functionality using property decorators.

Getter: Used to access value of an attribute.
Setter: Used to modify value of an attribute.
Let’s see an example of implementing getter and setter methods using @property decorators:

class Dog:
    def __init__(self, name, age):
        self._name = name  # Conventionally private variable
        self._age = age  # Conventionally private variable

    @property
    def name(self):
        return self._name  # Getter

    @name.setter
    def name(self, value):
        self._name = value  # Setter

    @property
    def age(self):
        return self._age  # Getter

    @age.setter
    def age(self, value):
        if value < 0:
            print("Age cannot be negative!")
        else:
            self._age = value  # Setter

Explanation:

init: Initializes private attributes _name and _age.
@property name: Returns _name value.
@name.setter: Updates _name.
@property age: Returns _age value.
@age.setter: Updates _age if it’s not negative.

Method Overriding

Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. This allows subclasses to modify or extend behavior of inherited methods.

Let’s look at an example of method overriding, where a subclass changes the behavior of an inherited method:

class Animal:
    def sound(self):
        print("Some sound")

class Dog(Animal):
    def sound(self):  # Method overriding
        print("Woof")

dog = Dog()
dog.sound()

Static Methods and Class Methods

Static methods and class methods are bound to the class, not instances of the class.

Static Method: A method that does not require access to instance or class. It’s defined using @staticmethod decorator.
Class Method: A method that receives the class as its first argument (cls). It’s defined using @classmethod decorator.

Examples how to use @staticmethod and @classmethod in python

class Dog:
    @staticmethod
    def info():
        print("Dogs are loyal animals.")

    @classmethod
    def count(cls):
        print("There are many dogs of class", cls)

Dog.info()  # Static method call
Dog.count()  # Class method call

output
Dogs are loyal animals.
There are many dogs of class

@staticmethod info(): No access to instance or class; prints a general message.
@classmethod count(cls): Receives the class as cls and prints a message including the class.
Dog.info(): Calls static method.
Dog.count(): Calls class method.

Abstract Classes and Interfaces

An abstract class is a class that cannot be instantiated on its own and is designed to be a blueprint for other classes. Abstract classes allow us to define methods that must be implemented by subclasses, ensuring a consistent interface while still allowing the subclasses to provide specific implementations.

Abstract classes are defined using abc module in Python. Let’s see an example of using an abstract class to define a required method for subclasses:

from abc import ABC, abstractmethod
class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        print("Woof")

dog = Dog()
dog.sound()

For more details

Class Variables vs Instance Variables

Class Variables are shared by all instances of a class. They are defined inside the class but outside any methods.
Instance Variables are unique to each instance and are defined in init() method.

class Dog:
    species = "Canine"  # Class variable

    def __init__(self, name, age):
        self.name = name  # Instance variable
        self.age = age  # Instance variable

dog1 = Dog("Buddy", 3)
dog2 = Dog("Lucy", 2)

print(dog1.species)  # Accessing class variable
print(dog2.name)  # Accessing instance variable

Explanation:

species = "Canine": Class variable shared by all Dog objects.
self.name, self.age: Instance variables unique to each object.
dog1 = Dog(...) / dog2 = Dog(...): Creates two instances with different names and ages.
dog1.species: Accesses the class variable.
dog2.name: Accesses an instance variable.

Python Inheritance

Inheritance allows us to define a class that inherits all the methods and properties from another class.
Parent class is the class being inherited from, also called base class.
Child class is the class that inherits from another class, also called derived class.

Create a Parent Class

Any class can be a parent class, so the syntax is the same as creating any other class: Example

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

#Use the Person class to create an object, and then execute the printname method:

x = Person("John", "Doe")
x.printname()

Create a Child Class
To create a class that inherits the functionality from another class, send the parent class as a parameter when creating the child class:

class Student(Person):
  pass

- pass keyword when you do not want to add any other properties or methods to the class.

Example: Use the Student class to create an object, and then execute the printname method:

x = Student("Mike", "Olsen")
x.printname()

keywords

SNo	Keyword	Descriptions
1	_init_	_init_ method is called automatically every time the class is being used to create a new object.
2	pass	pass keyword when you do not want to add any other properties or methods to the class.

Conclusion: Discussed about object oriented programming in Python with examples

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin, github

Amazon S3 Sync - cross aws account

Srinivasulu Paranduru — Thu, 14 Nov 2024 13:55:08 +0000

Use Case : Cross Account S3 Bucket Sync

Scenario : You will be in a situation where

You don't have access to source AWS Account
You have access only destination AWS Account
You wanted to sync/copy files from source AWS Account to destination AWS Account

AWS Account details

1.Source_AWS_Account : 11112222
S3 Bucket Name : Source-Bucket-Name
KMS key attached to S3 Bucket
- Add the destination ec2 instance profile role in kms policy

2.Destination_AWS_Account : 22223333
Destination S3 Bucket Name : Destination-Bucket-Name

1.Attach the policy to Source S3 bucket

{
        "Sid": "CrossAccountSyncAccess",
        "Effect": "Allow",
        "Principal": {"AWS": "Destination_AWS_Account"},
        "Action" : [ "s3:ListBucket","s3:GetObject"],
        "Resource" :[
            "arn:aws:s3:::Source-Bucket-Name/*",
            "arn:aws:s3:::Source-Bucket-Name"
        ]
}

2.Attach the below iam policy for destination account - EC2 Instance profile role

{
        "Sid": "CrossAccountSyncAccess_Source",
        "Effect": "Allow",
        "Action" : [ "s3:ListBucket","s3:GetObject"],
        "Resource" :[
            "arn:aws:s3:::Source-Bucket-Name/*",
            "arn:aws:s3:::Source-Bucket-Name"
        ]
},
{
        "Sid": "CrossAccountSyncAccess_Destination",
        "Effect": "Allow",
        "Action" : [ "s3:ListBucket","s3:PutObject","s3:PutObjectAcl"],
        "Resource" :[
            "arn:aws:s3:::Destination-Bucket-Name/*",
            "arn:aws:s3:::Destination-Bucket-Name"
        ]
}

3.Run the below command


aws s3 sync s3://Source-BucketName  s3://Destination-BucketName

Conclusion : Process for S3 Sync cross aws accounts.
💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin

HTTP Ping on CloudPing

Srinivasulu Paranduru — Sat, 24 Aug 2024 23:37:29 +0000

Measure Cloud Latency with HTTP Ping on CloudPing

https://cloudping.info/

To measure the latency from your browser to various cloud provider datacenters, visit CloudPing. Simply click the "HTTP Ping" button to initiate the process. This tool will send HTTP requests from your browser to different datacenters of major cloud providers like AWS, Azure, and Google Cloud, and display the round-trip time (RTT) for each. Analyzing these results can help you determine the optimal cloud provider and datacenter location to ensure minimal latency and improved performance for your applications.

AWS Cloud Practioner - Certification Preparation

Srinivasulu Paranduru — Thu, 25 Jul 2024 06:48:01 +0000

1.Exam link

2.Exam Guide

Will be adding more to this in coming days.

IAC - Azure WebApp creation

Srinivasulu Paranduru — Sun, 30 Jun 2024 22:20:04 +0000

Step1: Terraform provider section

    terraform {
        required_providers {
            azurerm ={
                source = "hashicorp/azurerm"
                version="3.17.0"
            }
        }  
    }

Step2: Provider section of azurerm

Refer to article to get mentioned details required to be provided in azurerm provider - https://dev.to/srinivasuluparanduru/azure-service-principal-creation-step-by-step-approach-2a46

provider "azurerm" {
        subscription_id = ""
        tenant_id = ""
        client_id = ""
        client_secret = ""    

        features {

        }
    }

Step3: Azure resource group creation

resource "azurerm_resource_group" "example" {
        name     = "template-grp"
        location = "North Europe"
    }

Step4: Azure service plan

resource "azurerm_service_plan" "plan202407" {
        name                = "plan202407"
        resource_group_name = azurerm_resource_group.example.name
        location            = "North Europe"
        os_type             = "Windows"
        sku_name            = "F1"
    }

Step5: Creation of Azure web app

resource "azurerm_windows_web_app" "example" {
        name                = "examplewebapp"
        resource_group_name = azurerm_resource_group.example.name
        location            = azurerm_service_plan.example.location
        service_plan_id     = azurerm_service_plan.example.id

        site_config {
            always_on = false
            application_stack {
                current_stack = "dotnet"
                dotnet_Version = "v6.0"
            }
        }
        depends_on= [
                azurerm_service_plan.plan202407
        ]
    }

References:
1.Service Plan

2.Azure webapp

Conclusion : Creation of Azure webapp using IAC - Terraform
💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin

ARM Template: Azure SQL Server

Srinivasulu Paranduru — Fri, 28 Jun 2024 22:18:27 +0000

Two Resources to be created for Azure SQL Server

Azure SQL Database Server for hosting the database
SQL Database

ARM Template for Azure SQL Server

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "SQLLogin":{
            "type": "string",
            "metadata":{
                "description":"The administrator user name"
            }
        },
        "SQLPassword":{
            "type": "secureString",
            "metadata":{
                "description":"The administrator user name"
            }
        },
    },
    "functions": [],
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Sql/servers",
            "apiVersion": "2023-05-01-preview",
            "name": "sqlserver24062024",
            "location": "[resourceGroup().location]",
            "properties":{
                "administratorLogin": "[parameters('SQLLogin')]",
                "administratorLoginPassword":  "[parameters('SQLPassword')]"
            }
        },
        {
            "type": "Microsoft.Sql/servers/databases",
            "apiVersion": "2023-05-01-preview",
            "name": "[format('{0}/{1}','sqlserver24062024','appdb')]",
            "location": "[resourceGroup().location]",
            "sku":{
                "name":"Basic",
                "tier":"Basic"
            },
            "properties":{},
            "dependsOn": [
                "[resourceId('Microsoft.Sql/servers','sqlserver24062024')]"
            ]
        }
    ],
    "outputs": {}
}

Explanation for the above template

Step1:

"parameters": {
        "SQLLogin":{
            "type": "string",
            "metadata":{
                "description":"The administrator user name"
            }
        },
        "SQLPassword":{
            "type": "secureString",
            "metadata":{
                "description":"The administrator user name"
            }
        },
    }

Two variable parameters SQL Login and SQL Password has been created in ARM Template and to pass dynamic values

Step2:

 {
            "type": "Microsoft.Sql/servers",
            "apiVersion": "2023-05-01-preview",
            "name": "sqlserver24062024",
            "location": "[resourceGroup().location]",
            "properties":{
                "administratorLogin": "[parameters('SQLLogin')]",
                "administratorLoginPassword":  "[parameters('SQLPassword')]"
            }
        },

Above code is used for creating SQL Server for hosting the database and using two input parameters passed

Step3:

{
            "type": "Microsoft.Sql/servers/databases",
            "apiVersion": "2023-05-01-preview",
            "name": "[format('{0}/{1}','sqlserver24062024','appdb')]",
            "location": "[resourceGroup().location]",
            "sku":{
                "name":"Basic",
                "tier":"Basic"
            },
            "properties":{},
            "dependsOn": [
                "[resourceId('Microsoft.Sql/servers','sqlserver24062024')]"
            ]
        }

Creating sql database only after the sql server is created by mentioning the dependency in dependsOn resourceId

Step4:Go to portal.azure.com and create a new resource group as arm-sql

Step5:Search with template deployment in azure portal and select the option highlighted in the picture

Step6: Select the custom template and paste the arm template code,select resource group and pass the parameters

then review and create

Conclusion : Code used for SQL Server and database using ARM Template

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin

ARM Template: Azure Webapp

Srinivasulu Paranduru — Sun, 23 Jun 2024 23:01:41 +0000

Creation of Azure Webapp using ARM Templates

Step1: ARM Template for creating Azure Webapp

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {},
    "functions": [],
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Web/serverfarms",
            "apiVersion": "2022-09-01",
            "name": "plansrinivas2024",
            "location": "[resourceGroup().location]",
            "sku":{
                "name" :"F1",
                "capacity":1
            },
            "properties": {
                "name" : "plansrinivas2024"
            }
        },
        {
            "type": "Microsoft.Web/sites",
            "apiVersion": "2022-09-01",
            "name": "newappsrinivas2024",
            "location": "[resourceGroup().location]",
            "properties": {
                "name" : "newappsrinivas2024",
                "serverFarmId" : "[resourceId('Microsoft.Web/serverfarms','plansrinivas2024')]"
            },
            "dependsOn": [
                "[resourceId('Microsoft.Web/serverfarms','plansrinivas2024')]"
            ]
        }
    ],
    "outputs": {}
}

Step2:Go to portal.azure.com and create a new resource group as arm-template1

Step3:Search with template deployment in azure portal and select the option highlighted in the picture

Step4: Select the resource group created earlier then review and create

Step5: Select the custom template

Step6: Paste the ARM Template code

Step7: Save the plan, review and create

Step8: Go the resource group arm-template1 selected for the arm template

Step9: Delete the resource group: arm-template1 created for this exercise for avoiding expenses

References :

Conclusion : Created a Azure webapp using ARM Template

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin

Github - Organization(Demo)

Srinivasulu Paranduru — Thu, 13 Jun 2024 22:44:59 +0000

Step by Step approach to create an organization in GitHub

Step 1 : Click on the icon of your profile and which is highlighted in the below picture

Step 2 : Select organization

Step 3 : You will see list of organizations already existing and if you want you create a new organization by clicking on New Organization button

Step 4 : Then you will get a option to pick the plans

Step 5: Select the free and proceed further. GitHub Organization are globally unique and we cant able to give same organization name once again.

Step 6: Following fields are mandatory for creating a new organization

Organization name
Contact Email
The organization belongs to My personal account / A business or institution

Just accept the terms of service and click on Next button

Step 7 : If you want you can add organization members

then click on complete setup, if you are using Multi factor authentication then ask you to enter code from your MFA device

Once MFA code verified then you will see the screen shown below

Step 8 : Invite members by clicking on Invite your first member

Step 9 : Click on invite member

Step 10: Type user name in the text field shown below and it will search globally in github, select the user.

Step 11: Give the appropriate permission and then click on invite

Step 12 : User invited will get an email for confirmation and once confirmed user can able to see organization.

Conclusion:
💬 If you enjoyed reading this blog post about GitHub Organization and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin

Code with GitHub Codespaces

Srinivasulu Paranduru — Tue, 11 Jun 2024 14:11:56 +0000

Introduction : GitHub Codespaces is a fully configured development environment hosted in the cloud. By using GitHub Codespaces, your workspace, along with all of your configured development environments, is available from any computer with access to the internet.

GitHub Codespaces is an instant, cloud-based development environment that uses a container to provide you with common languages, tools, and utilities for development.

The Codespace lifecycle

GitHub Codespaces is configurable, allowing you to create a customized development environment for your project.
A Codespace's lifecycle begins when you create a Codespace and ends when you delete it. You can disconnect and reconnect to an active Codespace without affecting its running processes.
You can stop and restart a Codespace without losing the changes that you make to your project.

Create a Codespace
You can create a Codespace on GitHub.com, in Visual Studio Code, or by GitHub CLI. There are four ways to create a Codespace:

From a GitHub template or any template repository on GitHub.com to start a new project.
From a branch in your repository for new feature work.
From an open pull request to explore work-in-progress.
From a commit in a repository's history to investigate a bug at a specific point in time.

Codespace creation process

When you create a GitHub Codespace, four processes occur:

VM and storage are assigned to your Codespace.
A container is created.
A connection to the Codespace is made.
A post-creation setup is made.

Few other options we can do with codespaces
Save changes in a Codespace :

When you connect to a Codespace through the web, AutoSave is automatically enabled to save changes after a specific amount of time has passed.
When you connect to a Codespace through Visual Studio Code running on your desktop, you must enable AutoSave.

Open an existing Codespace : You can reopen any of your active or stopped Codespaces on GitHub.com, in a JetBrains IDE, in Visual Studio Code, or by using GitHub CLI.

Timeouts for a Codespace: If a Codespace is inactive, or if you exit your Codespace without explicitly stopping, the application times out after a period of inactivity and stops running.

*Internet connection while using GitHub Codespaces *: A Codespace requires an internet connection. If the connection to the internet is lost while working in a Codespace, you won't be able to access your Codespace.

Close or stop a Codespace If you exit the Codespace without running the stop command (for example, by closing the browser tab) or leave the Codespace running without interaction, the Codespace and its running processes continue during the inactivity timeout period.

Rebuild a Codespace : You can rebuild your Codespace to implement changes to your dev container configuration. For most uses, you can create a new Codespace as an alternative to rebuilding a Codespace.

Delete a Codespace : You can create a Codespace for a particular task. After you push your changes to a remote branch, then you can safely delete that Codespace.

Conclusion:
💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin

Introduction to GitHub's products

Srinivasulu Paranduru — Tue, 11 Jun 2024 13:17:25 +0000

In this module, you'll learn about the many different types of GitHub accounts, plans, and their associated features. You'll also discover how other features are licensed.

1. GitHub accounts and plans: There's a difference between the types of GitHub accounts and the GitHub plans. Here are the three types of GitHub accounts:

Personal
Organization
Enterprise

1.1 Personal accounts :

Every person who uses GitHub.com signs into a personal account (sometimes referred to as a user account). Your personal/user account is your identity on GitHub.com and has a username and profile.
Your personal/user account can own resources such as repositories, packages, and projects as well as a straightforward way to manage your permission.
Each personal account uses either GitHub Free or GitHub Pro. All personal accounts can own an unlimited number of public and private repositories, with an unlimited number of collaborators on those repositories.
If you use GitHub Free, private repositories owned by your personal account have a limited feature set.

1.2 Organization accounts:

Organization accounts are shared accounts where an unlimited number of people can collaborate across many projects at once.
Similar to personal accounts, organizations can own resources such as repositories, packages, and projects.
The personal accounts within an organization can be given different roles in the organization to grant different levels of access to the organization and its data.

1.3 Enterprise accounts : Enterprise accounts on GitHub.com allow administrators to centrally manage policies and billing for multiple organizations and enable inner sourcing between their organizations. An enterprise account must have a handle, like an organization or user account on GitHub.

GitHub plans

GitHub Free for personal accounts and organizations
GitHub Pro for personal accounts
GitHub Team
GitHub Enterprise

GitHub Free : GitHub Free provides the basics for individuals and organizations. Anyone can sign up for the free version of GitHub.

GitHub Free for personal accounts

With GitHub Free, a personal account includes:

GitHub Community Support
Dependabot alerts
Two-factor authentication enforcement
500 MB GitHub Packages storage
120 GitHub Codespaces core hours per month
15 GB GitHub Codespaces storage per month
GitHub Actions:
2,000 minutes per month
Deployment protection rules for public repositories

GitHub Free for organizations : With GitHub Free for organizations, you can work with unlimited collaborators on unlimited public repositories with a full feature set or unlimited private repositories with a limited feature set.

In addition to the features available with GitHub Free for personal accounts, GitHub Free for organizations includes:
Team access controls for managing groups

GitHub Pro : GitHub Pro is similar to GitHub Free but comes with upgraded features. It's designed for individual developers (using their personal account) who want advanced tools and insight within their repositories but don't belong to a team.

GitHub Team
GitHub Team is the version of GitHub Pro for organizations. GitHub Team is better than GitHub Free for organizations because it provides increased GitHub Actions minutes and extra GitHub Packages storage.

GitHub Enterprise
GitHub Enterprise accounts enjoy a greater level of support and extra security, compliance, and deployment controls.

You can create one or more enterprise accounts by signing up for the paid GitHub Enterprise product. When you create an enterprise account, you're assigned the role of enterprise owner. As an enterprise owner, you can add and remove organizations to and from the enterprise account.

GitHub Enterprise options :
There are two different GitHub Enterprise options:

GitHub Enterprise Server
GitHub Enterprise Cloud

The significant difference between GitHub Enterprise Server (GHES) and GitHub Enterprise Cloud is that GHES is a self-hosted solution that allows organizations to have full control over their infrastructure.

The other difference between GHES and GitHub Enterprise Cloud is that GitHub Enterprise Cloud includes a dramatic increase in both GitHub Actions minutes and GitHub Packages storage.

GitHub Mobile :GitHub Mobile gives you a way to do high-impact work on GitHub quickly and from anywhere. GitHub Mobile is a safe and secure way to access your GitHub data through a trusted, first-party client application.

You will get couple of questions in github mobile

GitHub Desktop : GitHub Desktop is an open-source, stand-alone software application that enables you to be more productive. It facilitates collaboration between you and your team and the sharing of Git and GitHub best practices within your team.

GitHub billing: GitHub bills separately for each account. This means that you receive a separate bill for your personal account and for each organization or enterprise account you own.

The bill for each account is a combination of charges for your subscriptions and usage-based billing.

**Subscriptions **include your account's plan, such as GitHub Pro or GitHub Team, as well as paid products that have a consistent monthly cost, such as GitHub Copilot and apps from GitHub Marketplace.
Usage-based billing applies when the cost of a paid product depends on how much you use the product. For example, the cost of GitHub Actions depends on how many minutes your jobs spend running and how much storage your artifacts use.

References : https://learn.microsoft.com/en-us/training/modules/github-introduction-products/

Introduction to GitHub

Srinivasulu Paranduru — Tue, 11 Jun 2024 12:53:29 +0000

Introduction:
GitHub provides an AI-powered developer platform to build, scale, and deliver secure software. Whether you’re planning new features, fixing bugs, or collaborating on changes, GitHub is where over 100 million developers from across the globe come together to create things and make them even better.

GitHub

GitHub is a cloud-based platform that uses Git, a distributed version control system, at its core. The GitHub platform simplifies the process of collaborating on projects and provides a website, command-line tools, and overall flow that allows developers and users to work together.

Core pillars of the GitHub Enterprise platform

AI - Generative AI is dramatically transforming software development as we speak.
Collaboration - Collaboration is at the core of everything GitHub does.
Repositories, Issues, Pull Requests, and other tools help to enable developers, project managers, operation leaders, and others at the same company to work faster together, cut down approval times, and ship more quickly.
Productivity: Productivity is accelerated with automation that the GitHub Enterprise Platform provides. With built-in CI/CD tools directly integrated into the workflow and makes our life easier
Security: Able to take advantage of security overview and Dependabot.
Scale:GitHub is the largest developer community of its kind. With real-time data on over 100M+ developers, 330M+ repositories, and countless deployments, we’ve been able to understand the shifting needs of developers and make changes to our product to match.

Introduction to repositories :

What is a repository? : A repository contains all of your project's files and each file's revision history. It is one of the essential parts that helps you collaborate with people. You can use repositories to manage your work, track changes, store revision history and work with others.

How to create a repository

You can create a new repository on your personal account or any organization where you have sufficient permissions.
Choose a repository visibility.
- Public repositories are accessible to everyone on the internet.
- Private repositories are only accessible to you, people you explicitly share access with, and, for organization repositories, certain organization members.
Refer the below link for step by step approach for creation of repository and adding files

https://learn.microsoft.com/en-us/training/modules/introduction-to-github/2-what-is-github

What are gists :

Similarly to repositories, gists are a simplified way to share code snippets with others.
Every gist is a Git repository, which you can fork and clone and can be either public or secret.
Public gists are displayed publicly where people can browse new ones as they’re created. Public gists are also searchable.
Conversely, secret gists are not searchable, but they aren’t entirely private. If you send the URL of a secret gist to a friend, they'll be able to see it.

What are wikis?

Every repository on GitHub.com comes equipped with a section for hosting documentation, called a wiki.
You can use your repository's wiki to share long-form content about your project, such as how to use it, how you designed it, or its core principles.
While a README file quickly tells what your project can do, you can use a wiki to provide additional documentation.
If your repository is private only people who have at least read access to your repository will have access to your wiki.

Components of the GitHub flow
Will be discussing following components of the GitHub flow:

Branches
Commits
Pull Requests
The GitHub Flow

What are branches

Branches are an essential part to the GitHub experience because they're where we can make changes without affecting the entire project we're working on.
Your branch is a safe place to good with new features or fixes. If you make a mistake, you can revert your changes or push more changes to fix the mistake. Your changes won't update on the default branch until you merge your branch.

You can create a branch using the command
git checkout -b newBranchName

What are commits
Adding a new file or updating existing file into the repository, you needed to push a commit.

A commit is a change to one or more files on a branch. Every time a commit is created, it's assigned a unique ID and tracked, along with the time and contributor. Commits provide a clear audit trail for anyone reviewing the history of a file or linked item, such as an issue or pull request.
Within a git repository, a file can exist in several valid states as it goes through the version control process:

The primary states for a file in a Git repository are:

1.Untracked: An initial state of a file when it isn't yet part of the Git repository. Git is unaware of its existence.

2.Tracked: A tracked file is one that Git is actively monitoring. It can be in one of the following substates:

Unmodified
Modified
Staged
Committed

What are pull requests?

A pull request is the mechanism used to signal that the commits from one branch are ready to be merged into another branch.
The team members submitting pull requests to merge their changes to desired git branch and needs to be assigned to Reviewers, Reviewer will review the code, add comments and developers needs to fix the changes.

The GitHub flow

The GitHub flow can be defined as a lightweight workflow that allows for safe experimentation. You can test new ideas and collaboration with your team by using branching, pull requests, and merging.

GitHub is a collaborative platform

Issues

GitHub Issues were created to track ideas, feedback, tasks, or bugs for work on GitHub.
Issues can be created in various ways, so you can choose the most convenient method for your workflow.
The different ways to create an issue from:
- a repository
- an item in a task list
- a note in a project
- a comment in an issue or pull request
- a specific line of code
- or a URL query

Creating an issue from a repository

On GitHub.com, navigate to the main page of the repository.
Under your repository name, select Issues.
Select New issue.

If your repository uses issue templates, next to the type of issue you'd like to open, select Get started.

If the type of issue you'd like to open isn't included in the available options, select Open a blank issue.

In the Add a title field, enter a title for your issue.
In the Add a description field, type a description of your issue.
If you're a project maintainer, you can assign the issue to someone, add it to a project board, associate it with a milestone, or apply a label.
When you're finished, select Submit new issue.

Discussions : Discussions are for conversations that need to be accessible to everyone and aren't related to code. Discussions enable fluid, open conversation in a public forum.

Enabling a discussion in your repository :

Repository owners and people with Write access can enable GitHub Discussions for a community on their public and private repositories.
The visibility of a discussion is inherited from the repository the discussion is created in.
When you first enable GitHub Discussions, you're invited to configure a welcome post.

On GitHub.com, navigate to the main page of the repository.
Under your repository name, select Settings.

3.Scroll down to the Features section and under Discussions, select Setup discussions.

4.Under Start a new discussion, edit the template to align with the resources and tone you want to set for your community.

5.Select Start discussion.

Create a new discussion
Any authenticated user who can view the repository can create a discussion in that repository.

Similarly, since organization discussions are based on a source repository, any authenticated user who can view the source repository can create a discussion in that organization.

GitHub platform management

Managing notifications and subscriptions :You can choose to receive ongoing updates about specific activity on GitHub.com through a subscription. Notifications are the updates that you receive for specific activity to which you're subscribed.
Subscription options : You can choose to subscribe to notifications for:
- A conversation in a specific issue, pull request, or gist.
- All activity in a repository.
- CI activity, such as the status of workflows in repositories set up with GitHub Actions.
- Repository issues, pull requests, releases, security alerts, or discussions (if enabled).
- In some instances, you're automatically subscribed to conversation. If you want you can unsubscribe.

What are GitHub Pages?

You can use GitHub Pages to publicize and host a website about yourself, your organization, or your project directly from a repository on GitHub.com.
GitHub Pages is a static site-hosting service that takes HTML, CSS, and JavaScript files straight from a repository on GitHub. Optionally, you can run the files through a build process and publishes a website.

Exercise - A guided tour of GitHub, use the below link to doing exercise

https://learn.microsoft.com/en-us/training/modules/introduction-to-github/5-platform-management

References:

GitHub Fundamentals Exam - Import topics to revise

Srinivasulu Paranduru — Sun, 02 Jun 2024 08:05:40 +0000

Alpha vs beta version in github
How to start the code spaces
Different kinds of charts - current charts vs historical charts https://docs.github.com/en/issues/planning-and-tracking-with-projects/viewing-insights-from-your-project/about-insights-for-projects
You can view everyone who has starred a public repository or a private repository you have access to. To view everyone who has starred a repository, add /stargazers to the end of the URL of a repository. For example, to view stargazers for the github/docs repository, visit https://github.com/github/docs/stargazers.
which language is used to enter the comments in github. - markdown
codespaces can be opened using
- click on +
Differences btn github.dev and codespaces
stages in github codespaces
ISSUE Templates will be in which folder?
Github teams can be created as secrets and which is available to members
11.Copilot individual vs business and what are extra features individual subscription will have?
Git hub repo topics -similar to SEO Tags

https://docs.github.com/en/issues/using-labels-and-milestones-to-track-work/managing-labels

13.What Project descriptor will automatically save when you change it?

Project name
A GitHub Project's name is the only descriptor that saves automatically.

Project description
You need to ensure your click save after writing your description to save it.

14.What's the best way to make sure you're integrating the most secure versions of your project dependencies?

Configure your package files to always use the latest versions of dependencies.

Check each project's security details closely before adding it to your dependencies by confirming its version status across multiple advisory sites.
Even if this practice helps you start off with a secure version of a given dependency, it won't ensure that you're safe from future vulnerabilities. You would need to constantly monitor every package to ensure compliance, which might be infeasible.

Enable Dependabot for your repository.
Dependabot scans your repository's dependency manifests and notifies you via pull request whenever a version you rely is marked as insecure.

15.Draft pull request - When you create a pull request, you can choose to either create a pull request that’s ready for review or a draft pull request. A pull request with a draft status can’t be merged, and code owners aren’t automatically requested to review draft pull requests.

https://learn.microsoft.com/en-us/training/modules/manage-changes-pull-requests-github/2-what-are-pull-requests

If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin and buy me a coffee