DEV Community: Khadija sajid

The Git & GitHub Guide I Wish I Had Before Losing My University Project

Khadija sajid — Tue, 02 Jun 2026 01:01:36 +0000

I Lost My University Project a Few Hours Before Demo Day — That’s How I Learned Git
A few years ago, I learned one of the most important lessons of my software engineering journey the hard way.

Just a few hours before my university project exhibition, I was fixing what seemed like a small bug. Instead of solving the problem, I accidentally corrupted a significant portion of my project's backend files.

I had no backup.

No version history.

No recovery plan.

At that time, Git and GitHub were just words I had heard from senior developers. I never thought I needed them.

That day, I could only demonstrate the frontend of my project while the backend remained broken.

The experience taught me something every developer eventually learns:

Your code is not truly safe until it is version-controlled.

This article is the guide I wish I had back then.

What Is Git?

Git is a distributed version control system.

In simple terms, Git tracks changes in your project over time.

Think of it as a timeline for your code.

Instead of saving files like:

project-final
project-final-v2
project-final-v2-latest
project-final-v2-latest-actual-final

Git maintains a complete history of every meaningful change.

Benefits:

Recover deleted code
Compare versions
Collaborate with others
Experiment safely
Track project history

What Is GitHub?

Many beginners think Git and GitHub are the same thing.

They are not.

Git = Version control software running on your computer.

GitHub = Cloud platform that hosts Git repositories.

Think of it this way:

Git is your notebook.

GitHub is the cloud storage where that notebook is safely stored and shared.

Why Every Developer Needs Git

Imagine these situations:

You accidentally delete important code.
A new feature breaks everything.
Your laptop crashes.
A teammate introduces a bug.
You want to return to a previous working version.

Without Git:

You panic.

With Git:

You simply restore a previous commit.

Installing Git

Windows:

Download Git from the official Git website.

Verify installation:

git --version

Expected output:

git version 2.x.x

Creating Your First Repository

Create a project folder:

mkdir my-project
cd my-project

Initialize Git:

git init

Output:

Initialized empty Git repository

Git is now tracking this folder.

Understanding the Git Workflow

Most beginners struggle because they don't understand Git's three stages.

Working Directory

Where you create and edit files.

Staging Area

Where you prepare changes for saving.

Repository

Where Git permanently stores snapshots.

Workflow:

Edit Files
     ↓
git add
     ↓
Staging Area
     ↓
git commit
     ↓
Repository History

Your First Commit

Create a file:

touch app.py

Check status:

git status

Stage the file:

git add app.py

Commit changes:

git commit -m "Initial commit"

Congratulations.

You have created your first checkpoint.

Essential Git Commands

Check Status

git status

Shows:

Modified files
Staged files
Untracked files

View History

git log

Displays all commits.

Compact view:

git log --oneline

Compare Changes

git diff

Shows what changed before committing.

Remove File from Staging

git restore --staged filename

Understanding Branches

A branch is an independent line of development.

Imagine building a new feature without touching the main project.

That's exactly what branches allow.

Create branch:

git branch login-feature

Switch branch:

git checkout login-feature

Modern shortcut:

git switch login-feature

Create and switch:

git switch -c login-feature

Why Branches Matter

Without branches:

You experiment directly on production code.

With branches:

You can make mistakes safely.

Professional developers rarely work directly on the main branch.

Merging Branches

After finishing a feature:

Switch to main:

git switch main

Merge feature:

git merge login-feature

Git combines both histories.

Understanding Merge Conflicts

Conflicts occur when two versions modify the same lines.

Example:

Developer A changes line 10.

Developer B changes line 10.

Git cannot decide automatically.

You must manually choose which version to keep.

This is normal.

Even experienced engineers handle merge conflicts regularly.

Connecting Git to GitHub

Create a repository on GitHub.

Connect local repository:

git remote add origin repository-url

Verify:

git remote -v

Push Code to GitHub

git push -u origin main

Your code is now stored online.

This single command could have saved my university project years ago.

Clone Existing Repositories

Copy a repository:

git clone repository-url

Git downloads the entire project history.

Pull Latest Changes

git pull origin main

Updates your local project.

Forking Open Source Projects

Forking creates your own copy of someone else's repository.

Typical workflow:

Fork repository
Clone fork
Create branch
Make changes
Push changes
Open Pull Request

This is how many developers contribute to open source.

Pull Requests

A Pull Request (PR) is a request to merge changes.

Benefits:

Code review
Discussion
Collaboration
Quality assurance

Professional teams rely heavily on PRs.

Git Ignore

Some files should never be tracked.

Examples:

Passwords
API keys
Build files
Temporary files

Create:

.gitignore

Example:

node_modules/
.env
dist/

Commit Message Best Practices

Bad:

fixed stuff

Good:

Add user authentication system

Great commits tell a story.

Future you will appreciate them.

GitHub Features Every Developer Should Use

Issues

Track bugs and tasks.

Projects

Manage development workflows.

Discussions

Community conversations.

Actions

Automate testing and deployment.

Releases

Publish stable versions.

GitHub Actions

GitHub can automatically:

Run tests
Build projects
Deploy applications

Every time code is pushed.

This is called CI/CD.

A basic workflow:

name: Test Project

on: push

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

Common Beginner Mistakes

Not Committing Frequently

Commit small changes often.

Working Only on Main

Use feature branches.

Forgetting .gitignore

Never upload secrets.

Ignoring Pull Requests

Code reviews improve quality.

No Remote Backup

Always push to GitHub.

From Beginner to Professional

A beginner uses Git to save code.

An intermediate developer uses Git to collaborate.

An advanced engineer uses Git to manage complex software systems.

The commands are important.

The mindset is more important.

Version control is not about memorizing commands.

It is about building with confidence.

Final Thoughts

The day I lost my university project taught me a lesson I will never forget.

Git is not just a developer tool.

GitHub is not just a website.

Together, they form a safety net that protects your work, enables collaboration, and gives you the confidence to experiment without fear.

If you are learning software development today, start using Git and GitHub immediately.

Trust me.

It is far better to learn from this article than from losing a project a few hours before demo day.

AWS Bedrock

Khadija sajid — Tue, 26 May 2026 06:47:25 +0000

Last December, I delivered a talk on AWS Bedrock at AWS Community Day. The main purpose of this talk is to differentiate between traditional AI and Generative AI, and how it makes a difference to the world, and AWS Bedrock enables us to use different models with different capabilities.
First, I explain generative AI and now how almost in every application Generative AI is used and the common challenges a developer face while building an application where they need more then one model for different capabilities as they jump from one plateform to other for using other models as different models have diffenent capabilities For example, for coding developer preffer Anthropic modes, for explaination open AI models work amazing and many other models for different capabilites.
AWS Bedrock solves this problem by offering multiple models from different companies.
I attach some of the companies' models that AWS Bedrock offers :

There are a couple of reasons developers should use AWS Bedrock :
● The developer doesn’t have to jump from one platform to another for different models
● They don’t have to worry about the infrastructure; AWS manages all for you.
● The best part, which I like, is that your data is not being used for model training, so you can use different models with ease of mind.

Now the question is how developers can use these models in their application or test the capabilities, Soo mainly there are three ways to use or test the model:
● AWS CLI
● Bedrock API
● Playground

How AWS Bedrock works. Here is the simplest workflow:
User Prompt
Amazon Bedrock
AI Model
Generated Response

Most developers use the API Call method, where they directly use the model by API Call:

Now the next Question is how to choose the right model, it all depends on the use case and requirements:
● Model Type & Multimodal Capabilities
● Performance & Latency Requirements
● Model Size & Context Window
● Customization Needs
● Licensing & Commercial Use

If you have any queries about AWS Bedrock, let me know in the comments.

Understanding AWS EC2: Workflow, Terminologies, and Cloud Computing Basics

Khadija sajid — Thu, 22 Jan 2026 17:06:08 +0000

Aiming to develop and build large-scale applications or advanced systems often requires high computational resources such as increased RAM, CPU cores, storage, and networking capabilities. Purchasing personal or on-premise servers to meet these requirements is extremely expensive and difficult to scale.
This is where cloud computing comes into play. Cloud computing allows us to rent computing resources on demand, meaning we can use as many resources as needed and pay only for what we use. This approach is far more cost-effective and flexible than buying and maintaining physical servers.
Amazon Web Services (AWS) is one of the leading cloud service providers and offers a wide range of services such as EC2, S3, and many others.
Elastic Compute Cloud (EC2) is a core AWS service that provides virtual machines in the cloud.
In cloud terminology, a virtual machine is called an instance. AWS offers multiple instance types, allowing users to choose hardware configurations based on their requirements. For example, t2.micro is a free-tier eligible instance commonly used by beginners and first-time users.
After selecting the instance type (hardware), we choose the software configuration using an Amazon Machine Image (AMI). An AMI is a preconfigured template that includes an operating system and optional software. It can be used directly or customized according to application needs.
The EC2 workflow starts by selecting networking, hardware (instance type), and software (AMI). After configuring storage, networking, and security, the instance is launched as a virtual machine. Developers then connect to the instance via SSH to deploy applications. EC2 instances can be scaled vertically (by changing instance size) or horizontally (by adding more instances) and managed throughout their lifecycle based on application needs.
In summary, EC2 provides scalable, flexible, and cost-effective virtual computing resources, making it an essential service in cloud computing.

How AWS Makes Life Easier for Students (and Powers Netflix & Instagram!)

Khadija sajid — Tue, 26 Aug 2025 10:15:53 +0000

Ever wondered how Instagram or Netflix never crash, even with millions of users?
As a computer science student, I’ve always been curious about how technology works behind the scenes. That curiosity led me to discover AWS (Amazon Web Services), the hidden power source that keeps apps running, data updated worldwide, and services customized at scale.
What makes AWS so exciting is that it isn’t just for big tech companies; it’s also for students like us. AWS provides free credits so we can experiment without spending money. You can:

Host a personal website
Build projects
Practice machine learning
Run heavy code even if your laptop is slow

In short, AWS removes many of the challenges we face as students. Limited storage? Use AWS cloud space. Want to take your project live? Host it in minutes. Worried about data loss? AWS keeps it secure.
Here’s a quick breakdown of its core services:

Compute → The “brain” where apps run
Storage → An online hard drive to keep files safe
Databases → Store & organize information
Networking → Connect everything like roads in a city
AI & ML tools → Try image recognition, speech-to-text, and more—without building from scratch.
Security → Protects your data at every step

So, the next time you use Netflix, Instagram, or any large-scale app, remember—AWS is working silently in the background.
And the best part? You and I can explore the same technology today. Has anyone here tried AWS credits for student projects?