DEV Community: Munyalo Meshack

Understanding SQL Joins with Practical Examples (Beginner Friendly Guide)

Munyalo Meshack — Sun, 08 Mar 2026 04:54:16 +0000

In real world databases, data is rarely stored in a single spreadsheet. Instead it is organized across multiple related tables. SQL provides powerful tools such as joins to combine and analyze this data efficiently.

What is SQL Joins.

SQL joins are used to combine data from two or more tables based on a related column between them. In most relational databases, information is stored across multiple tables and joins allow us to bring this data together for analysis.

SQL joins are useful in:

Matching records using common columns such as IDs or keys
Create meaningful results from separate tables
Retrieve related data stored across multiple tables
Improve data analysis by combining related information

By using joins allows analysts to work with connected datasets instead of isolated tables, making it easier to uncover insights and answer business questions.

Types of SQL Joins

SQL joins are categorized into different types based on how data in the different tables are matched and combined.

Inner join
Left join (left outer join)
Right join (Right outer join)
Full outer join
Cross join
Self join
Natural join

INNER JOIN

An INNER JOIN is used to return only the rows that have matching values in both tables being joined. If a record exists in one table but does not a corresponding match in the other table, it will not appear in the result.

In simple terms, INNER JOIN shows only data that exists in both tables.
This works by comparing a common column (usually an ID or Key) between the two tables and returning the rows where the values match.

Below we have the general syntax for an INNER JOIN.

syntax:
SELECT table_1.column_1, table_2.column_2, ...
FROM table_1 INNER JOIN table_2
ON table_1.matching_column = table_2.matching_column;

Example:
First we view the contents of the tables:

select * from employees e ;

select * from departments d ;

Now join the employees table with the departments table.

--> Join the employees table to department table

SELECT employees.name, departments.department_name 
FROM employees INNER JOIN departments 
ON employees.employee_id = departments.department_id ;

In this example, we use the department_id column, which acts as a unique identifier (Primary Key/Foreign Key relationship), to connect the two tables.

The result will return employees along with their department names, but only for employees whose department_id exists in both tables.

NOTE:

INNER JOIN focuses on the intersection of two tables, meaning only the records that match in both tables are included in the result set.

LEFT JOIN (LEFT OUTER JOIN)

A LEFT JOIN, also called a LEFT OUTER JOIN, returns all rows from the left table and the matching rows from the right table. If there is no matching record in the right table, the results will still include the row from the left table, but the columns from the right table will contain NULL values.

In simple terms, LEFT JOIN keeps everything from the left table and only the matching data from the right table

Unlike INNER JOIN, which only returns matching rows from both tables, LEFT JOIN keeps all rows from the left table even if no match exists in the right table.

Here is the general syntax from a LEFT JOIN.

SELECT table_1.column_1, table_2.column_2, ...
FROM table_1
LEFT JOIN table_2
ON table_1.matching_column = table_2.matching_column;

Example
First, we view the contents of the tables:

SELECT * FROM employees;

SELECT * FROM departments;

Now we perform the LEFT JOIN:

--> LEFT JOIN the employees table to departments table

SELECT employees.name, departments.department_name, employees.salary
FROM employees
LEFT JOIN departments
ON employees.department_id  = departments.department_id;

Below is a snippet image of how the query in our example will turn out;

Explanation

The query returns all employees from the employees table.
For the employees with a matching department_id in the department table, the department name is displayed.
For employees with no matching department, the department_name column will show NULL as of the case with Eve in the example above.

NOTE:

A LEFT JOIN returns all records from the left table and the matching records from the right table. If no match is found, NULL values are returned for columns from the right table.

RIGHT JOIN (RIGHT OUTER JOIN)

A RIGHT JOIN, also called a RIGHT OUTER JOIN, returns all rows from the right table and the matching rows from the left table. If there is no matching record in the left table, the result will still include the row from the right table, but columns from the left table will contain NULL values.

In simple terms, RIGHT JOIN keeps everything from the right table and only the matching data from the left table.

Here is the general syntax from a RIGHT JOIN.

SELECT table_1.column_1, table_2.column_2, ...
FROM table_1
RIGHT JOIN table_2
ON table_1.mathing_column = table_2.matching_column;

Example
First, we view the contents of the tables:

SELECT * FROM employees;

SELECT * FROM departments;

Now we perform the RIGHT JOIN:

--> RIGHT JOIN the employees table to departments table

SELECT employees.name, departments.department_name, employees.salary
FROM employees
RIGHT JOIN departments
ON employees.department_id = departments.department_id ;

Below we have an image showing how our query turns out.

Explanation
The query returns all departments from the departments table because it is the right table in the join.

If an employee belongs to a department, the employee name and salary will be displayed.
If a department has no employee assigned, the employee columns will contain NULL values as in the above example.

NOTE:

A RIGHT JOIN returns all records from the right table and the matching records from the left table. If no match is found, NULL values are returned for columns from the left table.

FULL OUTER JOIN

A FULL OUTER JOIN returns all rows from both tables, combining the results of a LEFT JOIN and a RIGHT JOIN. If arow from one table does not have a matching row in the other table, the missing side will contain NULL values.

In simple terms, FULL OUTER JOIN keeps everything from both tables and fills in NULL where there is no match.

Here is a general syntax for a FULL OUTER JOIN:

SELECT table_1.column_1, table_2.column_2, ...
FROM table_1
FULL OUTER JOIN table_2
ON table_1.matching_column = table_2.matching_column;

Example
We can view the contents in our tables (optional):

SELECT * FROM employees;

SELECT * FROM departments;

Now we can perform the FULL OUTER JOIN:

--> FULL OUTER JOIN the employees table to departments table

SELECT employees.name, departments.department_name, employees.salary
FROM employees
FULL OUTER JOIN departments
ON employees.department_id = departments.department_id;

Below we have an image showing our query's output.

Explanation
The query returns all records from both the employees and departments tables.

If an employee belongs to a department, the employee's information and department name are displayed.
If an employee has no matching department, the department_name column will show NULL.
If a department has no employees assigned, the employee related columns(name, salary) will show NULL.

In summary, the result contains three types of rows:
Matching rows from both tables
Employees without departments
Departments without employees

NOTE:

A FULL OUTER JOIN returns records from both tables. When there is no match between the tables, the result set fills the missing side with NULL values.

CROSS JOIN

A CROSS JOIN returns the Cartesian product of two tables. This means that each row from first table is combined with every row from the second table.

Cartesian product is the result of ** combining every row from one table with every row from another table**.

So CROSS JOIN takes each row in the first table and pair it with every row from the second table, producing all possible combinations of rows

The general syntax of CROSS JOIN:

SELECT table_1.column_1, table_2.column_2, ...
FROM table_1
CROSS JOIN table_2;

Now, unlike other joins, CROSS JOIN does not require a matching condition ON clause.

We can view the contents of the tables (optional):

SELECT * FROM employees;
SELECT * FROM departments;

We can now perform the CROSS JOIN:

SELECT employees.name, departments.department_name
FROM employees
CROSS JOIN departments;

Below we have two images, the first one is the CROSS JOIN query and the second one is the results we get after running the query.

Explanation
In this query, every employee is combined with every department.

For example, if the employees table has 3 rows and the departments table has 4 rows, the result will contain:

3 x 4 = 12 rows

So, each employee will appear once for every department as we have seen in the query result image 2 above.
This happens because CROSS JOIN creates all possible combinations between the two tables.

NOTE:

A `CROSS JOIN returns the Cartesian product of two tables, meaning every row from the first table is combined with every row from the second table.

NATURAL JOIN

A NATURAL JOIN is a type of SQL join that automatically joins two tables based on column with the same name and compatible data types in both tables.

Unlike other joins, you do not need to explicitly specify the join condition using an ON clause. The database automatically detects the common columns and uses them to perform the join.

In simple terms, `NATURAL JOIN matches rows from two tables using columns that share the same name.

NATURAL JOIN general syntax is;

SELECT column_1, column_2, ...
FROM table_1 
NATURAL JOIN table_2;

Example
In our two tables employees and departments we have a common column department_id.

Image for employees table;

Image for departments table;

We perform NATURAL JOIN to our two tables

SELECT name, department_name
FROM employees 
NATURAL JOIN departments;

Below is an image showing the results of our query

Explanation
Both tables contain the column department_id, which has the same name and compatible data type.
When the NATURAL JOIN is executed, SQL automatically uses this column to match rows between the two tables.
The result will include only rows where the department_id exists in both tables.

Eve is not included because she has no department_id.
The Finance department is not included because no employee belongs to it.

NOTE:

A NATURAL JOIN automatically joins tables using columns with the same name in both tables and returns only matching rows.

SELF JOIN

A SELF JOIN is a type of join where a table is joined with itself. This is useful when you want to compare or relate rows within the same table.
In self join, the same table is treated as two separate tables by using table aliases, allowing you to compare records within that table.

In simple terms, a SELF JOIN allows rows in a table to be related to other rows in the same table.

The general syntax of SELF JOIN;

SELECT a.column_name, b.column_name
FROM table_name a
JOIN table_name b
ON a.common_column = b.common_column;

In this case, a and b are aliases representing two instances of the same table.

Example
Let us consider an employees table where each employee may have a manager. The manager is also listed in the same table.

To find each employee and their manager, we can use a SELF JOIN.

SELECT  
    e.name AS employee,
    m.name AS manager
FROM employees e 
LEFT JOIN employees m
ON e.manager_id = m.manager_id ;

Below is an image to show the above query and the output.

Explanation
In the query;

The employees table is referenced twice.
e represents the employee
m represents the manager

The join condition:
e.manager_id = m.employee_id
matches each employee with their corresponding manger.

Alice and Diana have no manager, so the value is NULL.
Other employees are matched with their respective managers.

NOTE:

A `SELF JOIN joins a table with itself, allowing relationships between rows within the same table to be analyzed.

Common use Cases for a SELF JOIN
SELF JOIN are useful when working with hierarchical or relational data,such as:

Employees and their managers
Organizational structures
Parent child relationships
Comparing rows within the same dataset

Conclusion

SQL joins are essential for working with relational databases because data is usually stored across multiple related tables. By using different types of joins, we can combine and analyze this data effectively.

In this article we covered:

INNER JOIN
LEFT JOIN
RIGHT JOIN
FULL OUTER JOIN
CROSS JOIN
NATURAL JOIN
SELF JOIN

Each join type serves a different purpose depending on how the data should be matched and returned.

Understanding SQL joins is a foundational skill for anyone working with databases, data analysis, backend development, or data engineering.

Getting Started with Data Analysis Using Microsoft Excel (Beginner’s Guide)

Munyalo Meshack — Thu, 12 Feb 2026 09:46:33 +0000

You happen to have a spreadsheet full of sales data, just rows and columns. You do not need SQL or Python to start analyzing data. In this article we are going to use Microsoft Excel to perform data analysis step by step.

What is Data Analysis.

This is the process of inspecting, cleaning, transforming, and modeling data with the goal of discovering useful information, informing conclusions and supporting decision making.
In simple terms, data analysis helps us answer questions like:
Which product sells the most?
What is the average rating?
Are discounts increasing sales?

Why use Excel for Data Analysis?

For years Excel has remained a data powerhouse when it comes to data analysis. Even in an era where we have popular tools like Python, Power Bi, R, Excel is still one of the most essential tools for data analysts.
One of the greatest benefits of Excel is that you do not need prior coding experience and you can learn the basics quickly. It is also one of the primary tools that is used in data collection during data entry.
Whether you are cleaning data, analyzing trends, or presenting insights, Excel offers flexibility, ease of use, and a vast range of functions that other tools often can’t match in day-to-day business scenarios.

Understanding Excel Data (Rows, Columns, Cells)

Excel is made of rows and columns which make up a grid like structure in the spreadsheet. Each cell in the grid is identified by a unique combination of a row number and a column letter.
In the image below the column and row header are displayed, the intersection of each columns and rows make a unique cell.

Columns are identified using letter and they are vertically positioned. While rows are identified numerically and are positioned horizontally. In the example of the image above, the first column is A and the first row is 1. That makes the first cell to be identified as A1.

Preparing Data for Analysis.

Now that we are familiarizing ourselves with how excel looks, it will feel much better to do so while getting a test of what it does and the powerful features it provides under the hood.

Understanding basics of Data Analysis in Excel is the first step towards making informed decisions. In the next sections, we’ll start working with real data and explore how Excel helps us clean, analyze, and summarize information efficiently.

Understanding Your Dataset

In Excel data is usually represented in the form of a dataset. This is a regular Excel spreadsheet containing rows and columns, with data depending on the field of origin.

The first job of any data analyst when presented with any form of data is to study the data and understand the type of data they have. It can be from sales, health records, telecommunication, Human Resource, etc.
Below is an example of a simple HR dataset stored in Excel.

This is a simple Excel dataset with columns showing employee details and rows filled with individual employee data.

Once you are familiar with the dataset, the next step is to perform some basic data cleaning.

Basic Data Cleaning in Excel

Data cleaning is a very essential step of data analysis. Before we start deriving any insights or making sense of our data, we need to make sure we have a clean and consistent data to work with.

There are a few things we need to check before proceeding with analysis.

Identifying missing values

Having data with missing values is common in any dataset. This can be caused by many factors during data collection, such as omission, forgetfulness, or unclear data requirements.

It is our first responsibility to make sure that the missing values are worked on to prevent getting wrong analysis.
There are several ways to deal with missing values;

Remove rows with missing values
This works only if the number of rows with missing values will not have any major effect when deducted from the dataset.
Fill them with N/A, NULL or UNKNOWN
These are situations where the data is non-numerical and cannot be computed i.e. personal details like Phone number, City, etc.

Here we can use the Find and Replace.

Select the column with missing values
Press Ctrl + H or on the Home ribbon at the far right click on Find & Select. Check on the image below.

The below image will appear for Find and Replace

On the Find what field, type the value you want to replace. In the Replace with field, type the new value.

Filling the missing values with mean, median or average. For numerical columns we can calculate the mean, median or average of the whole column and fill it in the missing values in the column.

Removing Duplicates

In many instance we will get duplicates in our datasets. Maybe employees with same employee_id or products with the same product_id. This results to having wrong analysis

Removing duplicates helps in remaining with cleaner data and in return gives correct outputs like count, mean, median, average, sum.

In Excel, duplicates can be removed by selecting the dataset, going to the Data tab, and clicking Remove Duplicates.

Formatting Columns It is very crucial that we have columns formatted with the correct data type it represent. We select an individual column by clicking on top of the column where it is labelled with an alphabetical letter. On the Home ribbon go to the Number segment and choose the correct data type.

Click on on the small arrow at bottom right of the segment to get the datatype selection table as shown below.

You can now select on the given datatypes as per the one in your column.

The benefit of this is that it makes calculations and analysis easier and more accurate.. We can be able to use data given in every column correctly as per it's datatype.

Renaming Columns Columns names are like street names to guide us as we maneuver through the dataset. They help us know where to find specific data and what it represents.. This means having the correct names for our columns is very important in our data analysis process.

To rename a column we double click the cell with the column name and then we can type in an appropriate name.

At this point, our data is clean, consistent, and ready for analysis. In the next section, we will begin exploring the data using basic Excel tools such as sorting, filtering, and simple formulas.

Sorting and Filtering Data

Now that we have clean data with no missing values or duplicates, we are ready to dive a little deeper into the world of data analysis.

We begin this by sorting our data.
Sorting in Excel is the process of arranging data in a specific order; alphabetically, numerically, or by date in either ascending or descending order.
There are different ways we can sort data in Excel. The first way is by clicking at the top of a column header to select it.

Go to the Home tab on the ribbon and, on the far right under the Editing group, click Sort & Filter.

Click on the dropdown arrow to get more options on how to sort as illustrated in the image below.

In the Sort & Filter options we have two major options to choose from;

Sort A to Z / Oldest to Newest – This is Ascending Order
Sort Z to A / Newest to Oldest – This is Descending Order

NOTE:
We can follow the above procedure when we want to sort one or a few columns in our dataset.

The second way to sort your data is by formatting the dataset to a table.
You:

Click on any cell in the dataset
Go to the Home ribbon
Under styles segment; click on Format as Table

When you click it, you will see multiple table styles to choose from. Check the image below for reference.

By making the data to a table, we will get a dropdown button at the right corner of every column. The button will give us options to choose from when we need to sort the column as depicted in the image below.

You may have noticed that the Sort & Filter options are grouped together in Excel. Both in the first example and the second one. This makes it easier for us to also filter or use the filter function on our dataset when needed.

Filtering in Excel is the process of displaying only the rows of data that meet specific conditions, while temporarily hiding the rest of the data.

In simple terms, filtering helps us focus on the information we are interested in without deleting or permanently removing any data.
For example:

Showing only products with a rating above 4
Viewing employees from a specific department
Displaying sales made in a particular month

When a filter is applied, Excel does not remove any data. Instead, it hides the rows that do not match the selected criteria. This allows us to analyze specific parts of a dataset more efficiently.

Filtering is especially useful when working with large datasets where manually searching through rows would be time-consuming.

In the image below we see how to find the filter function just as we did we the sort.

We can also filter by formatting the dataset to a table first. This way we use the arrows in the column header of every column to apply the preferred filter as shown in the image below.

We can uncheck the boxes of the items we want to filter out so that we only remain with what we want to view.

With sorting and filtering, we can now explore our dataset from different perspectives and uncover meaningful insights more efficiently.

Basic Excel Formulas

As we have seen, Excel is not only a spreadsheet used to store data in rows and columns, but it is also a very powerful tool when it comes to manipulating data.

One of the best parts of Excel is its ability to perform computations on your data. This is possible because of the wide range of built-in formulas available in Excel. We are going to look at a few basic formulas such as SUM, AVERAGE, and COUNT.

SUM

To write any formula in Excel, we must start with an equals sign =.
This tells Excel that we want to perform a calculation in the selected cell.

SUM refers to the addition of two or more numbers.
For example: 2 + 2 = 4
In Excel we can either type the values manually or use cell representation.

In a new cell, type:

=5 + 5
Press Enter This will return the result 10.

We can also use the SUM() function.

=SUM(5+5) 
=SUM(5,5)

Both formulas will return the correct result.

Using Cell References

This becomes more useful when working with data inside a spreadsheet.

=SUM(B2,F2)

This adds the values in cells B2 and F2

Summing a Range of Cells

We can also calculate the total of a range of values in either column or rows.

=SUM(B2:F4)

This calculates the total of all values within that rectangular range.

If you want to sum values vertically in a single column:

=SUM(B2:B6)

This adds all the values from B2 to B6
With that we can now confidently use the SUM() function.

AVERAGE() Function

AVERAGE is the sum of a group of numbers divided by the total count of those numbers. It represents the central or typical value in a given dataset.

In Excel, the AVERAGE() function calculates the mean of selected cells automatically.

Just like the SUM() function, in AVERAGE() function we can either type the values manually inside the formula or use cell referencing.
Example:

=AVERAGE(66,72,80,62,60)

This will returns 68 as the average

Using Cell Referencing

=AVERAGE(B2:B6)

This calculate the average of values in cells B2 to B6.

The formula works both vertically(columns) and horizontally(rows).
Example:

=AVERAGE(B3:F3)

This would calculate the average of values across a row.

COUNT() Function

COUNT is used to count the number of cells that contain numeric values in a dataset.

In Excel, the COUNT() function counts only numbers. It ignores text and empty cells.

Example:

=COUNT(66,60,72,80,78,)

This will return 5 because there are five numeric values.

Using Cell Referencing

Example:
=COUNT(B2:F2)
This counts how many cells in the range B2 to F2 contain numbers.

Important:
If a cell contains text, it will not be counted by COUNT().
(If you want to count all non-empty cells, you would use COUNTA() instead.)

MAX() Function

MAX returns the largest value in a selected range of numbers.

=MAX(66,60,72,80,78)

This will return 80 because it is the highest value.

Using Cell Referencing

=MAX(B2:F2)

This returns the largest number in cells B2 to F2.

MIN() Function

MIN returns the smallest value in a selected range of numbers.

=MIN(66,60,72,80,78)

This will return 60 because it is the smallest value.

Using Cell Referencing

=MIN(B2:F2)

This returns the smallest number in cells B2 to F2.

MEDIAN() Function

MEDIAN returns the middle value in a dataset when the numbers are arranged in order.

If there is:

An odd number of values → it returns the middle number.
An even number of values → it returns the average of the two middle numbers.

Example:

=MEDIAN(66,60,72,80,78)

This returns 72

Using Cell Referencing

Example:

=MEDIAN(B2:F2)

This calculates the median of values in cells B2 to F2.

Conclusion

Microsoft Excel remains one of the most accessible and powerful tools for data analysis. Without writing a single line of code, we can clean data, organize it, explore trends, and perform meaningful calculations using built-in functions.

In this article, we learned:

What data analysis is
Why Excel is still relevant in modern data workflows
How to understand datasets in rows and columns
Basic data cleaning techniques
How to sort and filter data for better exploration

Essential formulas such as SUM, AVERAGE, COUNT, MAX, MIN, and MEDIAN.

These are foundational skills for anyone beginning their journey into data analysis.

As you grow more comfortable with Excel, you can explore more advanced tools such as Pivot Tables, conditional formatting, charts, and eventually transition into tools like SQL, Power BI, or Python.

Every data journey starts somewhere, and Excel is one of the best places to begin.

If you are learning data analysis, I will be sharing more beginner friendly guides on Excel and transitioning into tools like SQL and Python. Stay tuned.

Git for Beginners: Tracking Changes, Push and Pull Explained

Munyalo Meshack — Sun, 18 Jan 2026 18:13:34 +0000

Git and GitHub

Introduction

If you are new to programming, data analysis, or tech in general, Git and GitHub can feel confusing at first.
People throw around terms like repository, commit, push, and pull often without explaining what they actually mean.

This article is written for absolute beginners, including:

People with no technical background

People who have never used Git before

People who just want a simple, clear explanation

In this first part, we will focus only on:

What GitHub is
What Git is and why we need it
Creating a GitHub account
Installing Git on Windows, macOS, and Linux
Connecting Git to your GitHub account

What Is GitHub?

GitHub is a cloud based platform that allows developers to store, manage, and collaborate on code using a version control system called Git.

In simple terms GitHub is a website where people store and share code online.

Think of GitHub like:

Google Drive, but for code
Dropbox, but for projects
A backup location for your work

With GitHub, you can:

Save your projects online
Access them from any computer
Share your work with others
Collaborate with teammates

Even if you are working alone, GitHub is useful because it keeps your work safe.

What Is Git?

Git is a distributed version control system (VCS) used to track changes in source code during software development.

Git is a tool that runs on your computer.

Git helps you:

Track changes in your files
Save different versions of your work
Go back to an earlier version if something breaks

Imagine writing a document and being able to say:

“Take me back to how this looked yesterday.”

That’s what Git does but for code and files.

How to Create a GitHub Account

Creating a GitHub account is free and easy.

Step-by-step:

Go to https://github.com
Click Sign up
Enter:

Email address
Username
Password

Verify your email
Complete the setup steps

You now have a GitHub account.

What Is Git (the Software)?

Before we install it, one important clarification:

GitHub → a website
Git → a program you install on your computer

Installing Git allows your computer to:

Track changes
Communicate with GitHub

How to Download and Install Git

On Windows

Go to https://git-scm.com
Click Download for Windows
Open the downloaded file
Click Next on most screens (default options are fine)
Finish installation

After installing, you will have Git Bash, a terminal used to run Git commands.

On macOS (MacBook)

Option 1: Using the Installer

Go to https://git-scm.com
Download Git for macOS
Open the installer and follow the steps

Option 2: Using Terminal

Open Terminal and type:

git --version

If Git is not installed, macOS will prompt you to install it.

On Linux

Open a terminal and run:

For Ubuntu / Debian:
sudo apt install git

For Fedora:
sudo dnf install git

After installation, confirm:
git version

How to Connect Git to Your GitHub Account

To connect Git on your computer to GitHub online, Git needs to know who you are.

Step 1: Set Your Name

git config --global user.name "Your Name"

Step 2: Set Your Email

git config --global user.email "youremail@example.com"

Use the same email you used for GitHub
This does not upload anything yet. It only tells Git:

"This work belongs to me."

Understanding a Repository

What Is a Repository?

A repository (or repo) is a centralized location where project files and resources are stored. Repositories typically exist in the cloud, allowing for collaboration, version control and remote access to code modules and software packages.

In simple terms:
A repository (repo) is a project folder that Git is tracking.

When a folder becomes a repository:

Git starts watching files inside it
Git can track changes over time
Git can save versions of your work

A repository contains:

Your project files (code, text, images)
A hidden folder called .git (Git’s brain)

Note: If a folder does not have a .git folder, Git is not tracking it.

Local vs Remote Repository

There are two types of repositories you’ll work with:

Local Repository

Lives on your computer
Where you write and edit code
Created using the terminal

Remote Repository

Lives online (GitHub)
Used for backup and collaboration

Creating Your First Repository

Step 1: Open Git Bash / Terminal

Navigate to the folder where you want your project.

cd Documents

Create a new project folder:

mkdir my-first repo
cd my-first-repo

At this point:

The folder exists
Git is not tracking it yet

Step 2: Initialize Git

To tell Git to start tracking this folder, run:

git init

You will see something like:

Initialize empty Git repository

Congratulations, this folder is now a Git repository

What Actually Happened?

When you ran git init, Git:

Created a hidden .git folder
Started tracking this directory
Prepared to record changes You normally never touch the .git folder manually.

Checking Repository Status:

Run:

git status

This command:

Confirms you are inside a repository
Shows tracked and untracked files At this stage it may say:

No commits yet

That is expected.

Adding a File to the Repository

Create a simple file e.g:

touch index.html

Check status again:

git status

You will see:

Untracked files:
  index.html

Meaning:

"Git sees the file, but is not tracking it yet."
This is where change tracking begins.

How Git Tracks Changes

We have created a repository and saw that Git can “see” files.
Now we will answer an important question:

How does Git know what changed, and what to save?
Git does this using two main areas:

The working directory
The staging area

Understanding these two will make Git feel logical instead of confusing.

The Working Directory

The working directory is simply:

Your project folder as you normally use it.

This is where you:

Write code
Edit files
Delete or rename files

Example:

You open index.html
You change some text
You save the file

At this point:

The file is changed
Git notices the change
But Git has not saved it yet

Note: Git does not auto-save your work.

Why Git Doesn’t Auto-Save

Beginners often ask:

“Why doesn’t Git just save changes automatically?”

Because Git is designed to:

Let you decide what to save
Let you group related changes together
Avoid saving broken or unfinished work

You control when a version is created.

Checking Changes with `git status`

To see what Git knows about your project, run:

git status

Example output

modified: index.html

This means:

"This file changed, but it is not ready to be saved yet."

Git is watching, but waiting for instructions

The Staging Area

The staging area is where you tell Git:

“These are the changes I want to save.”
_

It acts as a preparation zone between editing and saving.

Think of it like:

Selecting files before uploading
Choosing photos before posting
Packing items before traveling

Nothing is saved permanently yet.

Why `git add` Exists

To move changes from the working directory to the staging area, you use:

git add index.html

Or to add everything:

git add

What this tells Git:

"I want these changes included in the next save."

How Git knows what changed

Git compares:

The last saved version
The current version of your files

It then records only the differences, not the entire file.

This makes Git:

Fast
Efficient
Very accurate

Checking the Staging Area

After running git add, check again:

git status

Now you will see something like:

Changes to be committed:
  index.html

This means;

"These changes are staged and ready to be saved"

Why the Staging Area Is Important

Without staging:

You couldn’t choose what to save
Every small change would be forced into history
Commits would become messy

Staging allows you to:

Group related changes
Keep history clean
Commit with confidence

Commits — Saving Your Work in Git

We have learned:

Git tracks your project in the working directory
You move changes to the staging area using git add

Now it’s time to save a snapshot of your work*, this is called a **commit.

What Is a Commit?

A commit is like:

A photo of your project at a point in time
A save point in a video game
A version checkpoint of your code

When you commit:

Git stores the current state of files in the staging area
You can later go back to this point if needed

Think of it as telling Git:

“This is a version I’m happy with — save it.”
_

Why Commits Matter

Commits are important because they let you:

Undo mistakes – go back to a previous commit if something breaks
Track progress – see what changed over time
Collaborate safely – others can see your work without overwriting yours
Keep history organized – clean, meaningful snapshots make debugging easier

Without commits:

Your history is lost
You can’t roll back changes
Collaboration becomes dangerous

How to Create Your First Commit

Assuming you have:

A repository (git init done)

Added files to the staging area (git add)

You create a commit like this:

git commit -m "Add initial project files"

Breaking this down:

git commit - tells Git to save the snapshot
-m - allows you to add a message describing the changes
"Add initial project files" - the commit message (explained below)

Writing Meaningful Commit Messages

Commit messages are important because they tell you and others what changed.

Tips for beginners:

Use the present tense: "Fix bug in login form"
Be short but descriptive: "Add homepage layout"
Focus on what changed, not how: "Update README" vs "Type some text"

Bad example:

git commit -m "stuff"

Good example:

git commit -m "Add styling to navigation bar"

Checking Your Commit

After committing, run:

git log

You will see:

commit 9fceb02
Author: Your Name <youremail@example.com>
Date: Sat Jan 18 16:00 2026

    Add initial project files

Meaning:

Git saved your snapshot
You now have a recorded version of your project

Push and Pull — Syncing with GitHub

In the previous parts, we have learned:

Creating a repository
Tracking changes
Saving work with commits

Now it’s time to share your work online and keep it up-to-date. This is where push and pull come in.

Local vs Remote Repository

Before we talk commands, let’s review:

Repository	Where it lives	Purpose
Local	Your computer	Edit files, track changes, commit versions
Remote	GitHub (online)	Backup, collaboration, portfolio

Push and pull are simply the communication between local and remote

What Is Push?

Push sends your committed changes from your local repository to GitHub.

Think of it as:

“I’ve made changes on my computer. Save them online.”
_

Example

git push origin main

Breaking it down:

git push - sends changes
origin - the remote repository (GitHub)
main - the branch you are pushing to (usually main)

After pushing:

Your work is safe online
Others can see your changes
You have a backup in case your computer fails

What Is Pull?

Pull fetches changes from GitHub (remote) to your local repository.

Think of it as:

“Check online for new updates and bring them to my computer.”
_

git pull origin main

After pulling:

Your local project is up-to-date
You avoid conflicts with other people’s changes
You can continue working safely

Safe Workflow Habits

Even if you’re working alone, following safe habits is important.

Always pull before starting work

git pull

Ensures you have the latest version

Stage and commit your changes regularly

git add
git commit -m "Describe changes"

Push after completing a task

git push

Saves work online

Write meaningful commit messages

Helps you and others understand the history

Avoid working directly on GitHub

edit locally - commit - push - then view online

Here’s how a typical session looks:

# Start your work
git pull

# Make changes to your files
# Stage and commit changes
git add .
git commit -m "Add feature or fix bug"

# Save your work online
git push

DEV Community: Munyalo Meshack

Understanding SQL Joins with Practical Examples (Beginner Friendly Guide)

What is SQL Joins.

Types of SQL Joins

INNER JOIN

LEFT JOIN (LEFT OUTER JOIN)

RIGHT JOIN (RIGHT OUTER JOIN)

FULL OUTER JOIN

CROSS JOIN

NATURAL JOIN

SELF JOIN

Conclusion

Getting Started with Data Analysis Using Microsoft Excel (Beginner’s Guide)

What is Data Analysis.

Why use Excel for Data Analysis?

Understanding Excel Data (Rows, Columns, Cells)

Preparing Data for Analysis.

Understanding Your Dataset

Basic Data Cleaning in Excel

Identifying missing values

Removing Duplicates

Sorting and Filtering Data

Basic Excel Formulas

SUM

Using Cell References

Summing a Range of Cells

AVERAGE() Function

Using Cell Referencing

COUNT() Function

Using Cell Referencing

MAX() Function

Using Cell Referencing

MIN() Function

Using Cell Referencing

MEDIAN() Function

Using Cell Referencing

Conclusion

Git for Beginners: Tracking Changes, Push and Pull Explained

Git and GitHub

Introduction

What Is GitHub?

What Is Git?

How to Create a GitHub Account

Step-by-step:

What Is Git (the Software)?

How to Download and Install Git

On Windows

On macOS (MacBook)

Option 1: Using the Installer

Option 2: Using Terminal

On Linux

How to Connect Git to Your GitHub Account

Step 1: Set Your Name

Step 2: Set Your Email

Understanding a Repository

What Is a Repository?

Local vs Remote Repository

Creating Your First Repository

Step 1: Open Git Bash / Terminal

Step 2: Initialize Git

What Actually Happened?

Checking Repository Status:

Adding a File to the Repository

How Git Tracks Changes

The Working Directory

Why Git Doesn’t Auto-Save

Checking Changes with git status

The Staging Area

Why git add Exists

How Git knows what changed

Checking the Staging Area

Why the Staging Area Is Important

Commits — Saving Your Work in Git

What Is a Commit?

Why Commits Matter

How to Create Your First Commit

Writing Meaningful Commit Messages

Tips for beginners:

Checking Your Commit

Push and Pull — Syncing with GitHub

Checking Changes with `git status`

Why `git add` Exists