DEV Community: Shatakshi

Python Basics

Shatakshi — Thu, 26 Mar 2026 05:35:07 +0000

The only guide you'd need to deep dive into Python basics like lists, tuples, dictionaries, and so much more.

Variables and Data Types

when you run hello_world.py, we observe the following output:
suppose hello_world.py has:

print("Hello Python world!")

output:
Hello Python world!

Variables

message = "Hello Python world!"
print(message)

output:
Hello Python world!

we've added a variable named message. every variable is connected to a value which is the information associated with that variable

Naming and using Variables

Variable names can contain only letters, numbers, and underscores.
They can start with a letter or an underscore, but not with a number.
Spaces are not allowed in variable names, but underscores can be used
to separate words in variable names. For example, greeting_message works but greeting message will cause errors
Avoid using Python keywords and function names as variable names.
variable names should be short but descriptive

Strings

A string is a series of characters. Anything inside quotes is considered
a string in Python, and you can use single or double quotes around your
strings like this:

"This is string"
'This is string'

double quotes are helpful with apostrophes.

changing case in Strings:

name = "john doe"
print(name.title())

output:
John Doe

name = "John Doe"
print(name.lower())#o/p: john doe
print(name.upper())#o/p: JOHN DOE

first_name = "john"
last_name = "doe"
full_name = f"{first_name} {last_name}"
print(full_name)#o/p: john doe

f-strings are used to format the output.

first_name = "ada"
last_name = "lovelace"
print(f"Hello, {full_name.title()}!")

adding whitespace or tabs:

print("\tPython")

output:
Python

print("Languages:\nPython\nC\nJavaScript")

output:
Languages:
Python
C
JavaScript

stripping whitespace:

useful when user might enter spaces after or before any critical information.
like "name "
use .strip() method
name.lstrip(), removes whitespace from left; name.rstrip() removes whitespace from right.
name.strip() removes space from both left and right.

Numbers

integers

uou can add (+), subtract (-), multiply (*), and divide (/) integers in Python.
2 + 3
5
3 - 2
1
2 * 3
6
3 / 2
1.5

Python uses two multiplication symbols to represent exponents:
3 ** 2
9

floats

Python calls any number with a decimal point a float.

0.1 + 0.1
0.2

mixing integers and floats

When you divide any two numbers, even if they are integers that result in a
whole number, you’ll always get a float:
4/2
2.0

Lists

A list is a collection of items in a particular order. You can make a list that
includes the letters of the alphabet, the digits from 0–9, or the names of
all the people in your family. the items in your list don't have to be related in any particular way.
in Python, square brackets([]) indicate a list, and individual elements in the list are separated by commas.

names = ['aaron', 'bob', 'candice', 'daphne']
print(names)

op:
['aaron', 'bob', 'candice', 'daphne']

access item of a list using index or position.

print(names[0])
op: aaron

modifying elements in a list:

print(names)
names[1] = 'barb'
print(names)

op:
['aaron', 'bob', 'candice', 'daphne']
['aaron', 'barb', 'candice', 'daphne']

add elements to a list:

names.append('elle')
print(names)

o/p:
['aaron', 'barb', 'candice', 'daphne', 'elle']

inserting elements into a list:

You can add a new element at any position in your list by using the insert() method.

names.insert(0, 'charlie')
print(names)

o/p:
['charlie', 'aaron', 'barb', 'candice', 'daphne', 'elle']

removing an Item Using the del Statement

If you know the position of the item you want to remove from a list, you can
use the del statement.

del names[0]
print(names)

o/p:
['aaron', 'barb', 'candice', 'daphne', 'elle']

removing an item using pop() method:

The pop() method removes the last item in a list, but it lets you work
with that item after removing it.

print(names)
popped_name = names.pop()
print(names)
print(popped_name)

o/p:
['aaron', 'barb', 'candice', 'daphne', 'elle']
['aaron', 'barb', 'candice', 'daphne']
elle

removing an Item by Value

Sometimes you won’t know the position of the value you want to remove from a list. If you only know the value of the item you want to remove, you can use the remove() method.

names = ['aaron', 'barb', 'candice']
print(names)

names.remove('barb')
print(names)

o/p:
['aaron', 'barb', 'candice']
['aaron', 'candice']

NOTE:
The remove() method deletes only the first occurrence of the value you specify. If there’s a possibility the value appears more than once in the list, you’ll need to use a loop to
determine if all occurrences of the value have been removed.

organizing a list

sorting a list permanently using sort() method:

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)

o/p:
['audi', 'bmw', 'subaru', 'toyota']

cars.sort(reverse=True) sorts the list in reverse alphabetical order.

sorting a list temporarily using sorted() function:

print("Here is the original list:")
print(cars)

print("\nHere is the sorted list:")
print(sorted(cars))

print("\nHere is the original list again:")
print(cars)

o/p:
Here is the original list:
['bmw', 'audi', 'toyota', 'subaru']
Here is the sorted list:
['audi', 'bmw', 'subaru', 'toyota']
Here is the original list again:
['bmw', 'audi', 'toyota', 'subaru']

printing a list in reverse order:

print(cars)
cars.reverse()
print(cars)

o/p:
['bmw', 'audi', 'toyota', 'subaru']
['subaru', 'toyota', 'audi', 'bmw']

finding length of a list:

len(cars)#returns 4

Keep in mind that whenever you want to access the last item in a list you use the index -1. This will always work, even if your list has changed size since the last time you accessed it:
cars = ['bmw', 'audi', 'toyota', 'subaru'] &
print(cars[-1])
o/p:
'subaru'

working with lists:

Let’s say we have a list of magicians’ names, and we want to print out each name in the list. We could do this by retrieving each name from the list individually, but this approach could cause several problems.

magicians = ['alice', 'david', 'carolina'] 
for magician in magicians: 
    print(magician)

o/p:
alice
david
carolina

when writing your own for loops you can choose any name you want for temporary variable.

for cat in cats:
for dog in dogs:
for item in list_of_items:

using the range function:

for value in range(1,5):
    print(value)

o/p:
1
2
3
4

We can also use the range() function to tell Python to skip numbers in a given range. For example, here’s how we would list the even numbers between 1 and 10:

even_numbers = list(range(2,11,2)) 
print(even_numbers)

o/p:
[2,4,6,8,10]

statistics with a list of numbers:

A few Python functions are specific to lists of numbers. For example, you
can easily find the minimum, maximum, and sum of a list of numbers:
digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
min(digits)
0
max(digits)
9
sum(digits)
45

list comprehensions:

A list comprehension allows you to generate this same list in just one line of code. A list comprehension combines the for loop and the creation of new elements into one line, and automatically appends each new element.

squares = [value**2 for value in range(1,11)]
print(squares)

o/p:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

working with part of a list:

Slicing a list:

To make a slice, you specify the index of the first and last elements you want to work with.

players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
print(players[0:3])

o/p:
['charles', 'martina', 'michael']

If you omit the first index in a slice, Python automatically starts your slice at the beginning of the list:
print(players[:4])
o/p: ['charles', 'martina', 'michael', 'florence']

print(players[2:])
o/p: ['michael', 'florence', 'eli']

copying a list:

To copy a list, you can make a slice that includes the entire original list by omitting the first index and the second index ([:]).
below creates two separate lists.

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
print("My favorite foods are:")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods)

to create new list that points to same previous list and not create any new list:
friend_foods = my_foods
now any changes in my_foods will be shown in friend_foods

Tuples

sometimes you’ll want to create a list of items that cannot
change. Tuples allow you to do just that. Python refers to values that cannot change as immutable, and an immutable list is called a tuple.

A tuple looks just like a list except you use parentheses instead of square
brackets

 dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])

op:
200
50

dimensions[0] = 250 will lead to error. Python returns a Type error.

writing over a tuple

dimensions = (200, 50)
print("Original dimensions:")
for dimension in dimensions:
    print(dimension)

dimensions = (400, 100)
print("\nModified dimensions:")
for dimension in dimensions:
    print(dimension)

op:
Original dimensions:
200
50
Modified dimensions:
400
100

if statements

The following short example shows how if tests let you respond to special situations correctly.

cars = ['audi', 'bmw', 'subaru', 'toyota']
for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

op:
Audi
BMW
Subaru
Toyota

every if statement is an expression that can be evaluated as
True or False and is called a conditional test. Python uses the values True and False to decide whether the code in an if statement should be executed. If a conditional test evaluates to True, Python executes the code following the if statement. If the test evaluates to False, Python ignores the code following the if statement

requested_topping = 'mushrooms'
u if requested_topping != 'anchovies':
    print("Hold the anchovies!")

op:
Hold the anchovies!

checking multiple conditions

type following in cmd line:
age_0 = 22
age_1 = 18
age_0 >= 21 and age_1 >= 21
False

checking if a value is in a list:

requested_toppings = ['mushrooms', 'onions', 'pineapple']
'mushrooms' in requested_toppings
True
'pepperoni' in requested_toppings
False

checking if value not in list:

banned_users = ['andrew', 'carolina', 'david']
user = 'marie'
if user not in banned_users:
    print(user.title() + ", you can post a response if you wish.")

Marie, you can post a response if you wish.

simple if statements

if conditional_test:
do something

if-else statements:

age = 17
if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")
else:
    print("Sorry, you are too young to vote.")
    print("Please register to vote as soon as you turn 18!")

op:
Sorry, you are too young to vote.
Please register to vote as soon as you turn 18!

if-elif-else chain:

age = 12
if age < 4:
    print("Your admission cost is $0.")
elif age < 18:
    print("Your admission cost is $5.")
else:
    print("Your admission cost is $10.")

op:
Your admission cost is $5

note: you can use multiple elif blocks if required. you can also omit the else block completely.

styling your if-statements:

if age > 4 is better than if age>4. Such spacing does not affect the way Python interprets your code; it just makes your code easier for you and others to read.

Dictionaries

Python’s dictionaries, allow you to connect pieces of related information

alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])

op:
green
5

working with dictionaries:

A dictionary in Python is a collection of key-value pairs. Each key is connected to a value, and you can use a key to access the value associated with that key.
A key’s value can be a number, a string, a list, or even another dictionary.
In fact, you can use any object that you can create in Python as a value in a dictionary.

accessing values in a dictionary

alien_0 = {'color': 'green'}
print(alien_0['color'])

op:
green

adding new key-value pair:

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)

op:
{'color': 'green', 'points': 5, 'y_position': 25, 'x_position': 0}
remember order doesn't matter in Python dictionary

modifying values in a dictionary:

alien_0 = {'color': 'green'}
print("The alien is " + alien_0['color'] + ".")
alien_0['color'] = 'yellow'
print("The alien is now " + alien_0['color'] + ".")

op:
The alien is green.
The alien is now yellow.

removing key-value pairs:

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']
print(alien_0)

op:
{'color': 'green', 'points': 5}
{'color': 'green'}

looping through a dictionary:

user_0 = {
    'username': 'efermi',
    'first': 'enrico',
    'last': 'fermi',
    }
for key, value in user_0.items():
    print("\nKey: " + key)
    print("Value: " + value)

method items(), which returns a list of key-value pairs.
The for loop then stores each of these pairs in the two variables provided.
Key: last
Value: fermi
Key: first
Value: enrico
Key: username
Value: efermi

looping through all keys in a dictionary:

for name in favorite_languages.keys():
    print(name.title())

op:
Jen
Sarah
Phil
Edward

note:
Looping through the keys is actually the default behavior when looping through a dictionary, so this code would have exactly the same output if you wrote:
for name in favorite_languages:
rather than . . .
for name in favorite_languages.keys():

method favorite_languages.keys() returns list of keys

looping through dictionaries keys in order:

One way to return items in a certain order is to sort the keys as they’re returned in the for loop. You can use the sorted() function to get a copy of the keys in order:

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
    }
for name in sorted(favorite_languages.keys()):
    print(f"{name.title()}, thank you for taking the poll.")

op:
Edward, thank you for taking the poll.
Jen, thank you for taking the poll.
Phil, thank you for taking the poll.
Sarah, thank you for taking the poll.

looping through all values in a dictionary:

print("The following languages have been mentioned:")
for language in favorite_languages.values():
    print(language.title())

op:
The following languages have been mentioned:
Python
C
Python
Ruby

nesting

a list of dictionaries:

alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
    print(alien)

op:
{'color': 'green', 'points': 5}
{'color': 'yellow', 'points': 10}
{'color': 'red', 'points': 15}

list in dictionary:

pizza = {
    'crust': 'thick',
    'toppings': ['mushrooms', 'extra cheese'],
    }
print("You ordered a " + pizza['crust'] + "-crust pizza " + "with the following toppings:")

for topping in pizza['toppings']:
    print("\t" + topping)

op:
You ordered a thick-crust pizza with the following toppings:
mushrooms
extra cheese

a dictionary in a dictionary:

users = {
    'aeinstein': {
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton'
    },
    'mcurie': {
        'first': 'marie',
        'last': 'curie',
        'location': 'paris',
    }
}

for username, user_info in users.items():
     print("\nUsername: " + username)
     full_name = user_info['first'] + " " + user_info['last']
     location = user_info['location']

     print("\nFull name: " + full_name.title())
     print("Location: " + location.title())

op:

user input and while loops:

how the input() function works:

message = input("Tell me something, and I will repeat it back to you: ")
print(message)

op:
Tell me something, and I will repeat it back to you: Hello everyone!
Hello everyone!

using int() to accept numerical inputs

age = input("how old are you?")
op:
how old are you? 21

print(age) returns '21'. '21', the string representation of the numerical value entered.
so always convert numerical input to int.

age = int(age)
print(age) # returns 21

while loops:

The for loop takes a collection of items and executes a block of code once for each item in the collection. In contrast, the while loop runs as long as, or while, a certain condition is true.

current_number = 1
while current_number <= 5:
    print(current_number)
    current_number += 1

op:
1
2
3
4
5

using break to exit a loop:

To exit a while loop immediately without running any remaining code in the loop, regardless of the results of any conditional test, use the break statement.

using continue in a loop:

Rather than breaking out of a loop entirely without executing the rest of its code, you can use the continue statement to return to the beginning of the loop based on the result of a conditional test.

Functions:

def greet_user():
     """Display a simple greeting."""
     print("Hello!")
greet_user()

def to inform Python that you’re defining a function. This
is the function definition, which tells Python the name of the function and, if applicable, what kind of information the function needs to do its job. The parentheses hold that information. In this case, the name of the function is greet_user(), and it needs no information to do its job, so its parentheses are empty.

the lines that follow def greet_user() make up the body of the function. the first line is a comment called a docstring. Docstrings are enclosed in triple quotes, which Python looks for when it generates documentation for the functions in your programs.
last line is calling the function but as no arguments are needed so parentheses are empty.

passing information to a function:

op:
Hello, Jesse!

arguments vs parameters:

the value that we pass inside the parentheses are termed as argument. both arguments and parameter are used interchangably, even though they have different meaning.

The variable username is an example of parameter, a piece of information the function needs to do its job. the value 'jesse' is an example of argument.

Passing arguments:

Because a function definition can have multiple parameters, a function call may need multiple arguments. You can pass arguments to your functions in a number of ways. You can use positional arguments, which need to be in Functions the same order the parameters were written; keyword arguments, where each argument consists of a variable name and a value; and lists and dictionaries
of values. Let’s look at each of these in turn.

Positional arguments:

When you call a function, Python must match each argument in the function call with a parameter in the function definition.

def describe_pet(animal_type, pet_name):
    """Display information about a pet."""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('hamster', 'harry')

op:
I have a hamster.
My hamster's name is Harry.

When we call describe_pet(), we need to provide an animal type and a name, in that order. For example, in the function call, the
argument 'hamster' is stored in the parameter animal_type and the argument 'harry' is stored in the parameter pet_name

order matters in positional arguments:

if we do describe_pet('harry', 'hamster') we would get unexpected result because now animal_type is 'harry' and pet_name is 'hamster'

keyword arguments:

A keyword argument is a name-value pair that you pass to a function. You directly associate the name and the value within the argument, so when you pass the argument to the function, there’s no confusion.

in this we'd do: describe_pet(animal_type='hamster', pet_name='harry')

the order of keyword arguments does not matter

NOTE: When you use keyword arguments, be sure to use the exact names of the parameters in the function’s definition.

Default values:

when writing a function, we can define default values. if an argument for a parameter is provided in the function call, python uses the argument value. if not, it uses the parameter's default value.

def describe_pet(pet_name, animal_type='dog'):
"""Display information about a pet."""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(pet_name='willie')

Python still interprets this as a positional argument, so if
the function is called with just a pet’s name, that argument will match up with the first parameter listed in the function’s definition. This is the reason the first parameter needs to be pet_name.

NOTE: When you use default values, any parameter with a default value needs to be listed after all the parameters that don’t have default values. This allows Python to continue interpreting positional arguments correctly.

equivalent function calls:

# A dog named Willie.
describe_pet('willie')
describe_pet(pet_name='willie')
# A hamster named Harry.
describe_pet('harry', 'hamster')
describe_pet(pet_name='harry', animal_type='hamster')
describe_pet(animal_type='hamster', pet_name='harry')

return values:

A function doesn’t always have to display its output directly. Instead, it can process some data and then return a value or set of values. The value the function returns is called a return value.

 def get_formatted_name(first_name, last_name):    
     """Return a full name, neatly formatted."""
     full_name = first_name + ' ' + last_name
     return full_name.title()

musician = get_formatted_name('jimi', 'hendrix')
print(musician)

op:
Jimi Hendrix

passing an arbitrary number of arguments:

consider a function that builds a pizza. It needs to accept a
number of toppings, but you can’t know ahead of time how many toppings a person will want. The function in the following example has one parameter, *toppings, but this parameter collects as many arguments as the calling line provides:

def make_pizza(*toppings):
    """Print the list of toppings that have been requested."""
    print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

op:
('pepperoni',)
('mushrooms', 'green peppers', 'extra cheese')

The asterisk in the parameter name *toppings tells Python to make an empty tuple called toppings and pack whatever values it receives into this tuple.

mixing positional and arbitrary arguments:

If you want a function to accept several different kinds of arguments, the parameter that accepts an arbitrary number of arguments must be placed last in the function definition.
Python matches positional and keyword arguments first and then collects any remaining arguments in the final parameter.

example:

using arbitrary keyword arguments:

The following example takes in a first and last name, but it accepts an arbitrary number of keyword arguments as well:

The
double asterisks before the parameter **user_info cause Python to create an empty dictionary called user_info and pack whatever name-value pairs it receives into this dictionary.

Storing your functions in Modules:

One advantage of functions is the way they separate blocks of code from your main program.You can go a step further by
storing your functions in a separate file called a module and then importing that module into your main program. An import statement tells Python to make the code in a module available in the currently running program file.

This allows efficient use of functions.

importing an entire module:

a module is a file ending in .py that contains the code you want to import into your program. we make a module that has function make_pizza(). to make this module we'll remove everything from this file pizza.py except the function make_pizza():

now, we'll make a separate file called making_pizzas.py in same directory as pizza.py. This file imports the module we just created and then makes two calls to make_pizza():

When Python reads this file, the line import pizza tells Python to open the file pizza.py and copy all the functions from it into this program. All you need to know is that any function defined in pizza.py will now be available in making_pizzas.py.
To call a function from an imported module, enter the name of
the module you imported, pizza, followed by the name of the function, make_pizza(), separated by a dot. This code produces the same output
as the original program that didn’t import a module:

importing specific functions:

from pizza import make_pizza

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

using as to give a function an Alias:

from pizza import make_pizza as mp
mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

if the name of function you're importing might conflict with existing name in your program you can use short , unique alias - an alternate name similar to nickname for the function.

using as to give module an alias:

You can also provide an alias for a module name. Giving a module a short alias, like p for pizza, allows you to call the module’s functions more quickly.

import pizza as p
p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

importing all functions in a module:

You can tell Python to import every function in a module by using the asterisk (*) operator:

from pizza import *
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

The asterisk in the import statement tells Python to copy every function from the module pizza into this program file.
However, this is not the best approach.
The best approach is to import the function or functions you want, or import the entire module and use the dot notation.

Styling functions:

You need to keep a few details in mind when you’re styling functions.

Functions should have descriptive names, and these names should use lowercase letters and underscores. This helps you and others understand your code better.
Every function should have a comment that explains concisely what the function does. This comment should appear immediately after the function definition and use the docstring format.
If you specify a default value for a parameter, no spaces should be used on either side of the equal sign: def function_name(parameter_0, parameter_1='default value')
The same convention should be used for keyword arguments in function calls: function_name(value_0, parameter_1='value')
If your program or module has more than one function, you can separate each by two blank lines to make it easier to see where one function ends and the next one begins.
All import statements should be written at the beginning of a file.

The concept remains is OOPs(Object Oriented Programming) in Python and will be shared in next blog.

Source of this article: Python Crash Course Book by Eric Matthes
if you have come this far Thank you so much! You can leave a feedback of any kind below.

lessons learnt from CTF Linux Challenge - part 1

Shatakshi — Fri, 06 Mar 2026 13:17:07 +0000

following the https://github.com/learntocloud/linux-ctfs . i explored and learnt so many new things that i'd like to share with you all.

What is CTF Linux Challenge?

CTF Linux Challenge is designed for folks to get hands-on experience with Linux. so one does not only know the theory but knows how to implement them in the long run. In this challenge we as learner have to "Capture The Flag" where we type-in commands in Linux terminal to complete assigned tasks and when we enter the correct command we provoke the flag, verify it and move to next challenge.

little overview of what all is needed before starting:

1.Version Control:

method used to keep track and control every change we make to a file/folder/software/product that we're building
commonly used version control system is Git, which is really fast, reliable, scalable Open-Source version control system
GitHub is a cloud platform that uses Git as its core technology
learn how to practice and understand from here

2.Cloud CLI Setup:

first is to create a cloud account:

but why do we need it? so we could request services like servers and perform the work that we wish to do. - more as we move along this blog.
now create account one either one of the platforms i.e AWS, Azure, Google Cloud. we will work with AWS.

understand the console: provides every information about your cloud account at one place, the servers that are currently active, paused and everything we need to know about our account or to request any cloud service
learn why CLIs are better than clicking: manual clicking and hovering is much tiresome , so CLIs help in overcoming that issue
we install respective CLI

3.IAC(Infrastructure as a Code):

method used to manage infrastructure with configuration file rather than GUI. it helps in manage, change and build infrastructure in safe, consistent, way by defining resource configurations that we can version using VCS like GitHub
Terraform is most commonly used IAC engine

Key terms:

terraform init: initializes working directory with terraform configuration files
terraform apply: a core component of the Terraform workflow used to execute the actions proposed in a Terraform plan, provisioning or updating your infrastructure to match your configuration files

4.SSH

SSH(secure shell) sets up a connection between a user's device and a faraway machine, often a server.
SSH can transmit any arbitrary data over a network, and SSH tunneling can be set up for a myriad of purposes.

work in a nutshell:
we spin up an AWS ec2 instance(a computer faraway). then use ssh to connect to it(access it). now we can do many things like installing an OS (linux os) on this computer, sending a local file to remote server etc.

Background check:

first is to prepare the setup where it is recommended to use WSL for Windows users. WSL(Windows Subsystem for Linux) is like a machine where you can install Linux instead of dual-booting your system in order to avoid memory issues and prevent your system from over-loading.

Now you can install a Linux distribution of your choice from windows package manager, I installed Ubuntu.
wsl is like using a linux os, with direct terminal opened for you. from where you can check what folders, files we have on our system , download files etc. Soo cool!!😎✨

we open wsl ubuntu terminal, clone the github repo i.e https://github.com/learntocloud/linux-ctfs .
then do: cd linux-ctf/aws

we have to install terraform on this wsl as well otherwise terraform commands won't work.

then we do terraform init
now after this we need to create access key for iam user(concept in AWS cloud). iam user is used so we do not have to use root user.

i created one iam user named 'rg', i create access keys so now we have both access key and security access key.
now in the ubuntu wsl terminal i write the three commands:

then we perform terraform apply. now an EC2 instance is up and running.

remember to delete the access keys and both instance when done with session to avoid charges.

then i enter the commands:

then we see:

and it begins!!🥳

start from here to find tasks: tasks list

Challenge 1:

first task is find hidden file in ctf_challenges

ls -a : used to list all files in a directory(including hidden files)
cat filename : used to read content of a file

Challenge 2: Locate a file containing "secret" in its name under your home directory

learnt to use commands like:
find pathname -type f -name <pattern>
cd directory: change directory
ls directory: list directory content
cat filename: list file content

Challenge 3: Find and read an unusually large file in /var/log

commands helpful:
ls -lh: list file with human-readable sizes
tail -n 100 filename: View the last 100 lines.
tail filename: view the end of the file

This blog turned into a long one. if you're still here, thank you! i hope this proves helpful in some way.

next challenges will be covered in part - 2.
Any feedback is greatly appreciated.

Master Bash Scripting: A Practical Guide for Systems & Automation

Shatakshi — Wed, 18 Feb 2026 14:33:16 +0000

Stop running the same 10 commands manually every day. I put together this summary to help you automate your workflow in minutes. So to make such monotonous task more interesting.

what is bash scripting?

A bash script is a file containing a sequence of commands that are executed by the bash program line by line. It allows you to perform a series of actions, such as navigating to a specific directory, creating a folder, and launching a process using the command line.

By saving these commands in a script, you can repeat the same sequence of steps multiple times and execute them by running the script.

Bash scripting is a powerful and versatile tool for automating system tasks, managing system resources, and performing other routine tasks in Unix/Linux systems

Terms like "bash" and "Shell" are used interchangeably. but difference must be understood.
shell is a program that provides command line interface for interacting with the operating system.

a shell or command-line looks like:

the shell accepts commands from user and displays the output

In the above output, shatakshi@truamateur is the shell prompt. When a shell is used interactively, it displays a $ when it is waiting for a command from the user.

If the shell is running as root (a user with administrative rights), the prompt is changed to #.
some other shells are, C shell (csh), and Z shell (zsh). Each shell has its own syntax and set of features, but they all share the common purpose of providing a command-line interface for interacting with the operating system.

Some bash commands:

date: display current date
pwd: display the current working directory
echo: Prints a string of text, or value of a variable to the terminal.
cat: View contents of a file

how to create and execute bash scripts

script naming conventions

By naming convention, bash scripts end with .sh. However, bash scripts can run perfectly fine without the sh extension.

Adding the Shebang

Bash scripts start with a shebang. Shebang is a combination of bash # and bang ! followed by the bash shell path. This is the first line of the script. Shebang is simply an absolute path to the bash interpreter.

Below is an example of the shebang statement.
#!/bin/bash

creating your first bash script:

our first script prompts the user to enter a path. in return, its content will be listed.

create a file named run_all.sh using code command. here im using vs code to create, modify and execute the bash script.
move to the directory that you wish to create this script in using cd filename and then:

code run_all.sh

add the following content in the file and save it:

#!/bin/bash
echo "Today is " `date`

echo -e "\nenter the path to directory"
read the_path

echo -e "\n you path has the following files and folders: "
ls $the_path

Line #1: The shebang (#!/bin/bash) points toward the bash shell path.
Line #2: The echo command is displaying the current date and time on the terminal. Note that the date is in backticks.
Line #4: We want the user to enter a valid path.
Line #5: The read command reads the input and stores it in the variable the_path.
Line #8: The ls command takes the variable with the stored path and displays the current files and folders.

executing the bash script:

to make the script executable assign executable rights:

chmod u+x run_all.sh

-chmod is used to change the ownership of file for current user: u
-+x adds the execution rights to the current user. This means that the user who is the owner can now run the script.
-run_all.sh is the file we wish to run.

then we run the script using the following method:

sh run_all.sh

some side notes:
if you are struggling to get correct path when prompted by shell script then you can either enter into the directory that you wish to enter path of and then just enter .
or
you can just drag and drop the folder without entering into the directory.
one thing to note is that you must be in the directory that has run_all.sh script. then only the above points work.

example:

here my l2c folder has the run_all.sh file.

Bash Scripting Basics

comments in bash scripting: we use the `#` to begin comments in script file

Variables and data types in bash:

Variables let you store data. You can use variables to read, access, and manipulate data throughout your script.

There are no data types in Bash. In Bash, a variable is capable of storing numeric values, individual characters, or strings of characters.

in bash, we can set and use the variable in following ways:

assign value directory
name=shatakshi
assign a new variable an existing variable value. a $ is needed to use already assigned variable:
my_name=$name

example:

Variable naming conventions:

variable can either begin with a letter(A-Za-z) or an underscore(_)
variable can contain a letter, number or an underscore
variables are case-sensitive
reserved keywords should not be used like if, elif,then etc

input and output in bash scripts

reading input

we read user input using the read command

#!/bin/bash 

echo "What's your name?" 

read entered_name 

echo -e "\nHi $entered_name hope you are having good time learning bash scripting"

output:

Command line arguments

we can pass arguments while entering the execute command. the arguments are denoted by $1, $2 and so on.
example:

#!/bin/bash
echo "Hello, $1"

output:

Displaying output:

print to terminal:
echo "hii"
write to a file:
echo "This is some text." > output.txt
append to file:
echo "More text." >> output.txt

Conditional statements (if/else)

Expressions that produce a boolean result, either true or false, are called conditions. There are several ways to evaluate conditions, including if, if-else, if-elif-else, and nested conditionals.

Syntax:

if [[ condition ]];
then
    statement
elif [[ condition ]]; then
    statement 
else
    do this by default
fi

the keyword fi is used to terminate an if statement.

We can use logical operators such as AND -a and OR -o to make comparisons that have more significance.

if [ $a -gt 60 -a $b -lt 100 ]
Let's see an example of a Bash script that uses if, if-else, and if-elif-else statements to determine if a user-inputted number is positive, negative, or zero:

#!/bin/bash

echo "Please enter a number: "
read num

if [ $num -gt 0 ]; then
  echo "$num is positive"
elif [ $num -lt 0 ]; then
  echo "$num is negative"
else
  echo "$num is zero"
fi

looping and branching in bash

while loop:

while loop checks a condition and keeps executing till condition remains true.

in example below, ((i += 1)) is used to increment variable i on each iteration and also checks the condition

#!/bin/bash
i=1
while [[ $i -le 10 ]] ; do
   echo "$i"
  (( i += 1 ))
done

for loop:

just like while loop, just different syntax:

#!/bin/bash

for i in {1..5}
do
    echo $i
done

the expansion starts at number 1 and ends at 5.
the loop will run exactly 5 times.

How to Debug Bash Scripts

Debugging and troubleshooting are essential skills. Bash scripts are also prone to errors and unexpected behavior. In this section, we will discuss some tips and techniques to overcome these challenges.

Set the set -x option

by using set -x command at the beginning of the script, it enables debugging mode, which causes Bash to print each command that it executes to the terminal, preceded by a + sign. This can be helpful in identifying where errors are occurring in your script.

#!/bin/bash

set -x

# Your script goes here

example:

Check the exit code

When Bash encounters an error, it sets an exit code that indicates the nature of the error. You can check the exit code of the most recent command using the $? variable. A value of 0 indicates success, while any other value indicates an error.

#!/bin/bash

# Your script goes here

if [ $? -ne 0 ]; then
    echo "Error occurred."
fi

example code:

#!/bin/bash

ls /some/folder/that/doesnt/exist

if [ $? -ne 0 ]; then
    echo "Error occurred"

fi

output:

note: "read" command almost always works. use something like timeout on "read" like:

#!/bin/bash
echo "enter a number"
read -t 3 num

if [$? -ne 0]; then
   echo "error occurred"
fi

output:

the timeout here occurs after 3 seconds. dont type anything, and the output is shared.

Use echo statements

echo command is very useful to understand exactly where the problem is happening and what values are being passed to variables.

#!/bin/bash

# Your script goes here

echo "Value of variable x is: $x"

# More code goes here

Use the set -e option

If you want your script to exit immediately when any command in the script fails, you can use the set -e option. This option will cause Bash to exit with an error if any command in the script fails.

#!/bin/bash

set -e

# Your script goes here

note the difference, as soon as the command read -t 3 num fails the flow stops and exits immediately without reaching the next line of $? variable

Thanks for reading through! i hope this blog has helped in some way or other to better understand the bash scripting in tldr way.
the source of this summary is: Bash Scripting Tutorial

Feedbacks are appreciated. Thanks!
connect here: https://x.com/truamateur
email: shatakshi.gupta85@gmail.com

Functions in JavaScript

Shatakshi — Wed, 13 Oct 2021 12:06:45 +0000

If you have been into programming for a while then you must have come across functions. So there might be a little possibility that you would be very well aware about functions. But i would like to share the knowledge that I have of Functions. So here it goes hear me out-

Well if you ask me about functions then I would say that functions is one of my favorite topics in programming because they not only help us in writing clean, and efficient
code but also because Functions are a piece of code that enable us to call that block of code anywhere in the program thus refraining to not write that block of code again in the same program.
If you did not understand what functions are then you just need to have some patience and keep reading.

Declaration of functions in JavaScript

Functions without any argument
The functions that do not accept any argument are functions without arguments.

function learnJS() {
    console.log("Attention reader! You need to learn JavaScript now!");
}

//calling learnJS function
learnJS();

The above code gives output

Attention reader! You need to learn JavaScript now!

Functions with argument
The functions in which we pass on some value that would be accepted by some parameter that is present in function declaration. See below for better context

function square(x) {
    let sq = x * x;
    console.log(sq);
}

//calling function
square(4);

Difference between Arguments and Parameters
Argument - These are the values that we pass while calling the function and these act as the actual value that the variable would contain that we have declared while declaring or defining the functions.

Parameter - These are the variables that are use to store values that we have passed as argument while calling the function. These variables are declared while declaring the function.

What if a function accepts an argument but we do not pass an argument? To understand that go through below example

function sayHi(person) {
    console.log(`hi ${person}`);
}
//calling the function
sayHi();

Output of above code would be

hi undefined

In case of string argument.

Methods in JavaScript
Methods are same as functions in Javascript except that these are the type of function that are already defined and we can access those functions simply by calling them and passing the relevant argument if it is required to pass.
For instance refer the following example
array.push() is a predefined method/function which accepts an integer argument.

Multiple arguments in JavaScript Functions

function greet(firstname, lastname) {
    console.log(`Hello there! ${firstname} ${lastname}`);
}

//calling function
greet('Shatakshi', 'Gupta');

Above code will produce the following output

Hello there! Shatakshi Gupta

Order matters! Now if you call the above function in the following manner

greet('Gupta', 'Shatakshi');

Then it would lead to following result

Hello there! Gupta Shatakshi

And that simply implies that while dealing with multiple arguments order matters.

The Return Keyword

It is use to store/save value so that we can use it in future.
When return keyword is encountered, function execution stops and the value is returned and no next line is ever executed.
Refer the following code

function add(a,b) {
    return a+b;
}
let total = add(5,6);
console.log(total);

And that will print as 11!

Functions Scope

variables declared inside a function cannot be used outside a function.

function printValue(a) {
    a = a+1;
    console.log(a);
}

printValue(4);
console.log(a);

This will give following output

5
VM1082:7 Uncaught ReferenceError: a is not defined

Another example of variables that can not be used outside functions.

function printScore(value) {
    let totalScore = 0;
    totalScore += value; //short form of totalScore = totalScore + value
}

printScore();
console.log(totalScore);

Now that would produce the exact same error like before because variables like 'let' and 'const' are block scoped hence can not be used outside except its own function.

Block Scoped Functions

variables inside loops like it if, for, or while loop cannot be accessed outside that block

let value = 8;
if (value > 5) {
    let  score = value;
    console.log(`my score is ${score}`);
    const yay = "im greater than 5";
}

console.log(yay);

And the result of that is

my score is 8
VM1106:8 Uncaught ReferenceError: yay is not defined
    at <anonymous>:8:13

if we declare our variables with var keyword, we can access that variable outside of that block because var is a globally scoped keyword while let and const are block scoped keywords.

Lexical Scoped Functions

function inside another function or nested functions

function lexicalScope() {
    const randomNums = [34, 78, 88, 25]
    function anotherFunc() {
        for (let nums of randomNums) {
            console.log(`Numbers in the array are: ${nums}`);
        }
    }
    anotherFunc();
}

lexicalScope();

Which would give output as

Numbers in the array are: 34
Numbers in the array are: 78
Numbers in the array are: 88
Numbers in the array are: 25

FUNCTION EXPRESSION

In this variables store functions
Functions act as value that are assigned to variables
Function expression without any argument

let JsIsAwesome = function() {
    console.log("JavaScript is awesome. Indeed!");
}

//calling the function 
JsIsAwesome();

The output of above expression would be

JavaScript is awesome. Indeed!

Function Expression with Argument

let add = function (x,y) {
 console.log(x+y);
}

//calling the function
add(5,6)

The output of above expression would be

FUNCTION STATEMENT / FUNCTION DECLARATION

function sayHi() {
 console.log("hello there!");
}

ANONYMOUS FUNCTIONS

These are the functions used in function expressions.
These basically have no name.

FIRST CLASS FUNCTIONS
The ability to use functions as values, pass functions as arguments & return function as a value are known as first class
functions.

HIGHER ORDER FUNCTIONS

The functions in which we can pass function as argument

function basicJavascript(func) {
 func();
 console.log("But first I should clear my basics of JavaScript");
}

function learnJavascript() {
 console.log("I need to learn JavaScript");
}

basicJavascript(learnJavascript);

OUTPUT

I need to learn JavaScript
But first I should clear my basics of JavaScript

The ones in which we can return function as value

function func() {
    let random = Math.random();
        if (random < 0.5) {
        return function() {
        console.log("thats too low!");
        }
    } else {
        return function() {
        console.log("thats too high!");
        }
    }
}
func();

ARROW FUNCTIONS

These are type of functions that are syntactically alternative to a regular function expression
In this we remove function keyword and use an arrow to show that there is an function ahead

const add = (x, y) => {
 return x + y;
}

now how would you call this function in the following way

add(1,7)

that would print out to be 8!

Arrow functions with no arguments

const print = () => {
 console.log("This function says me to only print");
}

// calling above function
print();

OUTPUT:
This function says me to only print

Arrow functions implicit return
if you have a single statement inside arrow functions that needs to be evaluated like printing or a simple calculation then u can do that in the following way:

let add = (x, y) => x+y

now above statement is the same as you just wrote the one with curly braces!

CALLBACK FUNCTIONS

Function that is passed into another function or the function that is passed as an argument to another is called a callback function.
These are the type of functions that execute only when a certain function or statement has finished executing.
Refer below code

console.log("Hellooo..");

setTimeout(() => {
    console.log("well this got printed after 5sec and that is an example of CallBack concept!");
}, 5000);

console.log("Do you know CallBacks help us play with the async nature of js?");

And that gives us the output

Hellooo..
Do you know CallBack helps us play with the async nature of js?
undefined
well this got printed after 5sec and that follows CallBack concept!

CONCLUSION
Okay so that was a lot to grasp. But no worries you can go through this article whenever you feel like referring. If you have come this far then Congrats 🎉 you just learned some really important topics in JavaScript.
I'm so proud of you and wish you nothing but the best in your life as you keep learning and growing.

Thanks for reading and hope you have great day! :)
You can connect with me on Twitter

Kubernetes components made easy! - Part 1

Shatakshi — Thu, 26 Aug 2021 17:44:54 +0000

Kubernetes is an open-source container-orchestration system for automating computer application deployment, scaling, and management. This blog will help you know better about the main components of a Kubernetes Cluster.
Starting from the very basic unit of a Kubernetes Cluster:

Pod:

smallest unit of a Kubernetes cluster
usually preferred to contain only a single container

Node:

unit greater than pod
consists of group of pods

Cluster:

Collection of Nodes

IP addresses:
Let us suppose you have an application that connects to a Database. Now Both of these components your application and Database are pods. Both these pods make use of IP addresses to connect to each other for managing the application.

Now what if the IP address of one of the pods changes due to some reason like the container in the Pod could not get enough space allocation for it to work or simply any problem occurred and now the container is destroyed and along with it, it's IP address also gets lost which is used by your application to connect to the DB(Database).
Now you create a new container and hence you need a new IP address and you now have to again change the configuration for managing IP addresses and much more.

This costs a lot of time and effort due to this problem the concept of Services was introduced which replaces IP addresses or we can say it provides a permanent IP address which won't change even if your container gets destroyed.

Your application is now working fine and you want to access your application on your system and for this you need to get it on local host and the service would provide the IP address somewhat like:
https://124.89.101.2:8080 which u don't prefer to see in place of:
https://my-app.com
Here comes the role of Ingress which basically converts your not so good looking IP address to some preferred IP address which then forwards this IP address to services which is then used for communication between different dependent pods.

Now suppose your dependent pod URL that is the service URL which is used to interact with other pods changes or you change it due to any good reason then you will need to change it in all files, configuration files and many more to avoid any difficulties in the future. But this can be really tedious task to do, so this task is done by Config-Map which basically stores the URL of services that are used and are dependent and in this you can simply change the URL anytime without any stress of modifying all the files.

Now there can be some confidential data as well that you don't want others to see, that data is stored in Secrets like user_id, user_password and much more confidential data.

Deployments
Deployment for creating replicas is usually called a blueprint of pods and in actual we deal with deployments only and not actual pods. We connect multiple deployments through services which acts as a load balancer & when one pod/deployment/replica dies it(service) forwards the request of the user to another blueprint/deployment.

Now we can not create deployments for databases & that is because every Database has some state and and if we create deployments of Databases then we need to keep track of every pod like which pod is currently reading data from data storage and which one is writing data to that storage and all this mechanism needs to be synchronized, maintained among every replica to avoid data inconsistency which is not an easy task so here StatefulSets are used.

StatefulSets is used for creating replicas, working or
managing applications like Databases to avoid data inconsistency.

Referred resources:

If you have come this far then I really appreciate your efforts and I hope you got a little idea about the main components of a Kubernetes cluster. Thanks for reading and have a great day! :)

Beginner's guide to Chaos Engineering

Shatakshi — Thu, 19 Aug 2021 02:37:37 +0000

Have you ever wondered what firms/companies do or would do when their product or service that they are offering to customers suffers from Downtime?

Well, if not then this article will definitely help you in knowing about it in depth.

So taking the concept from scratch what is Chaos and why are we talking about it?

Let's suppose you create an application and deploy it on an online platform accessible to the public and all of a sudden your project/application gets recognized and you observe a lot of traffic over your application, people start using it as it might be helpful to them in some or the other way. Now you had no idea that something like this would happen and due to this you never took into account that whether you should scale your project or not.
As the traffic increases more and more each day, you observe that people are not able to access your application as some issues are being faced by a lot of people.

Now here comes the concept of scaling your application so that more and more people can access your application. So you now scaled your application to a large extent, still some issues were being faced that some microservices of your application were down and people were not able to update/make changes.

Here comes the concept of testing which is done while updating/scaling your application so that people can easily make use of it. We test our applications/system so that people in the near future do not face any difficulties while making use of your application.
Testing is done to ensure our system can withstand unexpected disruptions.

What we do is we inject Chaos in our applications to test for resiliency.
Chaos can also be explained as a technique that helps us to get to know that how our application would react when so and so changes are made in the system.

Resilience is the crucial concept of our testing as through this we can know that whether our application can stay afloat during downtimes.
One good example can be when there are sales on E-commerce websites be that for any occasion or literally any thing. Then there is huge amount of customers each day during the sale due to the low prices.

Chaos is used in four steps while testing your application-

Step 1:
We basically observe and take into account how your system is behaving in normal state or in the steady state

Step 2:
We make a hypothesis how our system would behave during Vulnerability/chaotic state and in steady state

Step 3:
This hypothesis further leads to experiments that help us know about what changes our system needs in chaotic state

Step 4:
And this cycle continues till our system starts getting adapted to the experiments provided.

Chaos Engineering also has some states that help us better understand the state of our application. These states are listed below-

STEADY STATE OF AN APPLICATION-
Identify the steady state that how your application behaves during normal state.

INTRODUCTION OF FAULTS-
Another state is the deliberate introduction of a fault. This is done so as to test that how would our application react when it would experience a downtime

STEADY STATE REGAINED OR NOT-
If we see no difference after introducing a fault then our application is in healthy state or resilient state

WEAKNESS FOUND-
If we do observe that the application isn't working or stopped working then that is called as weakness

FIXING & AGAIN PASS THE FAULT-
In this we try to fix the weakness or vulnerability and pass the faults again for testing of resiliency

RESILIENT-
This process continues till we observe that our application has achieved resiliency and is no longer in weak state even after introduction of multiple faults

These all the states help us better know about our system and how we should scale and test them so that it can be easily accessed by people.
Chaos Engineering is one of the most important and interesting concepts in the field of testing as through this once can inject chaos in application/system to test for Resiliency.

Here including some of the resources to get you started with Chaos if you found this article interesting:

1.Quick Start-Chaos Engineering

2.Chaos Community

3.CNCF Slack for #project-chaos-mesh channel

Thank you so much for reading this article! Hope you found it interesting. Have a Great day ahead! :)

How To Make Your First Contribution As a Beginner In Open Source

Shatakshi — Tue, 25 May 2021 06:09:00 +0000

Open Source is very powerful that is encouraging and empowering, but students today are not really aware of what power the Open Source world really holds, how motivating the community is, and what opportunities it brings as most of the students do not know much about Open Source and how engaging the community is.
If you are here then Kudos to you for making your first step into the amazing Open Source world.👏

Now with no more delays let's get right into what Open Source really is, how inspiring the community is, what all opportunities it brings to students and how you also can make a little change to the community and empower others too.

What is Open Source?

Open Source, when you think of this term what might come to your mind is anything that is freely available, well that's what it exactly is.
Open Source can be explained as source code of any software that you might be currently using or will be using in the near future as the Open Source thing is only going to grow more and more and which is made available to everyone so that every single one of us can have a look, help making it better if we think that particular software is missing this feature and if we add that feature to it then the software would become much more better than before.
So, I hope you got a little idea of how things work in Open Source world.
Some of the most commonly used open source softwares are Mozilla Firefox, VLC Media player, Image editing tool Gimp and the list is simply endless.
As now we have known so much about open source let's get right into how you can help make a change and make your first contribution.

If you know about Open Source I believe that you might be aware of GitHub to, but if do not let's know a bit about Git and GitHub to.

What is Git?

Git is a version control system that lets you manage and keep track of your source code history.

What is GitHub?

GitHub is a web-based Git version control repository hosting service. GitHub provides all the functionalities of Git along with some of its own features as well.

Now we will be covering some steps so that you can download Git on your system and get started to contributing to your first repository.

We will be downloading Git bash, through Git bash you will be able to type Git commands that make source code management easier through versioning and commit history.

Step 1

Download Git on your system from here.

Step 2

After downloading, you need install it on your system. So for installation click on run then click on next, after that do not change the Destination location and simply click on next, after that while selecting components check the boxes with 'In the Quick Launch' and 'On the desktop'. After that keep on clicking next.

Step 3

After installation, uncheck the box with 'View release notes' and check the one with 'Launch Git bash'

Getting started

To get involved with Open source projects you need to have a basic understanding of how git commands work and how one has to use those commands to make a valuable contribution.

Reference for git commands:

Contributing

1. Choose a project that interests you

This is the most crucial and salient part of your contribution. You need to find a project that interests you and that matches your skillset. And this need not to be a very large contribution. For someone who is just starting with open source it is highly recommended to start with Fixing typos, modifying documentation files in large and even small projects. Well as of now if you are reading this you might be looking to contribute as a beginner. first-contributions can prove to be a really good start for you. Hacktoberfest-practice and awesome-for-beginners can really help you as well.

Finding a project

You can filter the issues tab according to your skillset let's suppose you have basic knowledge of Java and you want to contribute to projects written in Java language then you can search good first issues by going to the issues tab and searching the issues with labels like 'label:"good first issue" ' and 'language:Java'

In a similar manner you can filter issues by replacing 'good first issues' with 'first-timers-only', 'beginner', 'good-first-bug' and 'easy'.

2. Forking the project

Fork will create a copy of the repository in your GitHub account so that you can make changes to the project.

3. Cloning the project

Go to your own GitHub account and there you will see a forked version of that project under your account. Now click into this repository that is forked and and we will make a copy of it on your machine by hitting the code button.

Copy the HTTPS URL.
Open your terminal or git bash window.

Move to the location on your computer where you want to create a copy of this project.

Run the following command:

git clone https://github.com/userid/first-contributions.git

Substitute your GitHub username for userid.

You now have a local copy on your computer.

The folder on your computer will have the same name as the remote repository on GitHub.

Create a new branch by running the following command:

git checkout -b add-your-name

cd into first-contributions.
Then cd into Contributors.

Now open the Contributors file in your Text editor.

Add your name alphabetically into the file along with your GitHub profile URL.

Now run git status in the terminal

You should see this:

Changes that you made need to be staged and committed.
So to add your changes run the following:

git add .

Now your changes have been added and you are needed to commit your changes and push it to your remote repository that is on your GitHub account.

To commit your changes run the following:

git commit -m "add-your-name-to-contributors-list"

It is always important to write a good commit message while working in large codebase projects. So there you have to take care of writing an explainable and not too long message that describes what your contribution fixes and which can be easily understood by the maintainers of the project.

Now you have to push your changes to your remote repository so run the following command:

git push origin branch-name

When you will head over to your GitHub account you will be able to see a message with compare and pull request button.
Click on the button and now you will be creating a pull request that will be visible to maintainers of the project.

After that click on create pull request

Yay!!!🎉 You just created your first pull request.
Thanks for following along. You are awesome and I am so proud of you!

NOTE: While contributing to any large codebase project or even smaller you can always ask your doubts in Slack channels, mailing lists that are there to help you.

Open Source community is really encouraging and inspiring and inclusive so if you ever feel overwhelmed about such large projects that you want to contribute to you can always ask your doubts and queries in mailing lists and slack channels.
Remember do not give up ever, people in different groups are more than happy to help solve your queries and all you got to do is reach out to them and explain your query.

If you have followed along then Congratulations 🎉 on starting your Open Source journey because that is really awesome and I really appreciate your efforts.

Also mentioning some other resources that will help you in your Open Source, programming journey and the amazing Computer Science Field :

Hope you found this helpful. If you did then do share this with people who are beginners like you and want to make their first contribution in Open source.

Thanks for reading and hope you have a great day!!😃

Say Hello! Twitter