Code::Core 3-Month Diploma Curriculum

For: Joannah Kuteesa & Jordan Mulungi Kaweesi Start Date: Week 1

Overview

This is a comprehensive 12-week computer science curriculum designed for diploma students transitioning from high school to university. Each week builds foundational skills in version control, web development, computer architecture, command-line interfaces, and beyond.

Curriculum Structure

Week 1: Git & GitHub Fundamentals

• Complete guide to version control
• Setting up Git and GitHub
• Uganda-based examples and case studies
• Hands-on: Create your first repository
• Duration: 5 days of learning content

Materials: false

Week 2: HTML & HTML Tags

• Introduction to markup languages
• Essential HTML tags and structure
• Building a multi-page website
• Daily Commits: Each day commits to Git with new features
• Collaborator: David Emiru Egwell (makanika)
• Duration: 5 days (Monday-Friday), daily Git commits

Materials: false

Week 3: ASCII, HEX & Binary

• Number systems explained
• ASCII character encoding
• Hexadecimal and binary representations
• Project: Write your name in binary and hexadecimal
• Duration: 5 days

Materials: false

Week 4: Introduction to Linux Command Line

• Command-line fundamentals
• File system navigation
• Essential commands for developers
• Writing and running scripts
• Duration: 5 days

Materials: false

Week 5+: Advanced Topics

Framework established for expansion to 1000+ pages of content

Planned topics:

• Week 5: CSS & Styling
• Week 6: Python Basics
• Week 7: Python Functions, Files & Data
• Week 8: APIs & HTTP with Python
• Week 9-12: Python Full-Stack Project

How to Use This Curriculum

For Students:

1. Read the daily lesson materials
2. Follow the hands-on exercises
3. Practice with code examples
4. Commit your work to Git daily (Weeks 2+)
5. Ask questions - this is your foundation

For Coaches/Mentors:

Getting Started

Student Examples

Both Joannah Kuteesa and Jordan Mulungi Kaweesi work through this curriculum together with equal representation. See STUDENTS-EXAMPLES.md for parallel examples showing how both students progress through each week.

Prerequisites:

• A Windows computer
• Git installed on your machine
• A GitHub account
• A code editor (VS Code recommended)

Quick Start:

# Clone this curriculum
git clone [repository-url]
cd CodeandCoreCompScience

# Navigate to Week 1
cd Week-01-Git-GitHub

# Read the README
cat README.md

Learning Objectives (Overall)

By the end of 3 months, you will:

• ✅ Understand and use version control professionally
• ✅ Build responsive websites with HTML & CSS
• ✅ Understand how computers represent data
• ✅ Navigate and control your computer from the command line
• ✅ Write Python programs for practical tasks
• ✅ Build and use APIs with Python
• ✅ Build a Python full-stack web application
• ✅ Follow industry best practices and workflows

Week-by-Week Breakdown

Uganda Examples Throughout

You'll see references to:

• Companies: Jumia Uganda, Pesalink, MTN Uganda innovations
• Places: Kampala tech hub growth, KCCA systems
• Culture: Local business challenges that tech solves
• Currency & Commerce: How payment systems work (Pesalink example)
• Real-World Scenarios: Building tools for Uganda's market

Resources

• Git Documentation: false
• GitHub Guides: false
• MDN Web Docs: false
• Linux Command Reference: false

Support

• Weekly check-ins: Review progress and blockers
• Daily exercises: Reinforce learning
• Git commits: Track your journey
• Peer learning: Joannah and Jordan learn together

Next Steps

👉 Start with Week 1: Git & GitHub Fundamentals

Code::Core Curriculum | Empowering the next generation of Ugandan developers

Last Updated: September 2026

Week 1: Git & GitHub Fundamentals

For Diploma Computer Science Students

Week Overview

This week, you'll learn version control - one of the most important skills in software development. Version control is like a detailed diary for your code: it records every change you make, who made it, when, and why.

What You'll Learn:

• ✅ What Git is and why developers use it
• ✅ How to set up Git on your computer
• ✅ Creating your first Git repository
• ✅ Making commits (saving changes with descriptions)
• ✅ Using GitHub to share your code
• ✅ Understanding branches and merging
• ✅ Collaborative development basics

Learning Time: 5 days (Monday-Friday)

Practicum: 2-3 hours per day

Daily Schedule

Why You Need This (Uganda Context)

Imagine you're building a payment app for Uganda like Pesalink or MTN Mobile Money:

• Your boss asks: "Can you show me what changed between yesterday and today?"
• Your team member breaks something: How do you go back to the version that worked?
• Two developers work on the same project: How do you combine their work without losing anything?
• You need to test a new feature: You don't want to break the working version.

That's what Git solves.

Real Uganda example: When MTN Uganda updates their mobile app, hundreds of developers work on it. Git ensures:

• Each developer works on their own feature without breaking others' work
• Changes are tracked (who did what, when, and why)
• It's easy to fix bugs by going back to previous versions
• Teams can collaborate efficiently across Kampala and beyond

MONDAY: What is Git? Installation & Setup

1. Understanding Git (30 minutes)

What is Git?

Git is a version control system - software that tracks changes to your code over time.

Think of it like this:

• Without Git: You have files on your computer. You make changes. If you mess up, you're stuck. Maybe you've done this:

  project.py
  project_v2.py
  project_final.py
  project_ACTUAL_FINAL.py
  project_REALLY_FINAL.py
  

  This is chaotic and unprofessional.

• With Git: You have ONE file. Git records every change. You can see exactly what changed, go back to any previous version, and understand why each change was made.

Why Git Matters

1. History: Every change is recorded with a message
2. Teamwork: Multiple people can work on the same project
3. Safety: Broken code? Roll back to a working version in seconds
4. Backup: Your code exists in multiple places (your computer + GitHub)
5. Professionalism: Every job in tech uses Git

Git vs GitHub (Important Distinction!)

• Git = The software that tracks changes (runs on your computer)
• GitHub = A website where you upload your Git repositories (cloud storage for code)

Analogy: Git is like your personal notebook. GitHub is like posting your notebook online for others to see and collaborate.

2. Installing Git (30 minutes)

Windows Installation

Step 1: Go to false

Step 2: The download should start automatically. If not, click the link for your Windows version (64-bit is standard).

Step 3: Run the installer. Accept the default options except:

• When asked about "Adjusting PATH environment," select "Git from the command line and also from 3rd-party software"
• Keep other defaults

Step 4: Complete the installation

Verify Installation

Open Command Prompt or PowerShell on Windows and type:

git --version

You should see something like:

git version 2.40.0

If you see this, Git is installed successfully! ✅

3. Configuring Git (30 minutes)

Now that Git is installed, you need to tell it who you are. This is important because Git will record your name with every change you make.

Set Your Name and Email

Open Terminal/Command Prompt and run these commands:

git config --global user.name "Your Full Name"
git config --global user.email "your.email@example.com"

Example for Joannah Kuteesa:

git config --global user.name "Joannah Kuteesa"
git config --global user.email "joannah.kuteesa@gmail.com"

Example for Jordan Mulungi Kaweesi:

git config --global user.name "Jordan Mulungi Kaweesi"
git config --global user.email "jordan.kaweesi@gmail.com"

Verify Configuration

Check that it worked:

git config --global --list

You should see:

user.name=Joannah Kuteesa
user.email=joannah.kuteesa@gmail.com

4. Creating Your First Folder (15 minutes)

You need a place on your computer where you'll practice Git.

Windows Users

1. Open File Explorer
2. Create a new folder. Name it: MyFirstRepo
3. Right-click inside the folder
4. Select "Open in Terminal" (or "Git Bash Here" if you have it)

5. Initializing Your First Repository (15 minutes)

Now you're in the folder. Initialize Git:

git init

You should see:

Initialized empty Git repository in /path/to/MyFirstRepo/.git

Congratulations! 🎉 You've created your first Git repository!

What happened? Git created a hidden folder called .git that will track all your changes from now on.

To see it:

Windows (Command Prompt):

dir /a

You should see a .git folder listed.

End of Day 1 Checklist

• Git is installed on your computer
• You've configured Git with your name and email
• You've created a folder called MyFirstRepo
• You've initialized Git in that folder
• You can see the .git folder inside

Reflection Question:

Write down in one sentence: What problem does Git solve?

TUESDAY: Your First Repository

1. Understanding Repositories (15 minutes)

A repository (or "repo") is just a folder with Git tracking it. It contains:

• Your project files (code, images, documents)
• The .git folder (where Git stores the history)

Think of it like a project folder at work that has:

• Your code files
• A filing cabinet (.git) with complete records of every change

2. Creating Real Project Files (30 minutes)

Now let's create some actual code to version control. You'll create a simple HTML file about Uganda.

Step 1: Create an HTML File

In your MyFirstRepo folder, create a file called index.html

Windows: Right-click > New > Text Document > Rename to index.html, or run New-Item index.html -ItemType File in PowerShell.

Step 2: Add Content

Open index.html in a text editor (Notepad, VS Code, etc.) and add:

<!DOCTYPE html>
<html>
<head>
    <title>Welcome to Uganda Tech</title>
</head>
<body>
    <h1>Uganda's Growing Tech Industry</h1>
    <p>Welcome! This page celebrates Uganda's amazing tech innovation.</p>
    
    <h2>Key Companies</h2>
    <ul>
        <li>Jumia Uganda - E-commerce platform</li>
        <li>MTN Uganda - Telecommunications & Mobile Money</li>
        <li>Pesalink - Fast mobile money transfer</li>
    </ul>
    
    <p>Created by: [Your Name]</p>
</body>
</html>

Replace [Your Name] with your actual name.

Step 3: Add Another File

Create a file called about.txt with:

About This Project
==================
This is my first Git repository.
I'm learning version control in Week 1 of my diploma.
It's exciting to finally understand how professionals manage code!

Step 4: Save Both Files

Make sure both files are saved in your MyFirstRepo folder.

3. Checking Repository Status (20 minutes)

Now let's ask Git: "What files do you see?"

In Terminal/Command Prompt (in your MyFirstRepo folder), run:

git status

You should see something like:

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        about.txt
        index.html

nothing added to commit but untracked files present (tracking files)

What this means:

• Git sees your files (about.txt and index.html)
• They're "untracked" - Git is not yet recording their history
• We need to tell Git to start tracking them

4. Staging Files (30 minutes)

Staging is the step where you tell Git: "Here are the changes I want to record."

It's like preparing items to be mailed:

1. You gather items (staging)
2. You put them in a box and seal it (committing)
3. You send the box (pushing to GitHub)

Stage All Files

git add .

The . means "add everything in this folder."

You can also add individual files:

git add index.html
git add about.txt

Check Status Again

git status

Now you should see:

On branch master

No commits yet

Changes to be committed:
  (use "rm --cached <file>..." to unstage)
        new file:   about.txt
        new file:   index.html

What changed? The files are now "staged" - they're ready to be recorded.

5. Making Your First Commit (20 minutes)

A commit is when you officially record changes with a message explaining what you did.

Create Your First Commit

git commit -m "Initial commit: Add Uganda tech project"

Breaking this down:

• git commit = Record the staged changes
• -m = The next thing is a message
• "Initial commit: Add Uganda tech project" = Your message describing the change

You should see:

[master (root-commit) a1b2c3d] Initial commit: Add Uganda tech project
 2 files changed, 15 insertions(+)
 create mode 100644 about.txt
 create mode 100644 index.html

Congratulations! 🎉 Your first commit is recorded!

6. Viewing Your History (20 minutes)

Git keeps a complete history. Let's see it:

git log

You should see:

commit a1b2c3d4e5f6g7h8i9j0 (HEAD -> master)
Author: Joannah Kuteesa <joannah.kuteesa@gmail.com>
Date:   Mon Sep 1 10:30:00 2026 +0000

    Initial commit: Add Uganda tech project

This shows:

• commit ID: A unique code for this change
• Author: Who made the change (you!)
• Date: When it was made
• Message: What was changed

Practical Exercise: Make a Second Commit

Step 1: Modify index.html

Add more content to index.html. Change the line:

<p>Created by: [Your Name]</p>

To something like:

<p>Created by: Joannah Kuteesa</p>
<p>This page was created on September 1, 2026</p>

Step 2: Stage the Changes

git add index.html

Step 3: Commit with a Meaningful Message

git commit -m "Add creation date and author name to index.html"

Step 4: View Your History

git log

You should now see TWO commits!

Understanding Commit Messages

Good commit messages are:

• Short and specific: "Add navigation menu" (not "Update website")
• Written in present tense: "Add feature" (not "Added feature")
• Descriptive: Someone should understand what changed without seeing the code

Good Examples:

• ✅ "Add user authentication"
• ✅ "Fix bug in login form validation"
• ✅ "Update README with installation instructions"
• ✅ "Refactor database queries for performance"

Bad Examples:

• ❌ "Update stuff"
• ❌ "asdfgh"
• ❌ "Fix things"
• ❌ "Final version"

Uganda Context: Real Commit Examples

When developers at Jumia Uganda work on features, they write messages like:

• "Add Pesalink payment option"
• "Fix mobile money verification for MTN"
• "Update product filtering for Ugandan categories"
• "Optimize search for slow internet connections"

Each message tells the story of how the app evolved.

End of Day 2 Checklist

• Created index.html with Uganda tech content
• Created about.txt with project description
• Staged both files with git add
• Made your first commit with a meaningful message
• Made a second commit by modifying a file
• Viewed your commit history with git log

Reflection Question:

Why is a good commit message important? Think about working in a team - what would you want to know when reviewing someone else's changes?

WEDNESDAY: Git Commits & History

1. Understanding the Commit Workflow (30 minutes)

Every time you make changes in Git, you follow this cycle:

EDIT FILES → STAGE FILES → COMMIT → HISTORY RECORDED
   (Write)      (Prepare)    (Save)      (Permanent)

Today, you'll practice this cycle multiple times and become comfortable with it.

The Three States

1. Working Directory - Your actual files that you're editing 2. Staging Area - Files you've selected to commit (ready to save) 3. Git Repository - The permanent history stored in .git

Think of it like this:

• Working Directory = Your desk with papers
• Staging Area = The papers you put in a pile to mail
• Git Repository = The mailbox (everything is officially recorded)

2. Practice Cycle 1: Updating Your Content (1 hour)

Step 1: Add More Content

Edit your index.html file. Add this section about Uganda's tech hub:

<h2>Uganda's Tech Hub - Kampala</h2>
<p>Kampala is emerging as East Africa's leading tech hub with:</p>
<ul>
    <li>Over 200+ active startups</li>
    <li>Co-working spaces across the city</li>
    <li>Universities producing tech talent</li>
    <li>Growing investor interest</li>
</ul>

<h2>Future Opportunities</h2>
<p>Uganda's tech sector is growing at 30% annually, creating opportunities in:</p>
<ul>
    <li>E-commerce</li>
    <li>Financial Technology (FinTech)</li>
    <li>Mobile Applications</li>
    <li>Data Analytics</li>
</ul>

Step 2: Check Status

git status

You should see:

On branch master
Changes not staged for commit:
  (use "git add <file>..." to include in what will be committed)
        modified:   index.html

no changes added to commit but untracked files present (tracking files)

This means Git detected changes but they're not staged yet.

Step 3: View the Differences

Before committing, let's see exactly what changed:

git diff index.html

This shows:

• Lines with - = removed
• Lines with + = added

This is powerful - you can review changes before committing.

Step 4: Stage and Commit

git add index.html
git commit -m "Add Kampala tech hub information and future opportunities"

Step 5: View Your Growing History

git log --oneline

The --oneline flag shows a shorter version. You should see:

3a4b5c6 Add Kampala tech hub information and future opportunities
d7e8f9g Add creation date and author name to index.html
a1b2c3d Initial commit: Add Uganda tech project

Notice: Your commits are listed with the newest first (at the top).

3. Practice Cycle 2: Create a New File (45 minutes)

Now create a new file with information about Uganda's developers.

Step 1: Create developers.md

Create a new file called developers.md and add:

# Uganda's Developer Community

## Who Are They?

Uganda has a vibrant developer community consisting of:
- Young graduates from Makerere University
- Self-taught developers using online resources
- Professionals transitioning from other fields
- Tech professionals from companies like Jumia and MTN

## Popular Programming Languages in Uganda

1. **Python** - Data science and automation
2. **JavaScript** - Web and mobile app development
3. **Java** - Enterprise applications
4. **PHP** - Web server development
5. **React Native** - Mobile app development (cross-platform)

## Learning Resources in Uganda

- Online: Coursera, Udemy, freeCodeCamp
- In-person: Coding bootcamps in Kampala
- Communities: Tech meetups and hackathons
- Universities: Makerere, Kyambogo, KCCA

## Salary Ranges (Approximate)

| Level | Annual Salary (UGX) |
|-------|---------------------|
| Junior Developer (0-2 years) | 20M - 40M |
| Mid-level Developer (2-5 years) | 40M - 80M |
| Senior Developer (5+ years) | 80M - 150M+ |
| Tech Lead | 120M - 200M+ |

**Note:** These are approximate ranges and vary by company and specialization.

## Job Market Growth

Uganda's tech sector is growing rapidly:
- 2023: ~4,000 developer jobs
- 2024: ~5,200 developer jobs
- 2025: ~6,500 developer jobs (projected)

This is YOUR market! Get good at Git and you'll be competitive.

Step 2: Check Status

git status

Step 3: Stage Both the New File and Any Changes

git add .

Step 4: Commit

git commit -m "Add developer community and market information"

Step 5: View Log

git log --oneline

4. Undoing Changes (Advanced - 30 minutes)

Sometimes you make a mistake. Git makes it easy to undo things.

Scenario 1: You Modified a File But Haven't Staged It Yet

Create a test file called test.txt with any content:

echo "This is a test file" > test.txt

Now make a change:

echo "This is a mistake" >> test.txt

You realize: "Oh no! I made a mistake!"

Solution: Discard the changes:

git checkout test.txt

The file is restored to its previous state.

Scenario 2: You Staged a File But Haven't Committed Yet

Create a new file:

echo "Another test" > test2.txt

Stage it:

git add test2.txt

Oh no! You didn't mean to add that file yet.

Solution: Unstage it:

git reset test2.txt

The file still exists, but Git is no longer tracking it.

Scenario 3: You Made a Commit with a Typo in the Message

You committed something but the message had a typo.

Solution: Amend the last commit:

git commit --amend -m "New message without typos"

This changes the message of your most recent commit.

5. Detailed Log Viewing (20 minutes)

Git offers many ways to view history. Here are some useful ones:

Show Full Commits

git log

Show One-Line Summary

git log --oneline

Show Last N Commits

git log -5

Shows the last 5 commits.

Show Changes in Each Commit

git log -p

Shows the exact lines that changed in each commit. (Press q to quit)

Show Statistics

git log --stat

Shows how many lines changed in each commit.

Pretty Formatting

git log --oneline --graph --all --decorate

Shows a fancy formatted view with branches (we'll learn about branches tomorrow!).

Practice Exercise: Create a Diverse Commit History

Make at least 3 more commits today by:

1. Commit 1: Add a new section to index.html about universities in Uganda

   git add index.html
   git commit -m "Add information about Ugandan universities"
   

2. Commit 2: Create a new file companies.md with information about tech companies

   git add companies.md
   git commit -m "Add list of major tech companies in Uganda"
   

3. Commit 3: Update about.txt with more details

   git add about.txt
   git commit -m "Update project description with more details"
   

View Your Complete History

git log --oneline

You should have at least 6+ commits now!

Understanding Git's Safety

One of Git's amazing features is that you can almost never lose work.

• Even if you delete a file, Git has a copy
• Even if you go back in history, previous versions are safe
• Even if you make mistakes, there's usually a way to recover

The commits you've made are now permanent in your repository.

End of Day 3 Checklist

• Made multiple commits today (at least 3 new ones)
• Practiced git status and git diff
• Viewed history with git log and git log --oneline
• Learned how to undo changes
• Practiced amending a commit message
• Explored different log viewing options

Reflection Question:

Write down 2 scenarios where version control would have saved you time in a previous school project.

THURSDAY: GitHub & Remote Repositories

1. Understanding GitHub (30 minutes)

So far, your Git repository exists only on your computer.

GitHub is a website (owned by Microsoft) where you can:

• Upload your repositories to the cloud
• Share code with others
• Collaborate on projects
• Show your work to employers
• Backup your code

Think of it like this:

• Your Computer = Your local workspace
• GitHub = Your code's home on the internet (backup + portfolio)

Why GitHub Matters

1. Backup: If your computer crashes, your code is safe on GitHub
2. Collaboration: Your team can access and work on your code
3. Portfolio: Employers see your GitHub to evaluate your skills
4. Open Source: Contribute to projects like Firefox, VS Code, Python
5. It's the industry standard: Every professional uses GitHub

2. Creating a GitHub Account (15 minutes)

⚠️ IMPORTANT: Your GitHub Username is Your Career Identity

Before you create an account, read this carefully.

Your GitHub username is NOT just a login. It's your professional brand. Here's why:

This username will:

• Appear on every project you ever build
• Be in every pull request you submit
• Show on your resume and portfolio
• Be visible to potential employers who review your work
• Follow you for your ENTIRE developer career
• Be part of every link to your code (e.g., github.com/YOUR-USERNAME/project)

Real talk: If you create a silly, unprofessional, or immature username today, you'll be stuck explaining it for the next 20+ years of your career.

You might think: "It's just a username, I can change it later."

Truth: You CAN change it technically, but:

• All your old links break
• Projects lose their URLs
• You confuse anyone who's seen your work
• You look unprofessional

Scenario from Uganda's tech scene:

Imagine this happens in 2030:

• You've built amazing apps
• Your GitHub has 5,000 followers
• Jumia Uganda, Pesalink, or MTN sees your work
• HR manager Googles your name
• They find: xXcoder420Xx as your GitHub profile

What they think:

• ❌ Immature
• ❌ Not serious about career
• ❌ Won't look professional at company

Contrast with:

• ✅ joannah-kuteesa - Clear, professional, memorable
• ✅ jordan-kaweesi-dev - Shows it's dev-focused
• ✅ jmulungi - Initials + name, simple and professional

Choosing Your Username Wisely

Think about it like this:

When you graduate and apply for your first tech job:

• Your future employer will search your GitHub
• They'll see your username first
• It's their first impression of your professionalism
• This affects whether you get the job

Your username should:

1. Include your name - Make it about YOU, not an alter ego
2. Be pronounceable - People should be able to say it out loud
3. Be memorable - Easy for others to find and share
4. Be professional - Something you'd write on a business card
5. Be unique to you - Not generic terms everyone uses

Step 1: Go to GitHub

Visit false

Step 2: BEFORE You Sign Up - Choose Your Username

Take 5 minutes to decide. This matters.

Brainstorm some options:

For Joannah Kuteesa:

• joannah-kuteesa ✅ Best
• joannah-k ✅ Good (shorter)
• joannahk-dev ✅ Good (shows dev focus)
• xXJoannahXx ❌ No (too many decorations)
• coder123 ❌ No (could be anyone)
• joannah420 ❌ No (immature)

For Jordan Mulungi Kaweesi:

• jordan-kaweesi ✅ Best
• jordan-mulungi ✅ Good (full middle name)
• jkaweesi ✅ Good (initials)
• JordanDev2026 ❌ No (dated, looks desperate)
• CoderFromUganda ❌ No (too generic)
• jordanMLG ❌ No (unclear, looks like gamer tag)

Step 3: Click "Sign up"

You should see a form asking for:

• Email address (use your personal email - preferably professional, not "epicgamer@...")
• Password (make it strong)
• Username (this will be public - choose wisely, you're stuck with it)

Username Guidelines for Uganda's Context

Uganda's best developers have GitHub usernames like:

• ebenezer-boateng - Clear, professional
• collins-musyoka - Professional, memorable
• amos-kipchoge-dev - Adds context (dev)
• slyBrian - Short, professional, personal

NOT like:

• SupremeGamer2020 - Immature, dated
• l33tCoder - Looks like 1990s hacker fiction
• randomkid123 - Forgettable
• xxx420xxx - Career suicide

Real-World Consequences

Story from Kampala's tech community:

A developer created GitHub username HotShotCoder666 in 2018. By 2023:

• He's an excellent engineer
• Built amazing products
• But when Jumia's HR searched his name...
• First result: HotShotCoder666
• They hired someone else

He's now trying to rebrand online, but all his work is connected to that username.

Don't be that person.

Your Decision (Make It Now)

Write down 3 username options you're considering:

Option 1: ________________ Option 2: ________________ Option 3: ________________

Which one would you write on your resume? ← That's the one to use.

Ask yourself:

• Would I be embarrassed to say this in a job interview? If yes, don't use it.
• Is this something 40-year-old me would be proud of? If no, don't use it.
• Would my future team members respect this? If no, don't use it.

Step 4: Complete Account Creation

Once you've decided on a professional username:

You should see a form asking for:

• Email address (use your personal email)
• Password (make it strong)
• Username (your carefully chosen, professional username)

Example Usernames

• Good: joannah-kuteesa or joannah-k-dev
• Good: jordan-kaweesi or jordan-mulungi-dev
• Bad: xXcoder420Xx or asdfgh123
• Bad: SillyGameNamer2020

Step 3: Verify Your Email

GitHub will send you an email. Click the verification link.

Step 4: Complete Setup

Answer a few questions about your interests. You can skip these if you want.

Congratulations! You now have a GitHub account! 🎉

3. Creating Your First Remote Repository (20 minutes)

Now let's create a repository on GitHub to receive your code.

Step 1: Click the "+" Icon

In the top-right corner of GitHub, click the + icon and select "New repository"

Step 2: Fill in the Details

• Repository name: MyFirstRepo (or any name you like)
• Description: "My first Git repository - Learning version control"
• Public or Private: Select "Public" (so employers can see it)
• Initialize with README: Leave unchecked (we already have commits)

Step 3: Create Repository

Click "Create repository"

You'll see a page with instructions. Keep this page open - we'll use it next.

4. Connecting Your Local Repo to GitHub (20 minutes)

This is the crucial step: linking your computer's Git repo to GitHub.

Step 1: Copy the Remote URL

On the GitHub page you just created, you should see something like:

https://github.com/YOUR-USERNAME/MyFirstRepo.git

Copy this URL (it's unique to your repository).

Step 2: Add the Remote

In Terminal/Command Prompt (in your MyFirstRepo folder), run:

git remote add origin https://github.com/YOUR-USERNAME/MyFirstRepo.git

Replace YOUR-USERNAME with your actual GitHub username and MyFirstRepo with your actual repository name.

What this means:

• git remote = Manage remote repositories
• add = Add a new remote
• origin = The name of this remote (standard convention)
• The URL = Where the remote is located

Step 3: Verify the Remote

git remote -v

You should see:

origin  https://github.com/YOUR-USERNAME/MyFirstRepo.git (fetch)
origin  https://github.com/YOUR-USERNAME/MyFirstRepo.git (push)

Great! Your computer now knows where to send your code.

5. Pushing Your Code to GitHub (20 minutes)

Now let's upload all your commits from your computer to GitHub.

Step 1: Push Your Commits

git push -u origin master

Breaking this down:

• git push = Send commits to remote repository
• -u = Set up tracking (remember this remote for future pushes)
• origin = Which remote (we set this up as GitHub)
• master = Which branch (we'll learn more tomorrow)

Step 2: Enter Your Credentials

GitHub may ask for your credentials:

• Username: Your GitHub username
• Password: Your GitHub password (or personal access token if you have 2FA enabled)

Note: For security, GitHub now requires a "Personal Access Token" instead of your password. If you get an error, visit: false

Step 3: Success!

You should see:

Counting objects: 8, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (5/5), done.
Writing objects: 100% (8/8), 1.2 KiB, done.
Total 8 (delta 0), reused 0 (delta 0)
To https://github.com/YOUR-USERNAME/MyFirstRepo.git
 * [new branch]      master -> master
Branch 'master' set up to track remote branch 'master' from 'origin'.

Congratulations! Your code is now on GitHub! 🎉

Step 4: Verify on GitHub.com

Go back to GitHub in your browser and refresh the page. You should see:

• Your index.html file
• Your about.txt file
• Your developers.md file
• Your complete commit history!

6. Making Updates from Here On (15 minutes)

Now that your local repo is connected to GitHub, pushing is easy:

Step 1: Make a Change

Edit your index.html file and add something new.

Step 2: Stage and Commit

git add index.html
git commit -m "Add new content to index page"

Step 3: Push to GitHub

git push

Notice: No need for -u origin master anymore. Git remembers!

Repeat This Cycle

From now on, your development cycle will be:

EDIT → ADD → COMMIT → PUSH

And your code is automatically backed up on GitHub.

Uganda Context: Code Repositories in the Real World

At companies like Jumia Uganda, this is how it works:

1. Developer writes code on their computer
2. Developer commits their work to Git with clear messages
3. Developer pushes to a GitHub repository
4. Team members review the code on GitHub
5. After approval, the code is merged into the main project
6. New version is deployed to production (the live website)

Every day, dozens of developers push code this way at Jumia. GitHub is the central hub.

Understanding Public Repositories

Your repository is now public. This means:

✅ Good:

• Employers can see your work
• You build a portfolio
• Others can learn from your code
• This is professional

❌ Be careful not to:

• Share passwords or API keys (credentials)
• Put other people's code without credit
• Commit large files
• Include sensitive information

For future projects, if you need privacy, you can make repositories "Private" (only you see them).

End of Day 4 Checklist

• Created a GitHub account
• Created a repository on GitHub
• Connected your local repository to GitHub with git remote
• Pushed your code to GitHub with git push
• Verified your code appears on GitHub.com
• Made a test update and pushed it

Reflection Question:

Why would an employer look at your GitHub profile when hiring a developer?

FRIDAY: Branches & Collaboration

1. Understanding Branches (30 minutes)

A branch is like creating an alternate version of your project.

Why Branches?

Imagine you're working on a website:

• The main website is working perfectly (master branch)
• You want to build a new feature (login system)
• You don't want to break the working website while developing

Solution: Create a new branch to work on the feature separately.

master branch:    ● ← → ● ← → ●  (live, working version)
                    └→ ● ← → ● (login-feature branch, experimental)

When the feature is working, you merge it back into master.

Branch Terminology

• master (or main) = The primary branch, usually the "production" version
• feature branch = A branch for developing a specific feature
• bugfix branch = A branch for fixing a specific bug
• HEAD = Your current location in the repository

2. Creating and Switching Branches (30 minutes)

Step 1: Check Your Current Branch

git branch

You should see:

* master

The * means you're currently on the master branch.

Step 2: Create a New Branch

You're going to create a branch for a new feature: "Adding a Contact Page."

git branch contact-page

This creates a new branch called contact-page, but you're still on master.

Step 3: List All Branches

git branch

Now you should see:

  contact-page
* master

Step 4: Switch to the New Branch

git checkout contact-page

Or in newer Git versions:

git switch contact-page

Step 5: Verify You're on the New Branch

git branch

Now you should see:

* contact-page
  master

3. Making Changes on Your Branch (30 minutes)

Now you're on the contact-page branch. Any changes you make will only affect THIS branch, not master.

Step 1: Create a New File

Create a new file called contact.html:

<!DOCTYPE html>
<html>
<head>
    <title>Contact Us - Uganda Tech</title>
</head>
<body>
    <h1>Contact Us</h1>
    <p>Get in touch with the Uganda tech community</p>
    
    <h2>Contact Methods</h2>
    <ul>
        <li>Email: contact@ugandatech.ug</li>
        <li>Phone: +256 (0)1 234 5678</li>
        <li>Location: Kampala, Uganda</li>
    </ul>
    
    <h2>Contact Form</h2>
    <form>
        <input type="text" placeholder="Your Name" required>
        <input type="email" placeholder="Your Email" required>
        <textarea placeholder="Your Message"></textarea>
        <button type="submit">Send Message</button>
    </form>
</body>
</html>

Step 2: Update index.html

Add a link to the contact page in your index.html:

<p><a href="contact.html">Contact Us</a></p>

Step 3: Stage and Commit

git add .
git commit -m "Add contact page with contact form"

Step 4: Check Your Branch's Log

git log --oneline

You see the new commit on the contact-page branch.

Step 5: Switch Back to Master

git checkout master

Step 6: Check Master's Log

git log --oneline

Important: The contact.html file DOESN'T EXIST on master! The commits you made on the contact-page branch aren't here. This is the power of branches - you can work on multiple things separately.

Try:

ls

Or dir on Windows - you won't see contact.html here.

Step 7: Switch Back to Contact-Page

git checkout contact-page

Now contact.html appears again! You're back to where you were working.

4. Merging Branches (30 minutes)

After you've tested your feature and it works, you merge it back into master.

Step 1: Switch to Master

git checkout master

Step 2: Merge Contact-Page Into Master

git merge contact-page

You should see:

Updating a1b2c3d..e5f6g7h
Fast-forward
 contact.html | 23 ++++++++++++++
 index.html   | 1 +
 2 files changed, 24 insertions(+)
 create mode 100644 contact.html

Step 3: Verify the Files

ls

Now you should see contact.html on the master branch!

Step 4: Check the Log

git log --oneline

You see all commits, including the one from the contact-page branch. They're now part of master's history.

Step 5: Clean Up - Delete the Old Branch

Once a branch is merged, you can delete it:

git branch -d contact-page

The branch is gone, but all its commits are preserved in master.

5. Collaboration Basics (30 minutes)

Git allows teams to work together. Here's how:

Scenario: You and Your Team Member

The Setup:

• You and your team member both have the same repository
• You each work on different features in different branches
• You both push to GitHub
• Your code gets combined

Step 1: Create a New Branch for a Feature

git checkout -b newsletter-feature

This creates AND switches to a new branch in one command.

Step 2: Make Some Changes

Add content to a new file newsletter.md:

# Newsletter Signup

We want to build a newsletter feature for our Uganda Tech website.

## Features
- Email signup form
- Monthly newsletter about Uganda's tech scene
- Unsubscribe option

## Technologies
- Email service: AWS SES or Mailgun
- Database: Store emails securely
- Encryption: Protect user data

Step 3: Commit and Push

git add newsletter.md
git commit -m "Plan newsletter feature"
git push -u origin newsletter-feature

Important: -u origin newsletter-feature tells GitHub to track this new branch.

Step 4: Check GitHub

Go to GitHub.com and refresh. You should see:

• Your repository now has a newsletter-feature branch
• GitHub shows your new file

Step 5: On GitHub, Create a Pull Request (Simulation)

On GitHub, you'd normally click "New Pull Request" to ask for your team member to review your work. But for now, you can manually merge:

git checkout master
git merge newsletter-feature
git push

Now your master branch on GitHub has the newsletter changes.

6. Best Practices for Branches (15 minutes)

Here's how professional teams use branches:

Branch Naming Conventions

Professional teams name branches clearly:

• feature/login-system - Adding a new feature
• bugfix/fix-validation - Fixing a bug
• hotfix/critical-issue - Urgent production fix
• docs/update-readme - Documentation updates
• refactor/optimize-queries - Code improvements

Example Workflow

1. Create a feature branch:

   git checkout -b feature/ugandan-payment-integration
   

2. Do your work:

   git add .
   git commit -m "Integrate Pesalink payment option"
   git commit -m "Add MTN Mobile Money integration"
   

3. Push to GitHub:

   git push -u origin feature/ugandan-payment-integration
   

4. Team reviews on GitHub

5. Merge to master:

   git checkout master
   git pull origin master  # Get latest changes
   git merge feature/ugandan-payment-integration
   git push
   

6. Delete the feature branch:

   git branch -d feature/ugandan-payment-integration
   

7. Pulling Changes from GitHub (15 minutes)

If your team member pushed code to GitHub, here's how you get their changes:

git pull

This does two things:

1. git fetch - Downloads changes from GitHub
2. git merge - Combines those changes with your local code

8. Understanding Conflicts (10 minutes - Advanced)

Merge conflicts happen when you and your teammate edited the same line differently.

Example: You both edited index.html's title:

• Your version: <title>Uganda Tech Community</title>
• Their version: <title>East Africa's Tech Hub</title>

Git can't choose, so it marks the conflict in the file:

<<<<<<< HEAD
<title>Uganda Tech Community</title>
=======
<title>East Africa's Tech Hub</title>
>>>>>>> newsletter-feature

Solution: Open the file, decide which version you want (or combine them), then commit.

For today, just know conflicts exist. You'll learn to handle them in Week 2 when you work with your team.

Practical Exercise: Complete Workflow

Do this entire workflow one more time to practice:

1. Create a branch:

   git checkout -b feature/events-page
   

2. Create a new file events.md:

   # Uganda Tech Events
   
   ## September 2026
   - Sept 5: Kampala Dev Meetup
   - Sept 12: Mobile Development Workshop
   - Sept 19: Data Science Bootcamp
   
   ## October 2026
   - Oct 3: Annual Tech Conference
   - Oct 10: Hackathon
   

3. Commit:

   git add events.md
   git commit -m "Add events page with upcoming tech events"
   

4. Push:

   git push -u origin feature/events-page
   

5. Merge back to master:

   git checkout master
   git merge feature/events-page
   

6. Delete the branch:

   git branch -d feature/events-page
   

7. Push to GitHub:

   git push
   

Uganda Context: Real Teams Using Branches

At Jumia Uganda's development team:

• Master branch = Live production code (stable)
• develop branch = Testing branch (latest features)
• feature branches = Individual developers work here
  • feature/payment-redesign
  • feature/mobile-optimization
  • feature/new-categories
• bugfix branches = Quick fixes
  • bugfix/checkout-error
  • bugfix/login-timeout

Each developer works on their own branch, pushes to GitHub, and the team reviews before merging.

End of Week 1 Summary

What You've Learned:

✅ Git Basics

• Installing and configuring Git
• Creating repositories
• Making commits with meaningful messages
• Viewing commit history

✅ GitHub Integration

• Creating GitHub accounts and repositories
• Pushing code to GitHub
• Understanding remote repositories
• Backing up your code in the cloud

✅ Collaboration

• Creating and switching branches
• Merging branches
• Understanding pull requests
• Best practices for team development

✅ Professional Workflows

• Staging changes before committing
• Writing clear commit messages
• Using branches for features
• Pushing to share code

Your Week 1 Checklist:

• Git installed and configured
• Created and committed to local repositories
• Created a GitHub account
• Pushed code to GitHub
• Created and merged branches
• Understand version control basics

Homework for This Weekend

Task 1: Explore Your Own Work

On GitHub, go to your repository. Browse through:

• Your files
• Your complete commit history
• The changes in each commit

Task 2: Reflect and Document

Create a file called WEEK-1-REFLECTION.md with:

# Week 1 Reflection - Git & GitHub

## What I Learned
- 

## Most Useful Concept
- 

## One Challenge I Had
- 

## How I'd Use This in a Team
-

## Questions for Next Week
-

Fill this out honestly - your coach wants to know what made sense and what was confusing.

Task 3: Clean Up Your Repo

• Remove test files you created during practice
• Add these files to a commit: git add . then git commit -m "Clean up test files"
• Push to GitHub: git push

Vocabulary Learned This Week

Common Git Commands Reference

# Setup
git config --global user.name "Your Name"
git config --global user.email "your@email.com"

# Create & Commit
git init                  # Create new repository
git add file.txt          # Stage file
git add .                 # Stage all files
git commit -m "Message"   # Commit with message
git status                # See what's changed
git diff                  # See exact changes

# History
git log                   # Full commit history
git log --oneline         # Short commit history
git log -p                # Show changes in commits

# Branches
git branch                # List branches
git branch name           # Create branch
git checkout name         # Switch to branch
git merge name            # Merge branch into current
git branch -d name        # Delete branch

# Remote & GitHub
git remote add origin URL # Connect to GitHub
git push                  # Upload to GitHub
git pull                  # Download from GitHub
git clone URL             # Download entire repository

# Undo
git checkout file         # Discard changes
git reset file            # Unstage file
git commit --amend        # Change last commit message

Week 2 Preview

Next week: HTML & HTML Tags

You'll:

• Learn what HTML is and why it matters
• Master every common HTML tag
• Build multi-page websites
• Make daily commits to GitHub with your team member
• Add David Emiru Egwell (makanika) as a collaborator
• Practice the Git workflow you learned this week

Come ready to code!

End of Week 1: Git & GitHub Fundamentals

Created with ❤️ for Uganda's next generation of developers

Week 1: Quick Reference Guide

Git & GitHub Cheat Sheet for Diploma Students

Installation Verification

git --version
git config --global user.name
git config --global user.email

Daily Workflow (What You'll Do Every Day)

# 1. Edit your files in your code editor
# 2. Check what changed
git status

# 3. Stage your changes
git add .

# 4. Save changes with a message
git commit -m "Clear description of changes"

# 5. Upload to GitHub
git push

Creating a Repository

# One-time setup
mkdir MyProject
cd MyProject
git init

# Connect to GitHub (one-time)
git remote add origin https://github.com/USERNAME/REPO-NAME.git

# Push your work
git push -u origin master

Working with Branches

# See current branch
git branch

# Create new branch
git branch feature-name

# Switch to branch
git checkout feature-name

# Create and switch in one step
git checkout -b feature-name

# Merge branch into master
git checkout master
git merge feature-name

# Delete branch
git branch -d feature-name

Viewing History

# Full commit log
git log

# Short version
git log --oneline

# Last 5 commits
git log -5

# Pretty graph
git log --oneline --graph --all

Fixing Mistakes

# Discard changes to a file
git checkout filename

# Unstage a file
git reset filename

# Change last commit message
git commit --amend -m "New message"

# Undo last commit (keep changes)
git reset HEAD~1

# View what changed
git diff

GitHub Operations

# Connect to GitHub (one-time)
git remote add origin URL

# Download code from GitHub
git clone URL

# Upload changes
git push

# Download changes
git pull

# See remote info
git remote -v

File Management

# Create a new file
touch filename.txt

# List files
dir             # Windows Command Prompt
Get-ChildItem   # Windows PowerShell

# Create a folder
mkdir foldername

# Navigate into folder
cd foldername

# Go back one folder
cd ..

# See current location
cd              # Windows Command Prompt
Get-Location    # Windows PowerShell

Important Settings (Do Once)

# Tell Git who you are
git config --global user.name "Your Full Name"
git config --global user.email "your.email@gmail.com"

# Make it permanent
git config --global core.editor "nano"  # or your preferred editor

# Verify settings
git config --global --list

Emergency Commands

# If you're confused, see status
git status

# If you made a mistake, undo before committing
git checkout filename

# If you want to see what changed
git diff

# If you committed something wrong, fix it
git commit --amend -m "Corrected message"

Uganda Tech Companies Using Git

✅ Jumia Uganda - E-commerce platform ✅ MTN Uganda - Mobile and payment solutions
✅ Pesalink - Fast money transfers ✅ AirtelTigo - Telecommunications ✅ Stanbic Bank - Digital banking

All use Git and GitHub for their development teams!

When to Commit

Good times to commit:

• ✅ Added a new feature
• ✅ Fixed a bug
• ✅ Changed styling
• ✅ Updated documentation
• ✅ End of your work session

Bad times to commit:

• ❌ Broken code (commit only when it works)
• ❌ After changing 10 different things (break into smaller commits)
• ❌ Without a clear message

Writing Good Commit Messages

Format: verb + what you changed

Examples:

✅ Add login form validation
✅ Fix navigation menu responsive design
✅ Update README installation instructions
✅ Refactor database queries for performance
✅ Remove unused CSS classes
✅ Create user authentication module

NOT:

❌ update stuff
❌ fixes
❌ asdf
❌ final
❌ v2

Troubleshooting

"Permission denied" when pushing?

• Generate a Personal Access Token on GitHub
• Use token instead of password

"Nothing to commit"?

• You haven't made changes, or
• Changes aren't staged yet (git add .)

"Merge conflict"?

• Open the file, decide which version to keep
• Stage and commit the resolved file

"Detached HEAD"?

• You're looking at an old commit
• Run: git checkout master to go back

Pro Tips

1. Commit often: Daily is better than weekly
2. Push regularly: Don't wait until the end - push every day
3. Write clear messages: Future you will thank present you
4. Use branches: One feature per branch
5. Never commit passwords: Keep secrets out of Git
6. Review before committing: Use git diff to see exactly what you're saving

Next Week

You'll already know Git, so Week 2 will focus on HTML. You'll:

• Create multiple HTML files
• Commit each day to GitHub
• Work with a team member
• Practice the Git workflow you learned this week

Prepare by: Make sure you can run git status, git add, git commit, and git push without thinking!

Keep this reference handy!

Week 2: HTML & HTML Tags

Building Your First Website - With Daily Git Commits

For Diploma Computer Science Students

Week Overview

This week, you'll learn HTML (HyperText Markup Language) - the foundation of every website on the internet.

What You'll Learn:

• ✅ What HTML is and why it matters
• ✅ HTML structure and proper formatting
• ✅ Essential HTML tags and their purpose
• ✅ Creating multi-page websites
• ✅ Semantic HTML (using tags correctly)
• ✅ HTML forms and input elements
• ✅ Best practices for accessibility

Learning Time: 5 days (Monday-Friday)

Daily Commits: One meaningful commit per day to GitHub

Collaboration: Add David Emiru Egwell (makanika) as collaborator

Practicum: 2-3 hours per day

Daily Schedule

Prerequisites for This Week

✅ Git installed and configured ✅ GitHub account created (with professional username!) ✅ Code editor (VS Code recommended) ✅ Understanding of Week 1 Git concepts ✅ Your Week 1 repository working

MONDAY: HTML Fundamentals

1. What is HTML? (20 minutes)

HTML = HyperText Markup Language

Breaking it down:

• HyperText = Text with links (the "hyper" part means it's interactive)
• Markup = Tags that "mark up" (describe) content
• Language = A system of communication with the computer

HTML is NOT:

• ❌ A programming language (no logic or calculations)
• ❌ For styling (that's CSS)
• ❌ For interactivity (that's JavaScript)

HTML IS:

• ✅ For structure (organizing content)
• ✅ For meaning (labeling what things are)
• ✅ For accessibility (helping screen readers)
• ✅ The foundation of every website

Real-World Example

When you visit Jumia Uganda's website and see:

[Logo] [Search Bar] [Cart]
Products:
- Phone
- Laptop
- Headphones

The HTML describes this structure. The browser reads it and displays it.

2. HTML Structure (30 minutes)

Every HTML document follows a standard structure:

<!DOCTYPE html>
<html>
  <head>
    <!-- Information about the page goes here -->
    <title>Page Title</title>
  </head>
  <body>
    <!-- Content that displays goes here -->
    <h1>Welcome</h1>
    <p>Your content here</p>
  </body>
</html>

Breaking It Down

<!DOCTYPE html>

• Tells the browser: "This is an HTML5 document"
• Must be first line
• Only one per document

<html> tag

• Wraps the entire document
• Everything goes inside
• Like a container for all your content

<head> section

• Contains information ABOUT the page
• Doesn't display on the page itself
• Includes: title, links to CSS, meta information

<body> section

• Contains everything that displays on the page
• All your visible content goes here
• Headings, paragraphs, images, links, etc.

Tag Syntax

Tags come in pairs:

<tagname>Content goes here</tagname>

• Opening tag: <tagname>
• Closing tag: </tagname> (note the /)
• Content: What goes between them
• Exception: Some tags are "self-closing" (like <img />)

3. Essential Tags for Content (30 minutes)

These tags describe different types of content:

Headings (h1 - h6)

<h1>Main Title</h1>
<h2>Section Title</h2>
<h3>Subsection</h3>
<h4>Small heading</h4>
<h5>Smaller heading</h5>
<h6>Smallest heading</h6>

Rules:

• Use only ONE <h1> per page
• Use headings in order (don't jump from h1 to h3)
• Each heading describes the content that follows

Paragraphs

<p>This is a paragraph. Paragraphs are for regular text content.</p>
<p>This is another paragraph.</p>

Line Breaks

<p>First line<br>Second line</p>

The <br> tag creates a line break without starting a new paragraph.

Text Formatting

<strong>This text is important</strong>
<em>This text is emphasized</em>
<mark>This text is highlighted</mark>
<u>This text is underlined</u>
<s>This text is struck through</s>
<small>This text is smaller</small>
<code>This is code text</code>

Comments

<!-- This is a comment - it won't display on the page -->
<!-- Use comments to explain your code to future developers -->

4. Creating Your First HTML File (30 minutes)

Step 1: Create a New Folder

Create a folder called week-2-html-project in a good location on your computer.

Step 2: Initialize Git

Open Terminal/Command Prompt in this folder and run:

git init
git config user.name "Your Name"
git config user.email "your@email.com"

Step 3: Create index.html

Create a file called index.html with this content:

<!DOCTYPE html>
<html>
  <head>
    <title>Uganda's Greatest Inventions</title>
  </head>
  <body>
    <h1>Uganda's Greatest Inventions & Innovations</h1>
    
    <h2>Introduction</h2>
    <p>Uganda has contributed significantly to global innovation despite challenges. Here are some remarkable inventions and innovations from Ugandan minds.</p>
    
    <h2>Notable Inventions</h2>
    
    <h3>1. The Automated Cassava Processing Machine</h3>
    <p>Developed to improve cassava processing efficiency, this machine has helped thousands of farmers in Uganda and across East Africa. Cassava is a staple food crop in Uganda.</p>
    
    <h3>2. Mobile Money Innovation</h3>
    <p>While not invented solely in Uganda, MTN Mobile Money and services like Pesalink were pioneered and perfected in Uganda. These systems have revolutionized finance for millions across Africa.</p>
    
    <h3>3. The Water-Saving Showerhead</h3>
    <p>Ugandan engineers have developed innovative water-saving technologies that are crucial in a water-conscious future.</p>
    
    <h2>Why Innovation Matters</h2>
    <p>Uganda's young population and tech-savvy generation are creating solutions for local problems. This is the future of the country.</p>
    
    <p><small>Created by: [Your Name]</small></p>
  </body>
</html>

Step 4: Test Your File

Open the index.html file in your web browser (double-click or drag into browser). You should see:

• A title in the browser tab
• Your content formatted with headings and paragraphs

5. Making Your First Commit (20 minutes)

Now you'll practice the Git workflow you learned in Week 1.

Step 1: Check Status

git status

You should see index.html as an untracked file.

Step 2: Stage the File

git add index.html

Step 3: Create the Commit

Write a clear, descriptive commit message:

git commit -m "Create index.html with Uganda innovations content"

Step 4: View Your Commit

git log --oneline

You should see your commit recorded!

End of Day 1 Checklist

• Understand basic HTML structure
• Know the purpose of common HTML tags
• Created first HTML file that displays in browser
• Made first commit with meaningful message

Reflection Question:

Why do you think HTML needs both opening and closing tags?

TUESDAY: Common HTML Tags & Multiple Pages

1. Understanding More HTML Tags (30 minutes)

Lists

Websites need lists everywhere (navigation, products, steps, etc.)

Unordered Lists (bullets):

<ul>
  <li>First item</li>
  <li>Second item</li>
  <li>Third item</li>
</ul>

Ordered Lists (numbered):

<ol>
  <li>First step</li>
  <li>Second step</li>
  <li>Third step</li>
</ol>

Links

Links are the core of the web - they connect pages together.

<a href="page2.html">Click here to go to page 2</a>
<a href="https://www.example.com">External link</a>
<a href="#section2">Jump to section 2 on this page</a>

Anatomy:

• <a> = anchor tag (for links)
• href="..." = where the link goes
• Text between tags = what the user sees

Images

<img src="image.png" alt="Description of image">

Anatomy:

• src = path to the image file
• alt = text that displays if image can't load (important for accessibility!)

Dividers and Containers

<hr>  <!-- Horizontal line -->

<div>
  <!-- Container for grouping content -->
  <p>Content goes here</p>
</div>

2. Creating Page 2: Ugandan Tech Companies (45 minutes)

Create a new file called companies.html:

<!DOCTYPE html>
<html>
  <head>
    <title>Uganda's Tech Companies</title>
  </head>
  <body>
    <h1>Uganda's Leading Tech Companies</h1>
    
    <p><a href="index.html">← Back to Home</a></p>
    
    <h2>E-Commerce & Retail</h2>
    
    <h3>Jumia Uganda</h3>
    <p>East Africa's leading e-commerce platform. Offers:</p>
    <ul>
      <li>Electronics</li>
      <li>Fashion</li>
      <li>Home & Appliances</li>
      <li>Same-day delivery in Kampala</li>
    </ul>
    
    <h2>Financial Technology</h2>
    
    <h3>Pesalink</h3>
    <p>Fast, secure money transfer service. Features:</p>
    <ul>
      <li>Instant transfers between bank accounts</li>
      <li>Low transaction fees</li>
      <li> 24/7 availability</li>
      <li>Covers major Ugandan banks</li>
    </ul>
    
    <h3>MTN Mobile Money</h3>
    <p>Uganda's most used mobile payment service:</p>
    <ol>
      <li>Dial *165# on your MTN phone</li>
      <li>Register for Mobile Money</li>
      <li>Send and receive money instantly</li>
      <li>Pay bills and buy airtime</li>
    </ol>
    
    <h2>Telecommunications</h2>
    
    <h3>MTN Uganda</h3>
    <p>The largest telecom company in Uganda, providing mobile and internet services to millions.</p>
    
    <h3>Airtel Uganda</h3>
    <p>Second-largest telecom provider with strong presence across the country.</p>
    
    <hr>
    
    <p><a href="index.html">← Back to Home</a></p>
  </body>
</html>

3. Linking Your Pages (20 minutes)

Now update your index.html to link to the new page:

Find this line in your index.html:

<h2>Why Innovation Matters</h2>

And ADD this BEFORE it:

<p><a href="companies.html">View Uganda's Tech Companies →</a></p>

<hr>

Now test: Open index.html in your browser, click the link, and you should go to companies.html!

4. Creating Page 3: Programming Resources (30 minutes)

Create resources.html:

<!DOCTYPE html>
<html>
  <head>
    <title>Learning Resources</title>
  </head>
  <body>
    <h1>Learning Resources for Ugandan Developers</h1>
    
    <p><a href="index.html">← Back to Home</a></p>
    
    <h2>Online Platforms</h2>
    <ul>
      <li><a href="https://www.freecodecamp.org">freeCodeCamp</a> - Completely free coding education</li>
      <li><a href="https://www.codecademy.com">Codecademy</a> - Interactive coding courses</li>
      <li><a href="https://www.coursera.org">Coursera</a> - University-level courses</li>
      <li><a href="https://www.udemy.com">Udemy</a> - Affordable courses on many topics</li>
    </ul>
    
    <h2>Local Opportunities</h2>
    <ul>
      <li><strong>Makerere University</strong> - Main tech programs in Uganda</li>
      <li><strong>Coding Bootcamps in Kampala</strong> - Intensive programs (3-6 months)</li>
      <li><strong>Tech Meetups</strong> - Free community learning events</li>
      <li><strong>Internships</strong> - Real-world experience at companies</li>
    </ul>
    
    <h2>Communities</h2>
    <ul>
      <li>Uganda Developers Community</li>
      <li>Women in Technology Uganda</li>
      <li>JavaScript Developers Kampala</li>
      <li>Python Uganda</li>
    </ul>
    
    <hr>
    
    <p><a href="index.html">← Back to Home</a></p>
  </body>
</html>

5. Creating a Navigation Menu (20 minutes)

Now update index.html to have links to all pages. Find the opening <body> tag and add this right after it:

  <body>
    <nav>
      <h2>Navigation</h2>
      <ul>
        <li><a href="index.html">Home</a></li>
        <li><a href="companies.html">Tech Companies</a></li>
        <li><a href="resources.html">Resources</a></li>
      </ul>
    </nav>
    
    <hr>

Add the same navigation to companies.html and resources.html (right after the opening <body> tag).

6. Staging and Committing Multiple Files (30 minutes)

Now you have 3 HTML files. Time to commit your work.

Step 1: Check Status

git status

You should see all three files (or new changes if they already exist).

Step 2: Stage All Files

git add .

Step 3: Create Meaningful Commit

git commit -m "Create multi-page website with companies and resources pages"

Step 4: View Your Work

git log --oneline

You now have 2 commits - one from Monday and one from Tuesday!

End of Day 2 Checklist

• Created 3 HTML pages (index, companies, resources)
• Added links between pages
• Created unordered and ordered lists
• Committed your work to Git with meaningful message
• All pages are working and properly linked

Reflection Question:

What would happen if you misspelled a filename in your link tag?

WEDNESDAY: Semantic HTML & Proper Structure

1. Understanding Semantic HTML (30 minutes)

So far, you've used basic tags. But HTML has special tags that describe the meaning of content.

Non-Semantic:

<div>
  <div>Article Title</div>
  <p>Article content here...</p>
</div>

Semantic:

<article>
  <h1>Article Title</h1>
  <p>Article content here...</p>
</article>

Both look the same, but semantic tags:

• ✅ Tell screen readers what content is
• ✅ Help search engines understand your site
• ✅ Make your code easier to maintain
• ✅ Follow modern web standards

2. Common Semantic Tags (40 minutes)

Header

<header>
  <h1>Website Title</h1>
  <p>Website tagline</p>
</header>

Use for: Page title, logo, main heading area

Navigation

<nav>
  <ul>
    <li><a href="/">Home</a></li>
    <li><a href="/about">About</a></li>
    <li><a href="/contact">Contact</a></li>
  </ul>
</nav>

Use for: Main navigation menus

Main Content

<main>
  <article>
    <h2>Article Title</h2>
    <p>Article content...</p>
  </article>
</main>

Use for: The primary content of your page

Section

<section>
  <h2>Why Uganda's Tech Matters</h2>
  <p>Content about tech in Uganda...</p>
</section>

Use for: Logical groupings of related content

Aside

<aside>
  <h3>Related Links</h3>
  <ul>
    <li><a href="#">Link 1</a></li>
    <li><a href="#">Link 2</a></li>
  </ul>
</aside>

Use for: Side content, ads, related information

Footer

<footer>
  <p>&copy; 2026 Uganda Tech Education</p>
  <p>Contact: info@ugandatech.edu</p>
</footer>

Use for: Copyright, contact info, site links

3. Restructuring Your Pages Semantically (1 hour)

Let's rebuild index.html with proper semantic structure:

<!DOCTYPE html>
<html>
  <head>
    <title>Uganda's Greatest Inventions</title>
  </head>
  <body>
    <header>
      <h1>Uganda's Greatest Inventions & Innovations</h1>
      <p>Celebrating innovation from the Pearl of Africa</p>
    </header>
    
    <nav>
      <ul>
        <li><a href="index.html">Home</a></li>
        <li><a href="companies.html">Tech Companies</a></li>
        <li><a href="resources.html">Resources</a></li>
      </ul>
    </nav>
    
    <main>
      <section>
        <h2>Introduction</h2>
        <p>Uganda has contributed significantly to global innovation despite challenges. Here are some remarkable inventions and innovations from Ugandan minds.</p>
      </section>
      
      <section>
        <h2>Notable Inventions</h2>
        
        <article>
          <h3>1. The Automated Cassava Processing Machine</h3>
          <p>Developed to improve cassava processing efficiency, this machine has helped thousands of farmers in Uganda and across East Africa. Cassava is a staple food crop in Uganda.</p>
        </article>
        
        <article>
          <h3>2. Mobile Money Innovation</h3>
          <p>While not invented solely in Uganda, MTN Mobile Money and services like Pesalink were pioneered and perfected in Uganda. These systems have revolutionized finance for millions across Africa.</p>
        </article>
        
        <article>
          <h3>3. The Water-Saving Showerhead</h3>
          <p>Ugandan engineers have developed innovative water-saving technologies that are crucial in a water-conscious future.</p>
        </article>
      </section>
      
      <section>
        <h2>Why Innovation Matters</h2>
        <p>Uganda's young population and tech-savvy generation are creating solutions for local problems. This is the future of the country.</p>
      </section>
    </main>
    
    <aside>
      <h3>Quick Facts</h3>
      <ul>
        <li>Uganda has 48+ million people</li>
        <li>Over 80% are under 30 years old</li>
        <li>Tech sector growing at 30% annually</li>
        <li>Kampala is the regional tech hub</li>
      </ul>
    </aside>
    
    <footer>
      <p>&copy; 2026 Uganda Tech Education Project</p>
      <p>Created by: [Your Name] | <a href="#">Contact</a></p>
    </footer>
  </body>
</html>

Do the same for companies.html and resources.html - add:

• <header> at the top
• <nav> with links
• Wrap main content in <main>
• Logical <section> tags
• <footer> at the bottom

4. Committing Your Semantic HTML (15 minutes)

git add .
git commit -m "Restructure pages with semantic HTML elements"

View your progress:

git log --oneline

You should see 3 commits now!

End of Day 3 Checklist

• Understand semantic HTML and why it matters
• Restructured all pages with proper semantic tags
• All pages have header, nav, main, aside (if applicable), footer
• Committed changes with meaningful message

Reflection Question:

Why would a screen reader (for blind users) prefer semantic HTML over generic <div> tags?

THURSDAY: HTML Forms & Interactive Elements

1. Understanding Forms (30 minutes)

Forms let users submit information to websites. Every time you:

• Login to your email
• Order food
• Fill a survey
• Search on Google

You're using an HTML form.

Form Structure

<form>
  <!-- form elements go here -->
</form>

Input Types

<input type="text" placeholder="Enter your name">
<input type="email" placeholder="Your email">
<input type="password" placeholder="Password">
<input type="number" placeholder="Enter a number">
<input type="date">
<input type="submit" value="Send Form">

Labels

Every input should have a label:

<label for="name">Full Name:</label>
<input type="text" id="name" placeholder="Enter your name">

• for attribute on label = matches id on input
• Helps accessibility (screen readers)
• Clicking label focuses the input

Text Areas

For longer text:

<label for="message">Your Message:</label>
<textarea id="message" placeholder="Type your message here..."></textarea>

Buttons

<button type="submit">Send</button>
<button type="reset">Clear Form</button>
<button type="button">Click Me</button>

Select (Dropdown)

<label for="country">Select your country:</label>
<select id="country">
  <option>-- Choose --</option>
  <option>Uganda</option>
  <option>Kenya</option>
  <option>Tanzania</option>
  <option>Rwanda</option>
</select>

Checkboxes & Radio Buttons

<!-- Checkboxes - multiple selections -->
<input type="checkbox"> Python
<input type="checkbox"> JavaScript
<input type="checkbox"> Java

<!-- Radio buttons - single selection -->
<input type="radio" name="level"> Beginner
<input type="radio" name="level"> Intermediate
<input type="radio" name="level"> Advanced

2. Creating a Contact Form Page (1 hour)

Create a new file called contact.html:

<!DOCTYPE html>
<html>
  <head>
    <title>Contact Us</title>
  </head>
  <body>
    <header>
      <h1>Contact Uganda Tech Education</h1>
      <p>Get in touch with our team</p>
    </header>
    
    <nav>
      <ul>
        <li><a href="index.html">Home</a></li>
        <li><a href="companies.html">Tech Companies</a></li>
        <li><a href="resources.html">Resources</a></li>
        <li><a href="contact.html">Contact</a></li>
      </ul>
    </nav>
    
    <main>
      <section>
        <h2>Send us a Message</h2>
        
        <form>
          <div>
            <label for="fullname">Full Name:</label>
            <input type="text" id="fullname" placeholder="Your full name" required>
          </div>
          
          <div>
            <label for="email">Email Address:</label>
            <input type="email" id="email" placeholder="your.email@example.com" required>
          </div>
          
          <div>
            <label for="phone">Phone Number:</label>
            <input type="text" id="phone" placeholder="+256 (0)1 234 5678">
          </div>
          
          <div>
            <label for="topic">Topic:</label>
            <select id="topic" required>
              <option>-- Select a topic --</option>
              <option>General Inquiry</option>
              <option>Support</option>
              <option>Partnership</option>
              <option>Feedback</option>
            </select>
          </div>
          
          <div>
            <label for="message">Your Message:</label>
            <textarea id="message" placeholder="Tell us what's on your mind..." rows="5" required></textarea>
          </div>
          
          <div>
            <label>What are you interested in?</label>
            <input type="checkbox"> Web Development
            <input type="checkbox"> Mobile Apps
            <input type="checkbox"> Data Science
            <input type="checkbox"> Cloud Computing
          </div>
          
          <div>
            <label>How did you hear about us?</label>
            <input type="radio" name="source"> Google Search
            <input type="radio" name="source"> Friend Referral
            <input type="radio" name="source"> Social Media
            <input type="radio" name="source"> Other
          </div>
          
          <div>
            <button type="submit">Send Message</button>
            <button type="reset">Clear Form</button>
          </div>
        </form>
      </section>
      
      <section>
        <h2>Contact Information</h2>
        <p><strong>Email:</strong> contact@ugandatech.edu</p>
        <p><strong>Phone:</strong> +256 (0)1 234 5678</p>
        <p><strong>Location:</strong> Kampala, Uganda</p>
      </section>
    </main>
    
    <footer>
      <p>&copy; 2026 Uganda Tech Education Project</p>
      <p>Created by: [Your Name] | <a href="#">Contact</a></p>
    </footer>
  </body>
</html>

3. Update Navigation on All Pages (15 minutes)

Add the Contact link to your navigation on:

• index.html
• companies.html
• resources.html

Add this line to each navigation <ul>:

<li><a href="contact.html">Contact</a></li>

4. Committing Your Forms (15 minutes)

git add .
git commit -m "Add contact page with HTML form and input elements"

View your progress:

git log --oneline

You should have 4 commits!

End of Day 4 Checklist

• Understand different HTML form input types
• Know how to use labels and form structure
• Created a functional contact form
• Updated navigation on all pages
• Committed changes to Git

Reflection Question:

Why is the required attribute important for form inputs?

FRIDAY: Polish, Accessibility & Final Review

1. Improving Accessibility (30 minutes)

Accessibility means making your site usable for everyone, including:

• People with vision impairments (using screen readers)
• People with hearing impairments
• People with motor disabilities
• People with cognitive disabilities
• People with slow internet connections

Add Alt Text to Images

If you have images, add descriptions:

<!-- Bad: -->
<img src="photo.png">

<!-- Good: -->
<img src="photo.png" alt="Developer from Uganda coding on laptop">

Use Semantic HTML (Already done!)

Your semantic tags (<header>, <nav>, <main>, <footer>) help screen readers.

Use Proper Heading Hierarchy

<!-- Correct: -->
<h1>Page Title</h1>
<h2>Section</h2>
<h3>Subsection</h3>

<!-- Wrong: -->
<h1>Page Title</h1>
<h3>Subsection</h3>  <!-- Skipped h2! -->

Make Links Descriptive

<!-- Bad: -->
<p>Click <a href="/resources">here</a> for resources.</p>

<!-- Good: -->
<p><a href="/resources">View learning resources</a> for your studies.</p>

Color and Contrast

Text should be readable. Test your site:

• Is text large enough?
• Is there enough contrast between text and background?
• Don't rely only on color to communicate (some people are colorblind)

2. Adding Meta Tags (20 minutes)

Meta tags go in <head> and provide information about your page:

Update the <head> section of ALL your pages:

<head>
  <title>Page Title</title>
  <meta charset="UTF-8">
  <meta name="description" content="Short description of page content">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="author" content="Your Name">
</head>

What these do:

• charset - Ensures special characters display correctly
• description - Shows in search engine results
• viewport - Makes site mobile-friendly
• author - Identifies who created the site

3. Code Quality Review (30 minutes)

Check Your HTML Quality

Use valid HTML:

• Every opening tag has a closing tag
• Tags are properly nested
• No typos in tag names
• Proper indentation (for readability)

Example of proper indentation:

<body>
  <header>
    <h1>Title</h1>
  </header>
  
  <nav>
    <ul>
      <li><a href="#">Link</a></li>
    </ul>
  </nav>
</body>

Add Meaningful Comments

Comments help future developers (including yourself!) understand your code:

<!-- Navigation menu -->
<nav>
  ...
</nav>

<!-- Main content section -->
<main>
  ...
</main>

<!-- Contact form for user inquiries -->
<form>
  ...
</form>

Verify All Links Work

Test every link:

• Navigation links work
• Links to other pages work
• External links open correctly

4. Creating a README for Your Project (30 minutes)

Create a file called README.md in your project folder:

# Uganda Tech Education Website

A multi-page website about Uganda's technology innovations and education resources.

## Project Pages

- **index.html** - Home page with innovation highlights
- **companies.html** - Information about major Ugandan tech companies
- **resources.html** - Learning resources for aspiring developers
- **contact.html** - Contact form for inquiries

## What I Learned This Week

- HTML structure and semantic tags
- Creating multi-page websites
- HTML forms and input elements
- Accessibility best practices
- Version control with Git

## Technologies Used

- HTML5
- Git/GitHub for version control

## How to View

1. Download all files
2. Open index.html in your web browser
3. Click links to navigate between pages

## Author

[Your Name]

## Date Created

September 2026

5. Final Commit and Push to GitHub (30 minutes)

Step 1: Stage All Changes

git add .

Step 2: Make Final Commit

git commit -m "Add accessibility features, meta tags, README, and final polish"

Step 3: Set Up GitHub (If Not Done)

If this is your first time pushing this project:

git remote add origin https://github.com/YOUR-USERNAME/week-2-html-project.git
git push -u origin master

Or if already set up:

git push

Step 4: Add David Emiru Egwell as Collaborator

On GitHub.com:

1. Go to your repository
2. Click "Settings"
3. Click "Collaborators"
4. Search for username: makanika
5. Click "Add collaborator"

Now David can see your work and collaborate on the project!

6. Viewing Your Work on GitHub (15 minutes)

On GitHub.com:

✅ Check that:

• All 5 files are visible (index.html, companies.html, resources.html, contact.html, README.md)
• Commit history shows all 5 commits from the week
• README.md displays nicely on the main page
• David Emiru Egwell (makanika) is listed as collaborator

Click on Commits

Review your commit messages - they tell the story of how your website evolved:

1. Monday: "Create index.html with Uganda innovations content"
2. Tuesday: "Create multi-page website with companies and resources pages"
3. Wednesday: "Restructure pages with semantic HTML elements"
4. Thursday: "Add contact page with HTML form and input elements"
5. Friday: "Add accessibility features, meta tags, README, and final polish"

This is what professional development looks like!

End of Week 2 Summary

What You've Learned:

✅ HTML Fundamentals

• Proper HTML document structure
• Common HTML tags and their purposes
• Creating multi-page websites with links

✅ Semantic HTML

• Using meaningful tags for content
• Improving accessibility
• Following web standards

✅ HTML Forms

• Creating interactive forms
• Various input types
• Labels and form structure

✅ Best Practices

• Accessibility guidelines
• Code quality and indentation
• Meta tags and SEO
• Documentation with README

✅ Professional Development

• Daily Git commits
• Pushing to GitHub
• Working with collaborators
• Professional GitHub presence

Your Week 2 Checklist:

• 5 HTML pages created and linked
• Semantic HTML structure implemented
• Contact form with multiple input types
• 5 meaningful commits made
• Code pushed to GitHub
• David Emiru Egwell added as collaborator
• README documentation created
• All links tested and working

Homework for This Weekend

Task 1: Code Review

Go through each of your HTML files and:

• Ensure every tag has proper opening and closing
• Check indentation is consistent
• Verify all links work
• Test form inputs

Task 2: Add More Content

Add at least 3 new sections to your pages with relevant Uganda tech content.

Task 3: Accessibility Audit

• Add alt text to any images
• Check color contrast (use WebAIM Contrast Checker)
• Test with a screen reader (if available)

Task 4: Reflection

Create WEEK-2-REFLECTION.md with:

# Week 2 Reflection - HTML & Git Practice

## What Was Easiest?

## What Was Challenging?

## HTML Tags I Feel Confident With?

## HTML Tags I Need More Practice With?

## How Git Commits Helped My Learning?

## Questions for Week 3?

Vocabulary Learned This Week

Week 3 Preview

Next week: ASCII, HEX & Binary

You'll:

• Learn how computers represent data
• Convert numbers between different bases
• Write your name in binary and hexadecimal
• Understand character encoding (ASCII)
• Continue daily Git commits

Prepare by: Review Week 1 Git commands - you'll be committing daily again!

End of Week 2: HTML & HTML Tags

Created with ❤️ for Uganda's future developers

Week 3: ASCII, HEX & Binary

Understanding How Computers Represent Data

For Diploma Computer Science Students

Week Overview

This week, you'll learn how computers actually represent data. Everything on your computer - text, images, videos, programs - is ultimately just numbers in different formats.

What You'll Learn:

• ✅ Binary (base 2) number system
• ✅ Hexadecimal (base 16) number system
• ✅ Decimal (base 10) number system
• ✅ ASCII character encoding
• ✅ Converting between number bases
• ✅ Writing your name in binary and hexadecimal
• ✅ Understanding how computers store information

Learning Time: 5 days (Monday-Friday)

Daily Commits: One per day to GitHub

Practicum: 2-3 hours per day

Why This Matters

Real-world example from Uganda's tech companies:

When Pesalink transfers money:

• Your amount is stored in binary on the server
• Transaction IDs are in hexadecimal
• Your name and account details are stored using ASCII encoding
• The entire system relies on understanding how data is represented

Without understanding these concepts, you can't debug networking issues, understand database errors, or work with low-level systems.

MONDAY: Introduction to Number Systems

1. Understanding Number Systems (30 minutes)

We use decimal (base 10) daily: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

But computers use different systems:

Why Different Systems?

Decimal: Easy for humans to understand Binary: Easy for computers (on/off, 1/0, true/false) Hexadecimal: Compact way to write binary (used in colors, memory addresses, etc.)

2. Binary (Base 2) - How Computers Think (45 minutes)

Binary uses only two digits: 0 and 1

Everything in your computer is ultimately:

• 0 (off, false, no power)
• 1 (on, true, power)

Place Values in Binary

Decimal place values: 1000s, 100s, 10s, 1s (powers of 10)

Binary place values: 128s, 64s, 32s, 16s, 8s, 4s, 2s, 1s (powers of 2)

Binary position:    8    7    6    5    4    3    2    1
Power of 2:        2^7  2^6  2^5  2^4  2^3  2^2  2^1  2^0
Place value:       128   64   32   16    8    4    2    1
Example binary:     1    0    1    0    1    0    1    0

Converting Binary to Decimal

Example: What is 10101 in decimal?

Position:    5    4    3    2    1
Power:      2^4  2^3  2^2  2^1  2^0
Value:       16    8    4    2    1
Binary:       1    0    1    0    1
              ×    ×    ×    ×    ×
Result:      16 +  0  +  4  +  0  +  1  = 21

So 10101 (binary) = 21 (decimal)

Converting Decimal to Binary

Example: Convert 13 to binary

Find which powers of 2 add up to 13:

• 13 = 8 + 4 + 1
• 13 = 2³ + 2² + 2⁰

So binary representation:

Position:    4    3    2    1    0
Power:      2^4  2^3  2^2  2^1  2^0
Value:       16    8    4    2    1
                ✓    ✓         ✓
Result:      0    1    1    0    1

13 (decimal) = 01101 (binary)

3. Practical Exercise: Binary Conversions (30 minutes)

Convert These Decimals to Binary:

5 = ________
10 = ________
15 = ________
20 = ________
31 = ________

Answers:

• 5 = 00101
• 10 = 01010
• 15 = 01111
• 20 = 10100
• 31 = 11111

Convert These Binaries to Decimal:

1001 = ________
1111 = ________
10000 = ________
11011 = ________

Answers:

• 1001 = 9
• 1111 = 15
• 10000 = 16
• 11011 = 27

4. Understanding Hexadecimal (Base 16) (30 minutes)

Hexadecimal uses 16 digits: 0-9, then A-F

Decimal:     0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
Hex:         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F

Why Hexadecimal?

Binary can be very long: 11111111 (255 in decimal)

Hexadecimal is shorter: FF (same as 255)

Place Values in Hexadecimal

Hex position:    3    2    1    0
Power of 16:    16^3 16^2 16^1 16^0
Place value:    4096  256   16    1

Converting Hex to Decimal

Example: 1A in hex = ? in decimal

Position:      1    0
Power:        16^1 16^0
Value:         16    1
Hex digit:      1    A(10)
               ×    ×
Result:       16 + 10 = 26

So 1A (hex) = 26 (decimal)

Converting Decimal to Hex

Example: 255 in decimal = ? in hex

• 255 ÷ 16 = 15 remainder 15
• Quotient 15 ÷ 16 = 0 remainder 15
• Read remainders from bottom to top: 15, 15
• 15 in hex is F, 15 in hex is F
• Answer: FF

5. Practical Exercise: Hexadecimal (30 minutes)

Convert These Decimals to Hex:

16 = ________
255 = ________
256 = ________
4096 = ________

Answers:

• 16 = 10
• 255 = FF
• 256 = 100
• 4096 = 1000

Convert These Hex Values to Decimal:

10 = ________
FF = ________
A5 = ________
1F = ________

Answers:

• 10 = 16
• FF = 255
• A5 = 165
• 1F = 31

6. Creating Your First Conversion Document (30 minutes)

Create a file called conversions.txt:

JOANNAH KUTEESA - NUMBER SYSTEM CONVERSIONS

Decimal Number: 74 (random number for example)

Binary Conversion:
74 = 64 + 8 + 2
74 = 2^6 + 2^3 + 2^1
74 = 01001010 (binary)

Hexadecimal Conversion:
74 ÷ 16 = 4 remainder 10
4 ÷ 16 = 0 remainder 4
Read from bottom: 4, 10(A)
74 = 4A (hexadecimal)

Verification:
Binary 01001010:
Position:  7  6  5  4  3  2  1  0
Value:   128 64 32 16  8  4  2  1
Binary:    0  1  0  0  1  0  1  0
           0 64  0  0  8  0  2  0 = 74 ✓

Hex 4A:
4 × 16 = 64
A(10) × 1 = 10
64 + 10 = 74 ✓

7. First Commit (15 minutes)

git add conversions.txt
git commit -m "Add number system conversions - decimal, binary, hexadecimal"

End of Day 1 Checklist

• Understand binary place values
• Can convert between decimal and binary
• Understand hexadecimal place values
• Can convert between decimal and hex
• Created conversions document
• Made first commit

Reflection Question:

Why would knowing hexadecimal be useful for a web developer? (Hint: think about colors)

TUESDAY: ASCII - How Letters Become Numbers

1. Understanding ASCII (30 minutes)

ASCII = American Standard Code for Information Interchange

ASCII is a system that assigns a number to every character.

For example:

• Letter 'A' = 65
• Letter 'a' = 97
• Number '1' = 49
• Space ' ' = 32
• Exclamation '!' = 33

Why ASCII Exists

When you type 'A' in an email:

1. Your keyboard sends a signal
2. The computer converts it to ASCII number 65
3. It's stored as binary (01000001)
4. When displayed, the computer converts 65 back to 'A'
5. You see the letter on screen

ASCII Table (Common Characters)

Decimal  Character
32       Space
48-57    0-9 (numbers)
65-90    A-Z (uppercase)
97-122   a-z (lowercase)

Special:
33       !
34       "
35       #
36       $
37       %
38       &

Complete ASCII table: false

2. Converting Characters to ASCII (40 minutes)

Manual Method

Look up each character in ASCII table:

• 'H' = 72
• 'e' = 101
• 'l' = 108
• 'l' = 108
• 'o' = 111

So "Hello" = 72 101 108 108 111

Converting to Binary

Once you have ASCII values, convert to binary:

• 'A' = 65 (decimal) = 01000001 (binary)
• 'B' = 66 (decimal) = 01000010 (binary)

Exercise: Your Own Name

Write down your name's ASCII values:

Example for "JOANNAH":

• J = 74
• O = 79
• A = 65
• N = 78
• N = 78
• A = 65
• H = 72

3. Your Name in ASCII (1 hour)

Create a file called my-name-ascii.txt:

JOANNAH KUTEESA - ASCII ENCODING

My Name: JOANNAH

Character-by-Character Breakdown:

J = 74 (decimal) = 01001010 (binary) = 4A (hex)
O = 79 (decimal) = 01001111 (binary) = 4F (hex)
A = 65 (decimal) = 01000001 (binary) = 41 (hex)
N = 78 (decimal) = 01001110 (binary) = 4E (hex)
N = 78 (decimal) = 01001110 (binary) = 4E (hex)
A = 65 (decimal) = 01000001 (binary) = 41 (hex)
H = 72 (decimal) = 01001000 (binary) = 48 (hex)

Complete Representation in Different Bases:

DECIMAL:  74 79 65 78 78 65 72
BINARY:   01001010 01001111 01000001 01001110 01001110 01000001 01001000
HEX:      4A 4F 41 4E 4E 41 48

How a Computer Stores "JOANNAH":
- In memory: 56 bits (7 characters × 8 bits each)
- In hex: 4A4F414E4E4148
- As numbers: 74 79 65 78 78 65 72

This is how ALL text is stored on your computer!

Do this for both your first name and last name.

4. Committing Your ASCII Work (15 minutes)

git add my-name-ascii.txt
git commit -m "Convert my name to ASCII, binary, and hexadecimal"

End of Day 2 Checklist

• Understand ASCII character encoding
• Can look up ASCII values for characters
• Created ASCII representation of your name
• Committed work to Git

Reflection Question:

If all text is just numbers, how does the computer know whether 65 means the number sixty-five or the letter 'A'?

WEDNESDAY: Your Name in Binary & Hex

1. Extended Name Analysis (1.5 hours)

Today, you'll create a comprehensive document showing your name in all formats.

Create a file called name-in-all-formats.md:

# JOANNAH KUTEESA - Complete Data Representation

## Full Name Analysis

### Character Breakdown

| Pos | Char | Decimal | Binary | Hex | Binary (Padded) |
|-----|------|---------|--------|-----|-----------------|
| 1   | J    | 74      | 1001010 | 4A | 01001010 |
| 2   | O    | 79      | 1001111 | 4F | 01001111 |
| 3   | A    | 65      | 1000001 | 41 | 01000001 |
| 4   | N    | 78      | 1001110 | 4E | 01001110 |
| 5   | N    | 78      | 1001110 | 4E | 01001110 |
| 6   | A    | 65      | 1000001 | 41 | 01000001 |
| 7   | H    | 72      | 1001000 | 48 | 01001000 |
| 8   | (space) | 32   | 100000 | 20 | 00100000 |
| 9   | K    | 75      | 1001011 | 4B | 01001011 |
| 10  | U    | 85      | 1010101 | 55 | 01010101 |
| 11  | T    | 84      | 1010100 | 54 | 01010100 |
| 12  | E    | 69      | 1000101 | 45 | 01000101 |
| 13  | S    | 83      | 1010011 | 53 | 01010011 |
| 14  | A    | 65      | 1000001 | 41 | 01000001 |

### Full Name in Different Bases

**DECIMAL:**

74 79 65 78 78 65 72 32 75 85 84 69 83 65

**BINARY (Concatenated):**

01001010 01001111 01000001 01001110 01001110 01000001 01001000 00100000 01001011 01010101 01010100 01000101 01010011 01000001

**HEXADECIMAL:**

4A 4F 41 4E 4E 41 48 20 4B 55 54 45 53 41

### Memory Usage

- Length: 14 characters
- Bits used: 112 bits (14 × 8)
- Bytes used: 14 bytes
- In hex representation: 4A4F414E4E414820 4B55544553 41

### Interesting Observations

1. **Case sensitivity in ASCII:**
   - Uppercase 'A' = 65
   - Lowercase 'a' = 97
   - Difference: 32 (which is the space character!)

2. **Binary patterns:**
   - Notice all my name starts with 01 in binary
   - This is because capital letters are 64-90 in ASCII

3. **Real-world application:**
   - When you send an email with "Joannah Kuteesa", your computer converts it to this format
   - It travels across the internet as these numbers
   - Recipient's computer converts back to letters for display

## Verification

Let me verify one conversion:

**J = 74:**
- 64 + 8 + 2 = 74
- 2^6 + 2^3 + 2^1 = 74
- Binary: 01001010 ✓
- Hex: 4A (4 × 16 + 10 = 74) ✓

Create a similar document with your actual names.

2. Creating an Interactive Conversion File (45 minutes)

Create a file called conversion-guide.txt:

HOW TO MANUALLY CONVERT YOUR NAME TO BINARY

Step 1: Find ASCII value of each letter
Step 2: Convert decimal to binary using place values

Example: Converting "AI"

A = 65 (decimal)
Find powers of 2 that sum to 65:
64 + 1 = 65
2^6 + 2^0

Place:  7  6  5  4  3  2  1  0
Value: 128 64 32 16  8  4  2  1
        0  1  0  0  0  0  0  1  = 01000001

I = 73 (decimal)
Find powers of 2 that sum to 73:
64 + 8 + 1 = 73
2^6 + 2^3 + 2^0

Place:  7  6  5  4  3  2  1  0
Value: 128 64 32 16  8  4  2  1
        0  1  0  0  1  0  0  1  = 01001001

"AI" in binary: 01000001 01001001

HOW TO MANUALLY CONVERT YOUR NAME TO HEXADECIMAL

Method: Divide by 16 repeatedly

Example: 65 (letter 'A')

65 ÷ 16 = 4 remainder 1
4 ÷ 16 = 0 remainder 4

Read from bottom: 4, 1
'A' = 41 in hex

Verify: 4 × 16 + 1 = 64 + 1 = 65 ✓

For your full name, convert each character separately!

3. Committing Your Complete Name Analysis (15 minutes)

git add name-in-all-formats.md conversion-guide.txt
git commit -m "Create comprehensive name analysis in ASCII, binary, and hexadecimal"

End of Day 3 Checklist

• Created detailed table of name with all bases
• Understand how each conversion works
• Created conversion guide for reference
• Committed work to Git

Reflection Question:

If you wanted to send a secret message using only binary numbers, how would you do it?

THURSDAY: Binary Math & Practical Applications

1. Understanding Binary Math (40 minutes)

Binary Addition

Binary addition works like decimal, but with only 0 and 1:

Binary Addition Rules:
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 10 (write 0, carry 1)

Example: 5 + 3 (in binary)

  0101 (5 in decimal)
+ 0011 (3 in decimal)
------
  1000 (8 in decimal)

Checking: 5 + 3 = 8 ✓

Binary Multiplication

Binary Multiplication Rules:
0 × 0 = 0
0 × 1 = 0
1 × 0 = 0
1 × 1 = 1

Example: 4 × 2 (in binary)

  0100 (4 in decimal)
× 0010 (2 in decimal)
------
  1000 (8 in decimal)

Checking: 4 × 2 = 8 ✓

Practice Exercises

Problem: Add 6 + 5 in binary

6 = 0110
5 = 0101

  0110
+ 0101
------
  ?

Answer: 1011 (which is 11 in decimal) ✓

2. Real-World Applications (45 minutes)

IP Addresses (Network Addresses)

IP addresses like 192.168.1.1 are actually:

• 192 in binary: 11000000
• 168 in binary: 10101000
• 1 in binary: 00000001
• 1 in binary: 00000001

Full IP: 11000000.10101000.00000001.00000001

Color Codes (Web Design)

Colors are written in hex: #FF5733

• FF (red channel) = 255
• 57 (green channel) = 87
• 33 (blue channel) = 51

File Permissions (Linux)

Permissions like 755 are actually binary:

• 7 = 111 (read, write, execute)
• 5 = 101 (read, execute)
• 5 = 101 (read, execute)

3. Practical Project: Build a Simple Counter (1 hour)

Create a file called binary-counter.txt:

BINARY COUNTER - 0 to 15

Decimal  Binary      Hex
0        00000000    00
1        00000001    01
2        00000010    02
3        00000011    03
4        00000100    04
5        00000101    05
6        00000110    06
7        00000111    07
8        01000000    08
9        01000001    09
10       01001010    0A
11       01001011    0B
12       01001100    0C
13       01001101    0D
14       01001110    0E
15       01001111    0F

Observation: With 8 bits, we can represent 256 different values (0-255).
This is why bytes are so important in computing!

With more bits:
- 8 bits (1 byte): 256 values (0-255)
- 16 bits (2 bytes): 65,536 values (0-65535)
- 32 bits (4 bytes): 4.3 billion values
- 64 bits (8 bytes): 18 quintillion values

4. Committing Your Math & Applications (15 minutes)

git add binary-counter.txt
git commit -m "Add binary math operations and practical applications"

End of Day 4 Checklist

• Understand binary addition and multiplication
• Know real-world applications of binary/hex
• Created binary counter reference
• Committed work to Git

Reflection Question:

Why do you think a byte has exactly 8 bits? What's special about the number 256?

FRIDAY: Review, Documentation & Final Commit

1. Creating a Complete Study Guide (1 hour)

Create WEEK-3-STUDY-GUIDE.md:

# Week 3 Complete Study Guide

## Number System Quick Reference

### Decimal (Base 10)
- Uses digits: 0-9
- Human-friendly
- Most common in daily life

### Binary (Base 2)
- Uses digits: 0-1
- Computer-friendly
- 8 bits = 1 byte

### Hexadecimal (Base 16)
- Uses digits: 0-9, A-F
- Compact representation
- Used in colors, memory addresses, codes

## Conversion Cheat Sheet

### Decimal to Binary
Divide repeatedly by 2, read remainders bottom-up

### Decimal to Hex
Divide repeatedly by 16, read remainders bottom-up

### Binary to Decimal
Add place values: 128, 64, 32, 16, 8, 4, 2, 1

### Hex to Decimal
Multiply each digit by its place value (16^n)

## ASCII Facts

- Characters 0-127 are standard ASCII
- Extended ASCII includes 128-255
- Each character is one byte
- Capital letters differ from lowercase by 32

## Common Conversions to Remember

| Decimal | Binary   | Hex |
|---------|----------|-----|
| 0       | 00000000 | 00  |
| 15      | 00001111 | 0F  |
| 16      | 00010000 | 10  |
| 255     | 11111111 | FF  |

## Practical Applications

1. **Web Colors:** #RRGGBB (hex)
2. **IP Addresses:** Four 8-bit numbers
3. **File Permissions:** 3 octal digits (binary)
4. **Memory:** Measured in bytes, kilobytes, megabytes, etc.
5. **Data Encoding:** All text, images, programs are binary

## Key Concepts You Should Know

- ✓ Every number can be represented in any base
- ✓ Computers work in binary internally
- ✓ Hexadecimal is just a shorthand for binary
- ✓ ASCII maps characters to numbers
- ✓ Understanding these is essential for debugging

## Practice Problems (With Answers)

### Problem 1: Convert 42 to binary and hex

Binary: 42 = 32 + 8 + 2 = 00101010
Hex: 42 ÷ 16 = 2 remainder 10 = 2A

### Problem 2: What is "HI" in ASCII decimal?

H = 72
I = 73

### Problem 3: Convert A7 from hex to decimal

A = 10
7 = 7
10 × 16 + 7 = 167

2. Reviewing Your Week's Work (30 minutes)

Check all files in your repository:

git log --oneline

You should see 4+ commits:

1. Number system conversions
2. ASCII name encoding
3. Comprehensive name analysis
4. Binary math and applications
5. (Optional) Others you created

Check Each File

• conversions.txt - Clear and readable
• my-name-ascii.txt - Complete ASCII breakdown
• name-in-all-formats.md - Formatted table
• conversion-guide.txt - Good reference
• binary-counter.txt - Complete counter
• WEEK-3-STUDY-GUIDE.md - Comprehensive review

3. Making Code Quality Improvements (30 minutes)

Before your final commit:

• All files have clear comments
• Formatting is consistent
• No typos or errors
• Explanations are clear
• Examples are correct

4. Creating Final Documentation (30 minutes)

Create README.md if not already present:

# Week 3: Number Systems & ASCII

A complete guide to understanding how computers represent data.

## Files Included

- **conversions.txt** - Basic number system conversions
- **my-name-ascii.txt** - Your name in ASCII decimal
- **name-in-all-formats.md** - Name in decimal, binary, hex with table
- **conversion-guide.txt** - Step-by-step conversion instructions
- **binary-counter.txt** - Reference counter 0-15 in all bases
- **WEEK-3-STUDY-GUIDE.md** - Complete study guide with practice problems

## What I Learned

- Binary place values and conversion
- Hexadecimal representation
- ASCII character encoding
- How to convert between number bases
- Real-world applications of different number systems

## Key Takeaways

1. Everything in a computer is ultimately binary
2. Hex is shorthand for binary
3. ASCII maps characters to numbers
4. Understanding these concepts is essential for programming

## Technologies Practiced

- Number system conversions
- ASCII encoding
- Binary arithmetic
- Hex notation
- Git version control

## Author

[Your Name]

## Date Completed

September 2026

5. Final Commit (15 minutes)

git add .
git commit -m "Complete Week 3: Add study guide, review materials, and final documentation"

Push to GitHub

git push

6. Verification Checklist (15 minutes)

On GitHub.com:

• All files visible on main page
• README.md displays correctly
• Commit history shows progression
• All 5 daily commits recorded
• File content readable

End of Week 3 Summary

What You've Learned:

✅ Number Systems

• Binary (base 2) fundamentals
• Hexadecimal (base 16) fundamentals
• Decimal (base 10) reference
• Conversion methods for each

✅ ASCII Encoding

• Character-to-number mapping
• ASCII table reference
• Representing your name in three formats
• Understanding how text is stored

✅ Practical Applications

• Binary math (addition, multiplication)
• Color codes in web design
• IP address structure
• File permissions
• Computer memory units

✅ Professional Development

• 5 meaningful daily commits
• Code organization and documentation
• Creating effective README files
• GitHub portfolio building

Your Week 3 Checklist:

• 5+ conversion files created
• Name represented in ASCII, binary, and hex
• Complete study guide created
• 5+ meaningful commits made
• README documentation completed
• All files pushed to GitHub

Homework for This Weekend

Task 1: Extra Conversions

Convert these numbers to binary and hex:

• 128
• 200
• 512
• 1000

Task 2: ASCII Message

Write your name and a short message (3-4 words) in ASCII decimal. Example:

"Hello World" = 72 101 108 108 111 32 87 111 114 108 100

Task 3: Research Project

Research one application of binary/hex in Uganda's tech companies:

• How does Jumia use hex for product codes?
• How does MTN use binary for data transmission?
• Create a 1-page document explaining it

Task 4: Reflection

Create WEEK-3-REFLECTION.md:

# Week 3 Reflection

## Most Interesting Concept

## Most Challenging Conversion

## Real-World Application I'll Remember

## Questions for Week 4

## How This Helps Me Understand Computers Better

Vocabulary Learned This Week

Week 4 Preview

Next week: Introduction to Linux Command Line

You'll:

• Learn terminal basics
• Navigate file systems with commands
• Understand directory structure
• Write and run scripts
• Practice Linux commands essential for developers

Prepare by: Get comfortable with Week 3 concepts - you'll need to understand file permissions (binary!) in Week 4.

End of Week 3: Number Systems & ASCII

Created with ❤️ for Uganda's future developers

Week 4: Introduction to Linux Command Line

The Gateway to Professional Development

For Diploma Computer Science Students

Week Overview

This week, you'll learn Linux and the command line - the foundation for everything professional developers do.

What You'll Learn:

• ✅ Why Linux dominates professional development
• ✅ Command line fundamentals
• ✅ File system navigation and manipulation
• ✅ Text processing and searching
• ✅ User and file permissions
• ✅ Writing simple shell scripts
• ✅ Understanding Linux processes

Learning Time: 5 days (Monday-Friday)

Daily Commits: One per day to GitHub

Critical: This leads to Weeks 5-8 Linux Intensive

Practicum: 2-3 hours per day

Why Linux Matters (More Than You Think)

The Professional Reality

Question: What operating system runs the servers that power:

• Google
• Facebook
• Twitter
• Netflix
• Jumia Uganda
• MTN Uganda
• Every serious tech company

Answer: Linux (and its variants like Ubuntu)

The Market Reality

• Linux/DevOps Engineers: 50+ desperately needed in Uganda
• Frontend Developers: 1000+ available in Uganda
• Salary difference: 2-3x higher for DevOps

The Personal Reality

After learning Linux deeply:

• You can deploy your own code
• You can manage servers
• You can troubleshoot production issues
• You're worth 50-100M+/year instead of 20-30M/year

Single biggest career decision: Master Linux or skip it.

Daily Schedule

MONDAY: Linux Fundamentals & Installation

1. Understanding Linux (30 minutes)

What is Linux?

Linux = Operating System

• Like Windows or Mac
• But designed for servers and professionals
• Free and open-source
• Used by 96% of top 1 million websites

Why Linux?

1. Free: No licensing costs
2. Stable: Can run for years without restart
3. Powerful: Can do anything Windows can do (and more)
4. Secure: Designed with security in mind
5. Professional: Used by all major tech companies

Linux vs Windows

Linux Distributions

Distribution = Version of Linux

Popular distributions:

• Ubuntu: Easiest for beginners, most popular
• CentOS: Used by servers, professional
• Debian: Rock-solid stability
• Red Hat: Enterprise (very expensive)

Recommendation: Ubuntu 24.04 LTS (Long Term Support)

2. Installation Options (30 minutes)

Option A: Windows Subsystem for Linux (WSL2)

Standard option for this curriculum: Learn Ubuntu while keeping Windows installed.

# On Windows PowerShell (as Administrator):
wsl --install

# Installs Ubuntu automatically
# Run from Windows terminal anytime

Pros:

• Easy to install
• Can use both Windows and Linux together
• WSL2 is very close to real Linux

Cons:

• Not exactly like real Linux
• Some features don't work perfectly
• Slower than native Linux

Option B: Virtual Machine (VirtualBox)

Best for: Learning without touching real system

# Steps:
1. Download VirtualBox (free)
2. Download Ubuntu ISO
3. Create new virtual machine
4. Install Ubuntu
5. Use Ubuntu inside VirtualBox

Pros:

• Completely safe
• Can snapshot and restore

Cons:

• Slower performance
• Disk space needed
• More complex setup

Recommendation for This Curriculum

Month 1-2 (Weeks 1-4):

• Use Option C or D
• Learn with safety net
• Get comfortable with Linux

Month 2-3 (Weeks 5-8 intensive):

• Continue with WSL2 or VirtualBox
• Practise on a remote Ubuntu server when learning deployment
• Keep Windows installed throughout the curriculum

3. Setting Up Your Linux Environment (60 minutes)

Step 1: Choose Your Option and Install

Pick one of the options above and follow installation steps.

For WSL2 (Easiest for now):

Open PowerShell as Administrator:

wsl --install

# After reboot, WSL2 + Ubuntu installed automatically
# Open Ubuntu from Start menu

Step 2: First Commands

Open terminal and run:

# See who you are
whoami

# See where you are
pwd

# See what files are here
ls

# See what files in detail
ls -la

# See system information
uname -a

# See Ubuntu version
lsb_release -a

Step 3: Update System

# Update package lists
sudo apt update

# Install updates
sudo apt upgrade -y

# Install useful tools
sudo apt install curl wget git build-essential -y

Step 4: Create Your Learning Directory

# Create folder for learning
mkdir -p ~/projects/week-4-linux

# Navigate into it
cd ~/projects/week-4-linux

# Initialize git repository
git init

# Create README
echo "# Week 4: Linux Command Line Learning" > README.md

# First commit!
git add README.md
git commit -m "Initialize Linux learning repository"

4. Understanding the Linux File System (30 minutes)

Directory Structure

Linux has standard directories:

/ (root)
├── home/          Your personal files
│   └── username/
├── root/          Superuser's home
├── etc/           System configuration
├── var/           Variable data (logs, cache)
├── tmp/           Temporary files
├── usr/           User programs and libraries
├── bin/           Essential commands
├── sbin/          System administration commands
├── lib/           Libraries
└── dev/           Device files

Key Paths to Know

~              Your home directory (/home/username)
.              Current directory
..             Parent directory
/              Root (top of file system)

Navigation Commands

pwd            Print working directory (where you are)
cd folder      Change directory
cd ..          Go up one folder
cd ~           Go to home directory
cd /           Go to root
cd -           Go back to previous directory

5. First Commit to GitHub (20 minutes)

Set up Git

# Configure git (if not already done)
git config --global user.name "Your Name"
git config --global user.email "your@email.com"

# Verify
git config --global --list

Create GitHub Repository

1. Go to github.com
2. Click "+" → "New repository"
3. Name it: week-4-linux-learning
4. Click "Create repository"

Connect Local to GitHub

# In your ~/projects/week-4-linux folder

# Add remote
git remote add origin https://github.com/YOUR-USERNAME/week-4-linux-learning.git

# Rename branch (if needed)
git branch -M main

# Push to GitHub
git push -u origin main

Commit Your First Linux Work

# Add and commit
git add .
git commit -m "Initialize Week 4 Linux learning project"

# Push
git push

End of Day 1 Checklist

• Linux installed (WSL2, dual boot, or VM)
• Terminal is open and working
• Can run basic commands (whoami, pwd, ls)
• Git is configured
• GitHub repository created
• First commit pushed

Reflection Question:

Why do you think 96% of web servers run Linux instead of Windows?

TUESDAY: Command Line Basics

1. Essential Commands (45 minutes)

File Navigation and Listing

ls                 List files
ls -l              List with details (long format)
ls -la             Include hidden files (files starting with .)
ls -lh             File sizes in human-readable format
ls -S              Sort by file size
ls -t              Sort by time (newest first)

cd folder          Change directory
cd ..              Go up one level
cd ~               Go home
pwd                Print working directory (show current location)

Creating Files and Directories

mkdir folder       Create directory
mkdir -p a/b/c     Create nested directories
touch file.txt     Create empty file
echo "text" > file.txt   Create file with content

touch file.{1,2,3}.txt   Create file.1.txt, file.2.txt, file.3.txt

Viewing File Contents

cat file.txt       Show entire file
less file.txt      View file page-by-page (press q to exit)
head -20 file.txt  Show first 20 lines
tail -20 file.txt  Show last 20 lines
tail -f file.txt   Follow file (show new lines as they appear)

wc -l file.txt     Count lines in file

Copying, Moving, Renaming, Deleting

cp file.txt copy.txt       Copy file
cp -r folder/ backup/      Copy entire directory
mv file.txt newname.txt    Rename file (or move it)
rm file.txt                Delete file
rm -r folder/              Delete folder and contents

# BE CAREFUL with rm - it's permanent! No trash bin in Linux.

2. Hands-On Practice: Build Your Learning Repository (1.5 hours)

Create a structured learning project:

cd ~/projects/week-4-linux

# Create directories
mkdir linux-commands
mkdir bash-scripts
mkdir practice-files

# Create documentation file
cat > linux-commands/basic-commands.txt << 'EOF'
WEEK 4 - LINUX COMMAND LINE BASICS

Monday Completed:
- Linux installation
- Basic commands (pwd, ls, cd)
- File and directory creation
- Git repository set up

Commands Learned:
ls              List files
pwd             Current directory
cd              Change directory
mkdir           Make directory
touch           Create file
cat             View file contents
cp              Copy files
mv              Rename files
rm              Delete files (permanent!)
EOF

# Create practice script
cat > bash-scripts/test-script.sh << 'EOF'
#!/bin/bash
echo "Hello from Linux!"
echo "This is a bash script"
echo "Current directory: $(pwd)"
EOF

# Make script executable
chmod +x bash-scripts/test-script.sh

# Run the script
./bash-scripts/test-script.sh

# List what you created
ls -R

# Add everything to git
git add .
git commit -m "Create directory structure and practice files"
git push

3. Understanding Paths (30 minutes)

Absolute Paths

Start from root (/):

cd /home/joannah/projects/week-4-linux

Relative Paths

Start from current location:

# If you're in /home/joannah
cd projects/week-4-linux

# If you're in /home/joannah/projects
cd week-4-linux

# Go up and across
cd ../backup-folder

Path Shortcuts

~              Home directory (/home/username)
.              Current directory
..             Parent directory
-              Previous directory

# Examples:
cd ~           Go to home
cd ./folder    Enter folder in current directory
cd ../folder   Go up, then into folder
cd -           Go to previous directory

4. File Permissions Preview (30 minutes)

Understanding Permissions

Files have three types of permissions:

• r (read): Can view contents
• w (write): Can modify contents
• x (execute): Can run as program

Three types of users:

• owner: Person who created file
• group: Group of users
• others: Everyone else

Viewing Permissions

ls -l

# Output:
# -rw-r--r--  1  joannah  joannah  1024  Sep 1 10:30  file.txt
#  ^ ^ ^ ^ ^
#  | | | | └─ others
#  | | | └──── group
#  | | └────── owner
#  | └──────── type (- for file, d for directory)

# Breaking it down:
# -     = file
# rw-   = owner: read, write (not execute)
# r--   = group: read only
# r--   = others: read only

Changing Permissions (Binary!)

Remember Week 3? This is where it applies!

# Binary notation (like Week 3):
# r = 4, w = 2, x = 1

# Examples:
chmod 644 file.txt    # rw-r--r-- (644 in octal = 110 100 100 in binary)
chmod 755 script.sh   # rwxr-xr-x (755 = 111 101 101 in binary)
chmod 700 secret.txt  # rwx------ (700 = 111 000 000 in binary)

# Symbolic notation:
chmod +x script.sh    # Make executable
chmod -w file.txt     # Remove write permission
chmod u=rwx,g=rx,o=rx directory/   # Complex permissions

Why This Matters

# Security example:
# Private file (only you can read)
chmod 600 password.txt

# Public website (everyone can read)
chmod 644 index.html

# Executable script (you run, others can't modify)
chmod 755 backup.sh

# Secret directory (only you can access)
chmod 700 secret-folder/

End of Day 2 Checklist

• Can navigate file system confidently
• Can create files and directories
• Can copy, move, rename files
• Understand file viewing commands
• Know basic permissions
• Committed practice work to GitHub

Reflection Question:

Why is rm permanent in Linux (no trash bin) when Windows has a recycle bin?

WEDNESDAY: Advanced File Operations & Permissions

1. Finding Files (40 minutes)

The find Command

find . -name "*.txt"          Find all .txt files
find . -name "*script*"       Find files with "script" in name
find . -type f                Find all files (not directories)
find . -type d                Find all directories
find . -type f -size +1M      Find files larger than 1MB
find . -type f -size -100k    Find files smaller than 100KB
find . -mtime -7              Files modified in last 7 days
find . -name "*.log" -delete  Find and delete all .log files

# Search entire system:
find / -name "file.txt" 2>/dev/null   # Search everywhere, hide errors

The locate Command

# Faster search using index
locate filename

# But must update index first:
sudo updatedb
locate filename

The grep Command (Search Inside Files)

grep "pattern" file.txt       Find lines with "pattern" in file
grep -i "pattern" file.txt    Case-insensitive search
grep -n "pattern" file.txt    Show line numbers too
grep -c "pattern" file.txt    Count matching lines

# Search multiple files:
grep "error" /var/log/*.log   Search all logs for "error"

# Reverse search (show lines WITHOUT pattern):
grep -v "pattern" file.txt

# Real example:
grep "sudo" /var/log/auth.log | grep "joannah"
# Find all sudo commands from user joannah

2. Text Processing (45 minutes)

The cut Command (Extract Columns)

# Extract fields from structured text
cut -d ":" -f 1 /etc/passwd   Extract usernames from system file
cut -d "," -f 2 data.csv      Extract second column from CSV

# Example: Find all user accounts:
cut -d ":" -f 1 /etc/passwd
# Output:
# root
# daemon
# bin
# joannah

The sort Command

sort file.txt                 Sort lines alphabetically
sort -n file.txt              Sort numerically
sort -r file.txt              Sort in reverse (descending)
sort -k 2 file.txt            Sort by second column
sort -u file.txt              Sort and remove duplicates

The uniq Command

sort file.txt | uniq          Remove duplicate lines
sort file.txt | uniq -c       Count occurrences of each line
sort file.txt | uniq -d       Show only duplicate lines

# Real example: Find most common errors in log:
cat /var/log/syslog | sort | uniq -c | sort -rn | head -10

The sed Command (Stream Editor)

sed 's/old/new/g' file.txt              Replace all "old" with "new"
sed 's/error/warning/' file.txt         Replace first "error" on each line
sed '5d' file.txt                       Delete line 5
sed '1,10d' file.txt                    Delete lines 1-10
sed -n '5,10p' file.txt                 Print only lines 5-10

# Real examples:
sed 's/Windows/Linux/g' mistakes.txt    Fix my mistakes!
grep "error" log.txt | sed 's/error/ERROR/' # Find and highlight

Pipes and Combinations

# Pipe (|) = Send output of one command as input to next

# Example 1: Find all .txt files and count them
find . -name "*.txt" | wc -l

# Example 2: Search logs, extract specific part, count occurrences
grep "error" /var/log/syslog | cut -d ":" -f 2 | sort | uniq -c

# Example 3: Process and display nicely
cat /var/log/syslog | grep "error" | cut -d ":" -f 3 | sort | uniq -c | sort -rn

3. Permissions Deep Dive (30 minutes)

The chmod Command (Change Mode)

# Octal notation (using binary place values):
chmod 644 file.txt    # rw-r--r-- (owner: read+write, group: read, other: read)
chmod 755 script.sh   # rwxr-xr-x (owner: all, group: read+exec, other: read+exec)
chmod 700 secrets/    # rwx------ (owner only, complete privacy)
chmod 600 key.pem     # rw------- (owner: read+write, nobody else can access)

# Symbolic notation:
chmod +x file.txt        # Add execute permission for all
chmod u+x file.txt       # Add execute for user only
chmod g-w file.txt       # Remove write for group
chmod o=r file.txt       # Set other to read-only
chmod u=rwx,g=rx,o= file.txt   # Multiple at once

# Directory permissions are different:
chmod 755 directory/     # rwxr-xr-x (others can enter and list)
chmod 700 private-dir/   # rwx------ (only owner can access)

The chown Command (Change Owner)

# Change owner (needs sudo):
sudo chown newuser file.txt          # Change owner to newuser
sudo chown user:group file.txt       # Change owner and group
sudo chown -R user:group directory/  # Change entire directory tree

Real-World Permission Scenarios

# Your personal project (only you should access):
chmod 700 my-secret-project/

# Website files (users can read, you can modify):
chmod 755 /var/www/html/
chmod 644 /var/www/html/*.html

# Executable script (you execute, team can read):
chmod 755 deploy.sh

# Configuration file (only root should see):
sudo chmod 600 /etc/database.conf

# Log file (readable, writable by system, readable by others):
chmod 644 /var/log/application.log

4. Practical Project: Build a Documented Cheat Sheet (30 minutes)

# Create comprehensive reference
mkdir ~/projects/week-4-linux/commands-reference
cd ~/projects/week-4-linux/commands-reference

# Create well-organized reference
cat > file-operations.md << 'EOF'
# File Operations Reference

## Navigation
`pwd` - Print working directory
`ls` - List files
`cd` - Change directory

## File Creation & Deletion
`touch file.txt` - Create empty file
`rm file.txt` - Delete file (permanent!)
`rm -r directory/` - Delete directory

## Copying & Moving
`cp file.txt copy.txt` - Copy file
`mv file.txt newname.txt` - Move/rename
`cp -r dir/ backup/` - Copy directory

## Viewing Files
`cat file.txt` - Show entire file
`less file.txt` - Page through file
`head -5 file.txt` - First 5 lines
`tail -5 file.txt` - Last 5 lines

## Finding Files
`find . -name "*.txt"` - Find txt files
`grep "pattern" file.txt` - Search file contents

## Permissions
`ls -l` - Show permissions
`chmod 755 file` - Change permissions
`chmod +x script.sh` - Make executable

## Combining Commands
`find . -name "*.txt" | xargs wc -l` - Count lines in all txt files
EOF

# Create permissions reference
cat > permissions-guide.md << 'EOF'
# Linux Permissions Guide

## Binary to Octal (from Week 3!)

r (read) = 4
w (write) = 2  
x (execute) = 1

## Common Permission Sets

| Octal | Binary | Meaning | Use Case |
|-------|--------|---------|----------|
| 755 | 111 101 101 | rwxr-xr-x | Executable script |
| 644 | 110 100 100 | rw-r--r-- | Regular file |
| 700 | 111 000 000 | rwx------ | Private directory |
| 600 | 110 000 000 | rw------- | Secret file |
| 777 | 111 111 111 | rwxrwxrwx | Everyone full access |

## Commands

`chmod 755 file` - Make it readable and executable
`chmod 644 file` - Regular file, only owner can write
`chmod 700 dir/` - Private directory
`chown user file` - Change owner
EOF

# Commit your reference
git add .
git commit -m "Add comprehensive file operations and permissions reference"
git push

End of Day 3 Checklist

• Can find files using find and locate
• Can search file contents with grep
• Can process text with cut, sort, uniq, sed
• Understand octal permissions deeply
• Can use chmod and chown
• Created reference documentation
• Committed to GitHub

Reflection Question:

Permissions in binary (from Week 3) now make sense in Linux. Why do you think the system was designed this way?

THURSDAY: Text Processing & Scripting Basics

1. Advanced Text Processing (45 minutes)

The awk Command (Powerful Text Processing)

# awk processes text line-by-line, field-by-field
awk '{print $1}' file.txt              Print first field of each line
awk -F ":" '{print $1}' /etc/passwd    Use ":" as field separator
awk '{sum += $1} END {print sum}' nums.txt   Sum first field

# Conditional processing:
awk '{if ($1 > 100) print $0}' data.txt   Print lines where first field > 100
awk '{print $1, $NF}' file.txt         Print first and last field
awk 'NR > 5 && NR < 10 {print}' file.txt   Print lines 6-9

# Real examples:
# Extract usernames and IDs from system:
awk -F ":" '{print $1, $3}' /etc/passwd

# Count lines containing "error":
grep "error" log.txt | awk '{count++} END {print count}'

Combining Commands with Pipes

# Real-world example: Find most common errors in log file
cat /var/log/syslog | \
  grep "error" | \
  awk '{print $NF}' | \
  sort | \
  uniq -c | \
  sort -rn | \
  head -10

# What this does:
# 1. cat - read log file
# 2. grep "error" - find lines with "error"
# 3. awk '{print $NF}' - extract last field (error message)
# 4. sort - sort alphabetically
# 5. uniq -c - count occurrences
# 6. sort -rn - sort by count descending
# 7. head -10 - show top 10

# Result: You see the 10 most common errors!

2. Introduction to Bash Scripts (1 hour)

What is a Bash Script?

A bash script is a text file containing commands that bash executes in order. Instead of typing commands one-by-one, you write them in a file and run the whole file.

Structure of a Bash Script

#!/bin/bash
# This line tells the computer to use bash to run this file
# Everything after # is a comment

echo "Hello, this is a bash script!"
echo "Bash will run each line in order"

# Variables
NAME="Joannah"
AGE=20

# Using variables
echo "My name is $NAME"
echo "I am $AGE years old"

# Running commands
echo "Current directory: $(pwd)"
echo "Today is: $(date)"

Creating Your First Script

# Create file
cat > hello.sh << 'EOF'
#!/bin/bash

# Script: Simple greeting
echo "Hello from bash!"
echo "This is my first script"

# Show current directory
echo "We are in: $(pwd)"

# List files
echo "Files here:"
ls -la
EOF

# Make it executable
chmod +x hello.sh

# Run it!
./hello.sh

# Output:
# Hello from bash!
# This is my first script
# We are in: /home/joannah/projects/week-4-linux
# Files here:
# ... (list of files)

Script with Variables and Conditions

cat > personal-script.sh << 'EOF'
#!/bin/bash

# Variables
NAME="Joannah Kuteesa"
PROJECT="Week 4 Linux"
YEAR=2026

# Greet user
echo "Welcome to $PROJECT!"
echo "Hello, $NAME"
echo "Year: $YEAR"

# Conditional logic
TIME=$(date +%H)

if [ "$TIME" -lt 12 ]; then
    echo "Good morning!"
elif [ "$TIME" -lt 18 ]; then
    echo "Good afternoon!"
else
    echo "Good evening!"
fi

# Loop example
echo "Counting to 5:"
for i in 1 2 3 4 5; do
    echo "Count: $i"
done

echo "Script completed successfully!"
EOF

chmod +x personal-script.sh
./personal-script.sh

3. Practical Automation Scripts (45 minutes)

Script 1: Project Backup

cat > ~/projects/week-4-linux/backup-project.sh << 'EOF'
#!/bin/bash

# Script: Backup project directory
PROJECT_DIR="/home/joannah/projects"
BACKUP_DIR="/home/joannah/backups"
DATE=$(date +%Y-%m-%d_%H-%M-%S)
BACKUP_FILE="project-backup-$DATE.tar.gz"

# Create backup directory if it doesn't exist
mkdir -p "$BACKUP_DIR"

# Backup project
echo "Backing up $PROJECT_DIR..."
tar -czf "$BACKUP_DIR/$BACKUP_FILE" "$PROJECT_DIR"

# Verify backup
if [ -f "$BACKUP_DIR/$BACKUP_FILE" ]; then
    SIZE=$(du -h "$BACKUP_DIR/$BACKUP_FILE" | cut -f1)
    echo "✓ Backup successful!"
    echo "  File: $BACKUP_FILE"
    echo "  Size: $SIZE"
else
    echo "✗ Backup failed!"
fi
EOF

chmod +x backup-project.sh
./backup-project.sh

Script 2: System Health Check

cat > ~/projects/week-4-linux/system-check.sh << 'EOF'
#!/bin/bash

# Script: Check system health

echo "=== SYSTEM HEALTH CHECK ==="
echo ""

# CPU Info
echo "1. CPU Usage:"
top -bn1 | grep "Cpu(s)" | awk '{print "   " $0}'

# Memory Usage
echo ""
echo "2. Memory Usage:"
free -h | tail -2 | awk '{print "   " $0}'

# Disk Usage
echo ""
echo "3. Disk Usage:"
df -h / | tail -1 | awk '{print "   Used: " $3 " / Total: " $2}'

# Uptime
echo ""
echo "4. System Uptime:"
uptime | awk '{print "   " $0}'

# Number of users logged in
echo ""
echo "5. Logged in users:"
who | wc -l | awk '{print "   " $1 " users"}'

echo ""
echo "=== CHECK COMPLETE ==="
EOF

chmod +x system-check.sh
./system-check.sh

Script 3: Git Auto-Commit

cat > ~/projects/week-4-linux/git-daily-commit.sh << 'EOF'
#!/bin/bash

# Script: Commit changes daily

PROJECT_DIR="$HOME/projects/week-4-linux"
cd "$PROJECT_DIR"

# Check if there are changes
if [ -n "$(git status -s)" ]; then
    echo "Changes detected in $PROJECT_DIR"
    
    # Stage changes
    git add -A
    
    # Commit with date
    DATE=$(date +"%Y-%m-%d %H:%M:%S")
    git commit -m "Daily update: $DATE"
    
    # Push to GitHub
    git push
    
    echo "✓ Committed and pushed successfully"
else
    echo "No changes to commit"
fi
EOF

chmod +x git-daily-commit.sh

# Test it
./git-daily-commit.sh

4. Committing Your Script Collection (20 minutes)

# Organize your scripts
mkdir -p ~/projects/week-4-linux/bash-scripts

# Move scripts there
mv hello.sh personal-script.sh backup-project.sh system-check.sh git-daily-commit.sh ~/projects/week-4-linux/bash-scripts/

# Create documentation
cat > ~/projects/week-4-linux/bash-scripts/README.md << 'EOF'
# Bash Scripts Collection

## Scripts

1. **hello.sh** - Basic script demonstrating variables and commands
2. **personal-script.sh** - Script with variables, conditionals, and loops
3. **backup-project.sh** - Automates project directory backup
4. **system-check.sh** - Checks system health (CPU, memory, disk)
5. **git-daily-commit.sh** - Automate daily Git commits

## How to Run

```bash
chmod +x script-name.sh
./script-name.sh

Key Learnings

• Bash scripts start with #!/bin/bash
• Variables: NAME="value" then use $NAME
• Commands: Use $(command) to capture output
• Conditions: if [ condition ]; then ... fi
• Loops: for i in list; do ... done

Automation Ideas

• Run git-daily-commit.sh daily to backup code
• Run system-check.sh to monitor server
• Modify backup-project.sh for different directories EOF

Commit everything

cd ~/projects/week-4-linux git add bash-scripts/ git commit -m "Add bash script collection for automation" git push

---

## End of Day 4 Checklist

- [ ] Understand awk for text processing
- [ ] Know how to pipe commands together
- [ ] Created first bash script
- [ ] Wrote automation scripts
- [ ] Can make scripts executable
- [ ] Committed scripts to GitHub

### Reflection Question:
**How could you use these bash scripts in a professional job to save time?**

---

# FRIDAY: Review, Integration & Looking Forward

## 1. Week 4 Comprehensive Review (30 minutes)

### What You've Learned This Week

**Monday:**
- Linux fundamentals
- Installation options
- Basic commands (pwd, ls, cd)
- File system structure

**Tuesday:**
- Essential commands (ls, cd, mkdir, touch, cat, cp, mv, rm)
- File and directory operations
- Navigation and listing

**Wednesday:**
- Finding files (find, locate, grep)
- Text processing (cut, sort, uniq, sed)
- Permissions (chmod, chown)
- Binary permissions in practice

**Thursday:**
- Advanced text processing (awk)
- Bash scripting
- Automation scripts
- Making scripts executable

### Commands You Now Know

```bash
# Navigation
pwd, cd, ls

# File Operations
touch, mkdir, cp, mv, rm, cat, less, head, tail

# Finding & Searching
find, locate, grep

# Text Processing
cut, sort, uniq, sed, awk

# Permissions
chmod, chown, ls -l

# Scripting
echo, variables, conditions, loops

# All combined with pipes (|)

2. Consolidating Your Learning (45 minutes)

Create Master Reference Document

mkdir -p ~/projects/week-4-linux/reference-docs

cat > ~/projects/week-4-linux/reference-docs/COMPLETE-GUIDE.md << 'EOF'
# Week 4 Complete Linux Command Line Guide

## Essential Skills Mastered

### 1. Navigation & File Operations
- Navigate file system confidently
- Create, copy, move, delete files
- Organize projects in directories

### 2. Finding & Searching
- Search for files by name and properties
- Search file contents
- Filter and find specific patterns

### 3. Text Processing
- Extract specific fields from text
- Sort and deduplicate
- Transform and modify text

### 4. Permissions & Security
- Understand binary permissions (Week 3 connection!)
- Set proper permissions for files
- Change ownership of files

### 5. Automation & Scripting
- Write bash scripts
- Automate repetitive tasks
- Combine commands with pipes

## Real-World Applications

### Daily Tasks You Can Now Do

1. **Backup projects:**
   ```bash
   ./backup-project.sh

2. Monitor system health:

   ./system-check.sh
   

3. Automate git commits:

   ./git-daily-commit.sh
   

4. Find and process files:

   find . -name "*.log" | xargs wc -l
   

5. Search logs for problems:

   grep "error" /var/log/*.log | wc -l
   

Professional Value

• You can now work efficiently in terminal
• You can automate boring tasks
• You can troubleshoot systems
• You're prepared for Linux servers

Next Steps: Weeks 5-8 Linux Intensive

In Weeks 5-8, you'll:

1. Install Ubuntu as primary OS
2. Learn kernel fundamentals
3. Set up and manage servers
4. Deploy applications
5. Become DevOps-ready

This foundation (Week 4) is essential. Master these commands first. EOF

Commit this comprehensive guide

git add reference-docs/ git commit -m "Add complete Linux command line reference guide"

---

## 3. Preparing for Week 5-8 Intensive (30 minutes)

### What Comes Next

**Weeks 5-8: Linux Intensive**

You'll move from "learning Linux" to using it confidently every day:
- Keep Windows and work in Ubuntu through WSL2 or VirtualBox
- Learn Linux kernel
- Set up production servers
- Deploy real applications
- Become DevOps engineer

### Preparation Checklist

- [ ] Comfortable with all Week 4 commands
- [ ] Can write basic bash scripts
- [ ] Understand file permissions deeply
- [ ] Can navigate file system confidently
- [ ] All Week 4 work committed to GitHub

### Week 5 Environment

**Use WSL2 or VirtualBox. Do not dual boot or replace Windows.**

**Option A: Continue with WSL2 (Recommended)**
- No risk to Windows
- Run Ubuntu from Windows Terminal or VS Code
- Suitable for Git, Python, Bash, and most development tasks

**Option B: Use VirtualBox**
- Keeps Ubuntu completely separate from Windows
- Useful for practising a full Ubuntu desktop
- Take snapshots before experimental system changes

**For server practice:** Create a small remote Ubuntu server only after learning the security basics. It is separate from the student laptop.

---

## 4. Final Week 4 Commit (15 minutes)

```bash
# Create final summary
cat > ~/projects/week-4-linux/WEEK-4-SUMMARY.md << 'EOF'
# Week 4 Summary - Linux Command Line Fundamentals

## Completed

- ✅ Linux installed (WSL2/Ubuntu/VM)
- ✅ Terminal navigation and file operations
- ✅ Finding, searching, and processing text
- ✅ Understanding permissions (binary connection!)
- ✅ Bash scripting and automation
- ✅ Daily commits to GitHub
- ✅ Reference documentation

## Skills Gained

- Comfortable in terminal environment
- Can navigate file system
- Can write useful bash scripts
- Can automate tasks
- Can troubleshoot basic issues

## Confidence Level

Before Week 4: "Linux is scary"
After Week 4: "I can work in terminal like a pro"

## Prepared For

Week 5-8 intensive Linux study including:
- Ubuntu installation
- Linux kernel basics
- Server administration
- Production deployment
- DevOps fundamentals

## Statistics

- Commands learned: 30+
- Scripts created: 5+
- Git commits this week: 5+
- Days practicing: 5
- Hours invested: 10-15 hours

This is the foundation. Everything else builds on this.

## To Improve

Areas to practice more:
- Advanced grep patterns
- Complex sed operations
- Advanced awk programming
- Shell scripting logic

But the basics are solid. Ready for next level!
EOF

# Final commit
git add .
git commit -m "Complete Week 4: Linux fundamentals mastered, ready for intensive"
git push

# Verify everything is on GitHub
echo "Week 4 complete! Check your GitHub for all commits."

End of Week 4 Checklist

• All daily commits pushed to GitHub
• Reference documentation created
• At least 5 bash scripts written and working
• Comfortable with terminal navigation
• Understand file permissions thoroughly
• Ready for Week 5 intensive

Week 4 Summary

What You Accomplished

✅ Learned Linux command line from basics to scripting ✅ Understood how permissions work (binary from Week 3!) ✅ Created useful automation scripts ✅ Committed daily to GitHub ✅ Built professional foundation

How This Prepares You

This Week 4 foundation is essential for:

• Weeks 5-8: Linux intensive (replacing Windows, kernel, servers)
• Career: DevOps and backend roles
• Income: 50M+/year positions
• Freedom: Ability to work on any system

Homework for This Weekend

Task 1: Master the Commands

Run each command from this week at least twice:

# Create practice files
echo "Practice data" > test.txt
echo "More data" >> test.txt

# Practice every command
ls -la
find . -name "*.txt"
grep "data" test.txt
chmod 644 test.txt
# ... and so on

Task 2: Write Additional Scripts

Create 2-3 more scripts for tasks you do frequently:

• Clean up old files
• Check internet connection
• Count files in project
• Search for large files

Task 3: Document Everything

Create a personal reference document:

• Commands you use daily
• Scripts you've written
• Problems you've solved
• Questions for Week 5

Vocabulary Learned This Week

Week 5 Preview

Next week: Linux Intensive Begins

You will:

• Continue learning Ubuntu with WSL2 or VirtualBox
• Learn what happens "under the hood"
• Understand Linux kernel
• Prepare for server management
• Start getting paid for your skills

This week built the foundation. Next week changes everything.

End of Week 4: Linux Command Line Introduction

Created specifically to prepare for the intensive Linux weeks ahead

Your path to 50M+/year starts here

Uganda Exercise Companion

Local scenarios for every Week 1-4 practice activity

How To Use This Companion

Use these scenarios in place of generic names such as project, file.txt, or example.com. They make each exercise feel like real work for a Ugandan business, school, community organisation, or technology team.

Jordan Mulungi Kaweesi and Joannah Kuteesa should take turns being the lead developer, reviewer, and documenter. Both students should complete every exercise in their own repository before collaborating.

Week 1: Git & GitHub Exercises

Exercise 1: Create Your First Repository

Ugandan scenario: A neighbourhood bakery in Ntinda, Kampala needs a simple record of its cake orders and delivery contacts.

Create a repository named ntinda-bakery-orders. Add a README.md explaining that the project will help staff track customer names, phone numbers, cake types, pickup dates, and delivery areas.

mkdir ntinda-bakery-orders
cd ntinda-bakery-orders
git init
printf "# Ntinda Bakery Orders\n\nA simple order-tracking project for a local Kampala bakery.\n" > README.md
git add README.md
git commit -m "Initialize Ntinda bakery order project"

Joannah's version: Document customer communication and delivery coordination.

Jordan's version: Document the order data and daily sales summary.

Exercise 2: Make a Meaningful Second Commit

Ugandan scenario: The bakery now wants a list of cake flavours commonly requested by customers.

Create cake-flavours.txt with entries such as vanilla, chocolate, red velvet, banana, and fruit cake. Commit only this focused change.

printf "Vanilla\nChocolate\nRed velvet\nBanana\nFruit cake\n" > cake-flavours.txt
git add cake-flavours.txt
git commit -m "Add cake flavour options for Kampala customers"

Check: git log --oneline should show two commits that explain different changes.

Exercise 3: Practise Status, Diff, and Staging

Ugandan scenario: A delivery rider asks the bakery to include service areas: Ntinda, Bukoto, Naguru, Kololo, and Kisaasi.

1. Add the areas to README.md but do not save immediately.
2. Run git status and git diff.
3. Stage the file with git add README.md.
4. Run git diff --staged before committing.

Use this commit message:

git commit -m "Document bakery delivery areas in Kampala"

Exercise 4: Create a Branch

Ugandan scenario: The bakery wants mobile-money payment instructions, but those instructions should be reviewed before appearing in the main project.

git switch -c add-mobile-money-details
printf "\n## Payment\nCustomers can confirm payment before delivery using approved mobile-money details.\n" >> README.md
git add README.md
git commit -m "Add mobile-money payment guidance"

Review the branch with git log --oneline --all --graph, then merge it only after the text is correct.

Safety lesson: Never commit a real mobile-money PIN, bank account secret, password, or customer personal data to Git or GitHub.

Exercise 5: Resolve a Collaboration Change

Ugandan scenario: Jordan updates the delivery section while Joannah updates the contact section for the same bakery project.

1. Jordan creates a branch called jordan-delivery-rules.
2. Joannah creates a branch called joannah-customer-contact.
3. Each changes a different heading in README.md.
4. Each commits with their own clear message.
5. Merge both branches into main.

Review question: Which commit explains who changed what and why most clearly?

Exercise 6: Push to GitHub

Ugandan scenario: Publish the repository as a portfolio sample called “Local Business Order Tracker.”

Add a public GitHub description that states it is an educational sample, not the bakery's real live ordering system. Confirm that no customer telephone numbers or payment information are included.

Week 2: HTML Exercises

Exercise 1: Build the Home Page

Ugandan scenario: Build an information website for a community reading club in Jinja.

Your home page should include:

• A heading: Jinja Community Reading Club
• A short mission statement
• Meeting location and day
• A list of age groups served
• A link to a contact page

Joannah's emphasis: Make the page welcoming to girls and young women who want to join technology and reading activities.

Jordan's emphasis: Add a clear section about book donations and volunteer support.

Exercise 2: Create Multi-Page Navigation

Ugandan scenario: Add programmes.html, events.html, and contact.html for the reading club.

Use the same navigation menu on every page. Add realistic sample events, such as a Saturday reading circle, a school-holiday coding session, and a Luganda storytelling afternoon.

<nav aria-label="Main navigation">
  <a href="index.html">Home</a>
  <a href="programmes.html">Programmes</a>
  <a href="events.html">Events</a>
  <a href="contact.html">Contact</a>
</nav>

Exercise 3: Use Semantic HTML

Ugandan scenario: On the events page, use header, main, section, article, and footer to describe a literacy event at Jinja Public Library.

Check: Use only one h1. Give each event its own article and heading. Explain why these choices help a screen-reader user find the next event.

Exercise 4: Build an Accessible Form

Ugandan scenario: Create a volunteer-registration form for the reading club.

Include labels for name, email, telephone number, preferred volunteering role, and availability. Use sample contact details only; do not publish real student or participant details.

<label for="availability">When are you available?</label>
<select id="availability" name="availability">
  <option>Saturday morning</option>
  <option>Saturday afternoon</option>
  <option>School holidays</option>
</select>

Exercise 5: Review and Commit Daily

Use one of these meaningful daily Git commits:

Create reading club home page
Add navigation for programmes and events pages
Structure events page with semantic HTML
Add accessible volunteer registration form
Document project and complete accessibility review

Week 3: ASCII, Hexadecimal, and Binary Exercises

Exercise 1: Convert Local Names to Binary

Ugandan scenario: Convert the town name KAMPALA from ASCII decimal to binary and hexadecimal.

Repeat the process for JINJA, MBARARA, or your own district name.

Exercise 2: Convert a Name

Joannah: Convert JOANNAH KUTEESA to ASCII, binary, and hexadecimal.

Jordan: Convert JORDAN MULUNGI KAWEESI to ASCII, binary, and hexadecimal.

Then compare the byte lengths of the two names and explain why a space is also stored as a character.

Exercise 3: Use Hexadecimal in a Web Project

Ugandan scenario: Create a colour palette for the Jinja reading-club website.

Lake blue: #136F8A
Sunset gold: #D99A2B
Leaf green: #2E7D32
Paper ivory: #F9F6EF

Explain that each pair of hexadecimal digits represents the red, green, and blue intensity of a colour.

Exercise 4: Build a Binary Counter

Ugandan scenario: A small bus stage in Kampala wants a simple counter for available seats. Represent 0 to 15 seats using four binary digits.

Extend the table to cover every number from 0 to 15. Explain why four bits can represent exactly $2^4 = 16$ values.

Week 4: Linux Command-Line Exercises

Exercise 1: Create a Project Directory

Ugandan scenario: Create a workspace for a Kampala market-price research project.

mkdir -p ~/projects/kampala-market-prices/{data,notes,scripts}
cd ~/projects/kampala-market-prices
printf "# Kampala Market Prices\n\nSample research data for learning Linux commands.\n" > README.md
git init
git add README.md
git commit -m "Initialize Kampala market price research project"

Use fictional sample values. Do not claim that the prices are current market data.

Exercise 2: Navigate, Copy, Move, and View Files

Ugandan scenario: Make a file called data/owino-sample-prices.txt containing fictional prices for matooke, beans, tomatoes, and rice.

Practise:

pwd
ls -la data
cat data/owino-sample-prices.txt
cp data/owino-sample-prices.txt data/owino-sample-prices-backup.txt
mv notes notes-from-research

Check: Explain the difference between cp and mv in this scenario.

Exercise 3: Search and Process Text

Ugandan scenario: Search a fictional customer-feedback file for the word delivery and count the results.

grep -in "delivery" data/customer-feedback.txt
grep -ic "delivery" data/customer-feedback.txt
sort data/customer-feedback.txt | uniq -c

Try a second search for Kampala, Jinja, or Mbarara. Explain what the -i, -n, and -c options do.

Exercise 4: Apply Permissions

Ugandan scenario: A student team has a private notes folder and a public web page.

mkdir private-notes public-site
touch private-notes/interview-notes.txt public-site/index.html
chmod 700 private-notes
chmod 600 private-notes/interview-notes.txt
chmod 755 public-site
chmod 644 public-site/index.html
ls -ld private-notes public-site
ls -l private-notes public-site

Explain why interview notes should be private and why a public HTML page needs to be readable by a web server.

Exercise 5: Write a Bash Script

Ugandan scenario: Create a script that records the date and a fictional market-research task completed that day.

cat > scripts/daily-research-note.sh << 'EOF'
#!/bin/bash

DATE=$(date +%F)
echo "$DATE: Reviewed sample Kampala market-price data." >> notes-from-research/progress.log
echo "Daily note recorded."
EOF

chmod +x scripts/daily-research-note.sh
./scripts/daily-research-note.sh

Read the log with cat notes-from-research/progress.log, then commit the script:

git add scripts/daily-research-note.sh
git commit -m "Add daily market research note script"

Final Shared Project

Kampala Community Services Directory

Jordan and Joannah should work together on a small directory of fictional community services. It can include a reading club, a bicycle-repair service, a local produce supplier, and a youth coding group.

The project must include:

• A GitHub repository with clear commit history
• A semantic multi-page HTML site
• A form with labels and accessible controls
• A short DATA-NOTES.md explaining which entries are fictional
• A scripts/ folder with one useful Bash script
• A README.md that credits both Joannah and Jordan equally

Suggested shared commits:

Initialize Kampala community services directory
Add accessible reading club information page
Document fictional service-directory data
Add script for checking project files
Complete Jordan and Joannah project review

Exercise Safety Rules

1. Use fictional personal data in public projects.
2. Never commit passwords, PINs, API keys, mobile-money details, or real customer records.
3. Ask permission before using an organisation's name, logo, photos, or data.
4. Check claims about businesses, prices, events, and job opportunities before publishing them.
5. Commit work that you understand and can explain.

Built for Jordan Mulungi Kaweesi and Joannah Kuteesa as they practise real technical work in a Ugandan context.

Student Examples: Jordan & Joannah

Personalized Learning Examples for Both Students - Equal Representation

Introduction

This document shows parallel examples for both students working through the curriculum together. They're learning at the same pace, supporting each other, and both will achieve professional developer status by month 6.

WEEK 1: Git & GitHub Setup - Both Students

GitHub Username Selection

Joannah Kuteesa's Choice

Selected: joannah-kuteesa
Reasoning: Professional, actual name, easy to spell
GitHub URL: github.com/joannah-kuteesa

Jordan Mulungi Kaweesi's Choice

Selected: jordan-mulungi
Reasoning: Professional, middle name included, memorable
GitHub URL: github.com/jordan-mulungi

Both chose professional, name-based usernames that will serve them throughout their careers.

Git Configuration - Side by Side

Joannah's Setup

git config --global user.name "Joannah Kuteesa"
git config --global user.email "joannah.kuteesa@gmail.com"

Jordan's Setup

git config --global user.name "Jordan Mulungi Kaweesi"
git config --global user.email "jordan.mulungi@gmail.com"

First Repository - Parallel Learning

Joannah's First Commit

mkdir week-1-joannah-practice
cd week-1-joannah-practice
git init
echo "# Joannah's Git Learning" > README.md
git add README.md
git commit -m "Initialize repository - Joannah's Git journey begins"

Jordan's First Commit

mkdir week-1-jordan-practice
cd week-1-jordan-practice
git init
echo "# Jordan's Git Learning" > README.md
git add README.md
git commit -m "Initialize repository - Jordan's Git learning starts"

Week 1 Commits - Both Students

Joannah's Week 1 Progress

1. "Initialize repository - Joannah's Git journey begins"
2. "Add Uganda tech companies research"
3. "Create development resources document"
4. "Set up branches for feature development"
5. "Merge branches and prepare for Week 2"

Jordan's Week 1 Progress

1. "Initialize repository - Jordan's Git learning starts"
2. "Add Uganda tech innovation research"
3. "Create learning objectives document"
4. "Create feature branches for practice"
5. "Merge branches - ready for Week 2"

WEEK 2: HTML Portfolio Projects

Joannah's Website Theme

Topic: Women in Uganda's Tech Industry

Joannah's Project Structure

joannah-website/
├── index.html (Women leaders in tech)
├── companies.html (Companies hiring women)
├── resources.html (Female-focused learning)
└── contact.html (Contact form)

Joannah's index.html Opening

<!DOCTYPE html>
<html>
  <head>
    <title>Women in Uganda's Technology Industry</title>
  </head>
  <body>
    <header>
      <h1>Celebrating Women in Uganda's Tech</h1>
      <p>Created by: Joannah Kuteesa | September 2026</p>
    </header>

Jordan's Website Theme

Topic: Male Tech Innovators & Entrepreneurs in Uganda

Jordan's Project Structure

jordan-website/
├── index.html (Tech innovators & entrepreneurs)
├── companies.html (Tech companies founded in Uganda)
├── resources.html (Technical learning resources)
└── contact.html (Contact form)

Jordan's index.html Opening

<!DOCTYPE html>
<html>
  <head>
    <title>Uganda's Tech Innovators & Entrepreneurs</title>
  </head>
  <body>
    <header>
      <h1>Uganda's Tech Innovation Story</h1>
      <p>Created by: Jordan Mulungi Kaweesi | September 2026</p>
    </header>

Week 2 Daily Commits - Side by Side

Monday - Initial Pages

Joannah: git commit -m "Create home page - Women in tech focus"
Jordan:  git commit -m "Create home page - Tech innovators focus"

Tuesday - Multi-page Structure

Joannah: git commit -m "Add companies page highlighting female tech leaders"
Jordan:  git commit -m "Add companies page with tech startup founders"

Wednesday - Semantic HTML

Joannah: git commit -m "Restructure with semantic HTML, improve accessibility"
Jordan:  git commit -m "Implement semantic HTML structure throughout"

Thursday - Forms & Interactivity

Joannah: git commit -m "Add contact form for networking opportunities"
Jordan:  git commit -m "Add contact form for collaboration inquiries"

Friday - Polish & Launch

Joannah: git commit -m "Final polish, README docs, ready for GitHub share"
Jordan:  git commit -m "Add documentation and deploy to GitHub Pages"

WEEK 3: ASCII, HEX & Binary - Both Students

Joannah's Name Conversion

Full Breakdown

NAME: JOANNAH KUTEESA

Decimal ASCII:
J=74, O=79, A=65, N=78, N=78, A=65, H=72, (space)=32, 
K=75, U=85, T=84, E=69, E=69, S=83, A=65

Binary Representation:
01001010 01001111 01000001 01001110 01001110 01000001 01001000
00100000 01001011 01010101 01010100 01000101 01000101 01010011 01000001

Hexadecimal:
4A 4F 41 4E 4E 41 48 20 4B 55 54 45 45 53 41

Jordan's Name Conversion

Full Breakdown

NAME: JORDAN MULUNGI KAWEESI

Decimal ASCII:
J=74, O=79, R=82, D=68, A=65, N=78, (space)=32,
M=77, U=85, L=76, U=85, N=78, G=71, I=73, (space)=32,
K=75, A=65, W=87, E=69, E=69, S=83, I=73

Binary Representation:
01001010 01001111 01010010 01000100 01000001 01001110 00100000
01001101 01010101 01001100 01010101 01001110 01000111 01001001 00100000
01001011 01000001 01010111 01000101 01000101 01010011 01001001

Hexadecimal:
4A 4F 52 44 41 4E 20 4D 55 4C 55 4E 47 49 20 4B 41 57 45 45 53 49

Week 3 Study Guide Content

Joannah's Conversion Practice

Converting her name:

• Practice binary conversion: J (74) → 01001010
• Practice hex conversion: J (74) → 4A
• Understand ASCII representation of her full name
• Create conversion table for reference

Jordan's Conversion Practice

Converting his name:

• Practice binary conversion: J (74) → 01001010
• Practice hex conversion: J (74) → 4A
• Understand ASCII representation of his full three names
• Create reference material for longer name

Week 3 Commits - Equal Progress

Joannah

Mon: git commit -m "Create number system conversion guide with decimal, binary, hex"
Tue: git commit -m "Convert my name to ASCII, binary, and hexadecimal"
Wed: git commit -m "Create comprehensive name analysis in all bases"
Thu: git commit -m "Add binary math operations and practical applications"
Fri: git commit -m "Complete Week 3: Study guide and final documentation"

Jordan

Mon: git commit -m "Initialize number systems study - decimal, binary, hexadecimal"
Tue: git commit -m "Convert my full name to ASCII and number systems"
Wed: git commit -m "Create detailed analysis of name representation in multiple bases"
Thu: git commit -m "Document binary mathematics and real-world applications"
Fri: git commit -m "Finalize Week 3: Complete reference guide and documentation"

WEEK 4: Linux Command Line - Both Students Learning Together

Joannah's Linux Setup

# Joannah's configuration
sudo apt install build-essential git code python3 python3-pip python3-venv -y

# Her learning directory
mkdir -p ~/projects/week-4-linux

# Her first script (backup.sh)
chmod +x ~/projects/week-4-linux/backup.sh
./backup-project.sh

Jordan's Linux Setup

# Jordan's configuration
sudo apt install build-essential git code python3 python3-pip python3-venv -y

# His learning directory
mkdir -p ~/projects/week-4-linux

# His first script (system-check.sh)
chmod +x ~/projects/week-4-linux/system-check.sh
./system-check.sh

Linux Commands Mastery - Parallel Progress

Both Students Learning:

# Navigation (both practice)
pwd, cd, ls, ls -la

# File operations (both practice)
touch, mkdir, cp, mv, rm, cat, less, head, tail

# Text processing (both master)
grep, find, sed, awk, cut, sort, uniq

# Permissions (both understand binary connection!)
chmod 755, chmod 644, chmod 700
ls -l (understanding rwxrwxrwx)

# Scripting (both create scripts)
#!/bin/bash, variables, conditionals, loops

Week 4 Bash Scripts - Both Create

Joannah's Script Collection

backup-project.sh       - Automated project backup
system-check.sh         - Monitor system health  
git-daily-commit.sh     - Automate git commits
cleanup-logs.sh         - Clean old log files

Jordan's Script Collection

backup-important.sh     - Back up critical files
system-monitor.sh       - Real-time system check
auto-commit.sh          - Automated git workflow
organize-files.sh       - File organization script

GitHub Profiles at End of Week 4

Joannah's GitHub (github.com/joannah-kuteesa)

Repositories:
✓ week-1-git-practice
✓ week-2-html-portfolio
✓ week-3-number-systems
✓ week-4-linux-learning

Commits This Month: 20+
Profile Visitors: Growing audience

Jordan's GitHub (github.com/jordan-mulungi)

Repositories:
✓ week-1-git-practice
✓ week-2-html-portfolio
✓ week-3-number-systems
✓ week-4-linux-learning

Commits This Month: 20+
Profile Visitors: Growing audience

WEEKS 5-8: Linux Intensive - Both Students Together

Decision: Safe Ubuntu Learning Environment

Joannah's Choice

Decision: Use Ubuntu through WSL2
Reasoning: Learn Linux without changing the Windows installation
Timeline: Week 5 Day 1: Install WSL2 and Ubuntu
          Week 5 Day 2: Set up Git, Python, and project folders
Result: Safe Linux development environment

Jordan's Choice

Decision: Use Ubuntu through VirtualBox
Reasoning: Practise a complete Ubuntu environment without changing Windows
Timeline: Week 5 Day 1: Install VirtualBox and Ubuntu
          Week 5 Day 2: Set up Git, Python, and project folders
Result: Isolated Linux development environment

Both keep Windows installed and use Ubuntu safely for course practice.

Linux Kernel Learning - Shared Journey

Week 7: Kernel Understanding

Both Students Learn:

• Process management and scheduling
• Memory management (virtual memory, paging)
• Device drivers and hardware abstraction
• System calls and interrupts

# Both explore kernel
grep "void schedule()" /usr/src/linux/kernel/sched/core.c
# Both understand: This is just C code!

Week 8: Server Deployment - Competing Projects

Joannah's Deployed Application

Application: Women Tech Leaders Database
Server: DigitalOcean Ubuntu 24.04
URL: joannah-tech-leaders.example.com
Stack: Python Flask + PostgreSQL + Nginx
Deploy Date: End of Week 8
Status: Production ready

Jordan's Deployed Application

Application: Tech Innovators Community Platform
Server: DigitalOcean Ubuntu 24.04
URL: jordan-innovators.example.com
Stack: Python Django + PostgreSQL + Nginx
Deploy Date: End of Week 8
Status: Production ready

Both demonstrate full-stack capabilities.

MONTHS 4-6: Career Launch - Equal Opportunity

Joannah's Month 4 Income Goal

Freelance Status: Building a portfolio and seeking one suitable client
Monthly Revenue: May be UGX 0 while learning
Types of Work: Small web updates or supervised technical tasks
GitHub Portfolio: 3-4 documented projects
Professional Reputation: Growing

Jordan's Month 4 Income Goal

Freelance Status: Building a portfolio and seeking one suitable client
Monthly Revenue: May be UGX 0 while learning
Types of Work: Small backend exercises or supervised technical tasks
GitHub Portfolio: 3-4 documented projects
Professional Reputation: Growing

Month 6: Professional Status - Both Positioned

Joannah's Options

A) Apply for an internship or junior support role
B) Complete one or two small freelance projects responsibly
C) Tutor or provide basic technical support while learning
D) Continue portfolio work while applying for suitable opportunities

Jordan's Options

A) Apply for an internship or junior support role
B) Complete one or two small freelance projects responsibly
C) Tutor or provide basic technical support while learning
D) Continue portfolio work while applying for suitable opportunities

GitHub Profiles at Month 6

Joannah's Professional Portfolio

github.com/joannah-kuteesa

✓ 40+ commits this quarter
✓ 8-10 complete project repositories
✓ 2-3 deployed applications
✓ Professional README documentation
✓ Consistent contribution history
✓ Open source contributions

Profile Summary: Strong junior developer portfolio
Employer View: "Clearly talented, serious about craft"

Jordan's Professional Portfolio

github.com/jordan-mulungi

✓ 40+ commits this quarter
✓ 8-10 complete project repositories
✓ 2-3 deployed applications
✓ Professional README documentation
✓ Consistent contribution history
✓ Open source contributions

Profile Summary: Strong junior developer portfolio
Employer View: "Clearly talented, serious about craft"

Both equally positioned for professional opportunities.

Career Path Comparison at Month 6

Both Chose DevOps Path (Linux Mastery)

Joannah's Position

Title: Junior DevOps Engineer (or Freelance DevOps)
Skills: Linux, Docker, Server management, Deployment, Monitoring
Market Value: 50-80M/year (employee) or 30-40M/month (freelance)
Trajectory: Clear path to 100-150M+/year in 2-3 years

Jordan's Position

Title: Junior Infrastructure/DevOps Specialist (or own agency)
Skills: Linux kernel knowledge, Server administration, Automation, CI/CD
Market Value: 50-80M/year (employee) or 30-40M/month (freelance)
Trajectory: Clear path to 100-150M+/year in 2-3 years

One Year Later: Professional Developers

Joannah's Year 1 Achievement

Experience: 1 year professional development
Income: 60-80M/year (or 40-50M/month freelance)
Reputation: Known as solid DevOps engineer
Next Goal: Become lead engineer, technical mentor
Salary Trajectory: Clear path to senior (100M+/year)

Jordan's Year 1 Achievement

Experience: 1 year professional development
Income: 60-80M/year (or 40-50M/month freelance)
Reputation: Known as reliable infrastructure engineer
Next Goal: Lead projects, mentor junior developers
Salary Trajectory: Clear path to senior (100M+/year)

Key Insight: The Linux Mastery Difference

Both Students Made the Same Strategic Choice

Week 1-4: Build foundation (Git, HTML, basics)

• Both at same level
• Both learning fundamentals
• Both building portfolio

Week 5-8: Linux intensive

• Both commit fully to Ubuntu
• Both learn kernel
• Both deploy servers
• This is where they differentiate from other developers

Month 4-6: Career Launch

• Both can take 50M+/year jobs
• Both can freelance at premium rates
• Both rare in market (most developers skip Linux)

The Competitive Advantage

Most developers:

• Frontend only: 20-30M/year
• 1000+ competing for same jobs
• Limited advancement

Joannah & Jordan (Linux masters):

• DevOps/Backend: 50-100M+/year
• 50+ competing for same jobs
• Fast advancement to 100M+/year
• Options: Employment, freelance, consulting, own business

Message to Both Students

You are on the same journey. You're both:

• Learning at the same pace
• Building equal skills
• Creating parallel portfolios
• Positioned for the same premium careers

The only difference: Your passion, effort, and focus.

Your GitHub profiles will look equally professional. Your portfolios will be equally impressive. Your career trajectories will be equally successful.

The curriculum treats you equally. The market will value you equally.

Your success depends on you, not the curriculum.

Equal Representation for Joannah Kuteesa & Jordan Mulungi Kaweesi

One diploma. Two futures. Same opportunity.

From students to professionals in 6 months.

Career Paths After Diploma: From Graduate to Professional Developer

How Joannah & Jordan Will Earn Within 6 Months

Executive Summary

After completing this 12-week curriculum, both students will have a foundation to apply for internships, junior roles, and small freelance jobs. A realistic early goal is to earn around UGX 600,000 per month from entry-level work or small projects once they have a portfolio and reliable work habits.

This is a target, not a guarantee. Income depends on the quality of work, consistency, local opportunities, client trust, and continued learning. Linux and server skills can broaden future options, but they take sustained practice beyond this course.

PART 1: Career Paths for Diploma Computer Science Graduates

Path 1: Frontend Web Developer (Start: Month 2-3)

Skills Needed After 12 Weeks

• ✅ HTML, CSS, and basic Python (Weeks 1-8)
• ✅ Git & GitHub (Week 1)
• ✅ Responsive design
• ✅ Portfolio projects

Income Potential

• Month 2-3: Focus on learning and completing portfolio projects.
• Month 6: Aim for up to UGX 600,000 per month through a small job, internship stipend, tutoring, or modest freelance work.
• Year 1: Income can grow with verified skills, work experience, and dependable referrals; do not treat any amount as guaranteed.

How to Get Started

1. Complete Week 1-2 (Git + HTML)
2. Add Week 5-6 content (CSS + Python basics)
3. Build 3 portfolio projects
4. Post on GitHub, LinkedIn, Upwork
5. Take freelance projects (start at 500K UGX for small website)
6. Graduate to agencies after 2-3 successful projects

Realistic Timeline

• End of Week 4: Can build basic websites
• End of Week 8: Can take professional freelance projects
• Month 3: Begin seeking feedback, internships, and small supervised tasks.
• Month 6: Seek steady entry-level work with an initial goal of around UGX 600,000/month.

Real Uganda Examples

• Jumia Junior Frontend Dev: 25-35M/year
• Small agency (Kampala): 15-20M/year starting
• Freelance (Upwork): 5-15M/year (scalable)

Path 2: Backend/Full-Stack Developer (Start: Month 4-5)

Skills Needed After 12 Weeks

• ✅ Frontend (HTML, CSS)
• ✅ Git & GitHub
• ✅ Linux basics
• ✅ Command line (Week 4)
• Continue Weeks 9-12: Python, Flask, and databases

Income Potential

• Month 4-5: Build backend projects and practise deployments; paid work is possible but not assumed.
• Month 6: Target small, clearly scoped work that contributes toward an initial UGX 600,000/month.
• Year 1: Progress depends on experience, professional conduct, and a stronger portfolio.

How to Get Started

1. Complete Weeks 1-4 (Foundation)
2. Learn Week 5-8 (Linux intensive + servers)
3. Learn Python as the backend language
4. Build simple API projects
5. Deploy to Linux servers (not just localhost)
6. Get hired as full-stack dev (premium pay)

Why They're More Valuable

• Can build complete applications solo
• Can deploy and manage servers
• Can solve infrastructure problems
• Paid 40-50% more than frontend-only devs

Realistic Timeline

• End of Week 4: Foundation solid
• End of Week 8: Linux + server basics
• Month 4: Can build backend projects
• Month 6: Can pursue small full-stack tasks with guidance and build references.

Real Uganda Examples

• Pesalink Backend Dev: 50-70M/year
• Jumia Backend Dev: 60-80M/year
• Startup CTO (co-founder): 20-40M/year starting + equity

Path 3: DevOps/Linux Systems Engineer (Start: Month 3, Premium Path)

Skills Needed After 12 Weeks

• ✅ Linux fundamentals (Week 4)
• ✅ Linux intensive (Week 5-8) - CRITICAL
• ✅ Kernel basics
• ✅ Server administration
• ✅ Docker/containers (Week 9-10)
• ✅ Cloud platforms (AWS, Azure)

Income Potential

• Month 3-4: Focus on labs, documentation, and safe practice environments.
• Month 6: Look for internships, support roles, or small server-maintenance tasks; an initial income goal remains UGX 600,000/month.
• Year 1 and beyond: DevOps progression varies widely and requires production experience; research current roles before setting pay expectations.

Why This Path is Premium

• High barrier to entry = less competition
• Companies desperately need skilled DevOps
• Salary jumps faster with Linux mastery
• In-demand across all tech companies

How to Get Started

1. Weeks 1-4: Solid foundation
2. Weeks 5-8: Linux intensive using WSL2 or VirtualBox
3. Weeks 9-10: Docker, containers, services
4. Month 3: Can manage basic servers
5. Month 4: Can deploy applications properly
6. Month 5-6: Hire for sysadmin/DevOps role

Real Uganda Examples

• MTN Uganda DevOps: 60-80M/year
• Jumia Infrastructure: 70-90M/year
• Startup DevOps Lead: 40-60M/year + equity
• Freelance DevOps (consultancy): 50-150M/year

The Massive Advantage

If Joannah becomes a DevOps expert while other graduates become frontend devs:

• Frontend Dev Year 1: 25-30M UGX
• DevOps Expert Year 1: 50-80M UGX
• DevOps Expert Year 2: 100-150M UGX

The difference: Learning Linux deeply.

Path 4: Mobile Developer (Start: Month 5-6)

Skills Needed After 12 Weeks

• ✅ Foundation (Weeks 1-4)
• ✅ JavaScript (Week 6-7)
• Week 9: React Native or Flutter
• Week 10-12: Build complete app

Income Potential

• Month 5-6: Build and test an app; revenue is uncertain and should not be assumed.
• Month 6: A small paid task can contribute toward the UGX 600,000/month initial goal.
• Year 1 and beyond: App income depends on adoption, pricing, support, and marketing.

Real Uganda Examples

• Jumia Mobile Dev: 40-60M/year
• Indie app developer: 10-50M/year (highly variable)
• Startup mobile lead: 50-80M/year

Path 5: Freelance/Agency Owner (Start: Month 2, Scaling)

The Strategy

1. Month 2: Build samples and offer a small, clearly scoped service.
2. Month 3-4: Earn client trust through reliable delivery and revisions.
3. Month 5-6: Aim for recurring small work before considering expansion.
4. Month 7+: Consider an agency only after consistent demand and sustainable cash flow.

Income Potential

• Month 2-3: Paid work may not begin immediately; portfolio quality comes first.
• Month 6: Use UGX 600,000/month as an initial personal target, not agency revenue.
• Year 1: Track income, expenses, and repeat clients before setting growth targets.

How to Position Yourself

• Build portfolio on GitHub
• Post projects on LinkedIn
• Join Uganda Dev communities
• Network with other developers
• Take projects from local businesses
• Deliver exceptional work (this leads to referrals)

Why This Works in Uganda

• Small businesses need cheap websites
• Many don't know where to find developers
• Word of mouth is powerful
• Can start with zero investment

Path 6: Technical Trainer/Educator (Start: Month 4-5)

The Insight

You just learned all this. Others want to learn it too.

Income Potential

• Month 4-5: Develop a lesson plan and tutor only subjects you understand well.
• Month 6: Small tutoring or support work can contribute toward the UGX 600,000/month initial goal.
• Year 1 and beyond: Teaching income depends on student demand, results, and responsible pricing.

How to Get Started

1. Complete the curriculum
2. Document your learning
3. Offer tutoring to high school students (500K/month per student)
4. Lead bootcamp workshops at Kampala tech hub
5. Create online courses (Udemy, Teachable)
6. Build community of learners

Real Uganda Examples

• Bootcamp instructor: 5-10M/month
• Online course creator: 2-20M/month (passive income)
• Private tuition: 10-30M/month (10-15 students)

PART 2: The 6-Month Income Plan

Month 1-2: Preparation & Foundation

Weeks 1-4 Completed
Income: 0 (building foundation)
Effort: 100% focused on learning
Action: Build portfolio, create GitHub projects

Month 2-3: First Income

Start seeking small, suitable opportunities
Income Target: First paid task, if available
Effort: 80% learning, 20% earning
Projects: One small website, documentation task, or tutoring session
Rate: Agree a modest price that matches the scope and your experience
Platforms: Referrals, local businesses, student networks

Month 3-4: Growing Capacity

Linux intensive + Backend basics
Income Target: Build repeatable skills and references
Effort: 70% learning, 30% earning
Projects: Improve a portfolio site or complete one small supported project
Rate: Set each price from the work required, not a fixed expectation
Platforms: Repeat clients, referrals, student networks

KEY MILESTONE: Set up an Ubuntu learning environment
- Start learning kernel concepts safely
- First remote Linux server deployment
- Build a useful systems foundation

Month 4-5: Serious Projects

Backend/DevOps skills applied
Income Target: Work toward consistent small earnings
Effort: 60% learning, 40% earning
Projects: Full-stack practice application or supervised server setup
Rate: Quote only after agreeing on scope, support, and delivery date
Additional: Seek feedback and references from completed work

Month 5-6: Career Inflection Point

Entry-level job readiness
Income Target: Around 600K UGX/month
Effort: Continue learning alongside paid work
Options:
   A) Internship or junior support role
   B) One or two small freelance clients
   C) Tutoring or technical support alongside study
   D) Continue improving the portfolio while applying for suitable roles

Realistic 6-Month Income Timeline

Grounded Initial Target:

• Months 1-4: Focus on learning, projects, and job readiness; income may be UGX 0.
• Month 5: Seek one small paid opportunity when the work can be delivered responsibly.
• Month 6: Aim for around UGX 600,000/month from an internship, entry-level role, tutoring, or one or more small projects.
• Track actual income and expenses; do not make financial commitments based on projections.

Linux skills improve the kinds of work students may pursue, but they do not guarantee an income level after six months.

PART 3: Why Linux Mastery is the Game Changer

Current Reality (Without Linux)

A typical frontend developer:

• ❌ Can only work on their laptop
• ❌ Can't deploy their own code
• ❌ Depends on others for servers
• ❌ Limited to frontend jobs
• ❌ Salary stuck at 20-30M/year

Future Reality (With Linux Mastery)

A Linux-savvy developer: Companies desperately need:

• Frontend devs: 1000+ in Uganda
• Backend devs: 500+ needed
• Linux/DevOps engineers: 50+ DESPERATELY needed
• Supply vs demand: 1:10 ratio

You know why? Most developers skip Linux. It's not "cool" or "trendy." But it's the most valuable skill.

PART 4: The Intensive Month - Linux Mastery Plan

The Challenge: One Month of Focused Ubuntu Practice

Start: Week 5 (End of Month 1) End: Week 8 (End of Month 2) Goal: Build Linux confidence using Ubuntu in WSL2 or VirtualBox

Week 5: Ubuntu Setup & Basic Mastery

What They'll Do:

1. Install Ubuntu through WSL2 or VirtualBox
2. Keep Windows installed and available
3. Learn the Ubuntu interface and terminal
4. Master terminal commands
5. Set up development environment

Daily Commitment: 3-4 hours

By End of Week 5:

• Ubuntu learning environment is working
• Terminal is comfortable
• Basic file management from command line
• GitHub already set up on Ubuntu
• Can compile code on Linux

Week 6: Command Line Proficiency & Scripting

What They'll Learn:

• Advanced file operations
• Text processing (grep, sed, awk)
• User and file permissions
• Writing bash scripts
• Process management

Practicum: Write 10+ scripts that automate tasks

By End of Week 6:

• Can do 95% of work from terminal
• Scripts automate repetitive work
• Comfortable with complex commands
• Understanding file permissions deeply

Week 7: Linux Kernel Basics & System Administration

What They'll Learn:

• How Linux kernel works
• Process management at kernel level
• Memory management
• Device drivers basics
• System calls
• Boot process

Practicum:

• Compile custom kernel
• Monitor kernel operations
• Understand what's happening at low level

By End of Week 7:

• Understand what's happening "under the hood"
• Can troubleshoot system issues
• Know kernel fundamentals
• Ready for advanced topics

Week 8: Server Administration & Production Readiness

What They'll Learn:

• Ubuntu server setup
• SSH and remote access
• Web servers (Nginx, Apache)
• Package management
• System monitoring
• Log analysis
• Basic security (firewall, users)

Practicum:

• Set up Linux server (AWS, DigitalOcean, or local)
• Deploy own application
• Monitor production system
• Handle common issues

By End of Week 8: This is DevOps work. It develops practical capability that can lead to future opportunities through continued experience.

PART 5: Month-by-Month Detailed Curriculum

Weeks 1-4: Foundation (Already Completed)

• Git & GitHub ✅
• HTML & CSS ✅
• Binary/ASCII ✅
• Linux basics ✅

Weeks 5-8: Linux Intensive (New)

Week 5: Ubuntu Installation & Transition

Monday - Ubuntu Learning Environment Planning

Goal: Set up a safe learning environment

Tasks:
1. Choose WSL2 or VirtualBox
2. Check available disk space and memory
3. Install Ubuntu 24.04 LTS in the chosen environment
4. Update the Ubuntu packages
5. Record the setup steps in your notes

Tuesday - Ubuntu Environment Setup

Goal: Use Ubuntu without changing the Windows installation

Use WSL2 or VirtualBox. Do not dual boot or replace Windows.

Setup steps:
1. Create the Ubuntu user account
2. Update the system with `sudo apt update && sudo apt upgrade`
3. Install Git, Python, and build tools
4. Create the course project directory
5. Test `pwd`, `ls`, and `python3 --version`

Wednesday - Ubuntu Setup for Development

Goal: Make Ubuntu development-ready

Install essentials:
sudo apt update
sudo apt install build-essential git curl wget

Install code editor:
sudo apt install code

Install Python:
sudo apt install python3 python3-pip python3-venv

Test everything works

Thursday - Terminal Mastery Begins

Goal: Become comfortable with terminal

Learn commands:
- ls, cd, pwd, mkdir, touch, rm
- cat, nano, vim
- grep, find, locate
- chmod, chown
- apt install/remove
- man (help command)

Practice: Do everything from terminal (no GUI)
This feels slow at first but builds muscle memory

Friday - First Git Commit from Ubuntu

Goal: Prove you can develop on Ubuntu

Create project on Ubuntu:
mkdir week-5-ubuntu-journey
cd week-5-ubuntu-journey
git init

Write documentation:
Create ubuntu-setup.md explaining your Ubuntu setup
Include: version, packages installed, preferences

Commit:
git add ubuntu-setup.md
git commit -m "First commit from Ubuntu Linux - OS transition complete"
git push

Reflection: How does development feel different?

End of Week 5 Milestone:

• ✅ Ubuntu installed and primary OS
• ✅ Development environment working
• ✅ Git working on Ubuntu
• ✅ Terminal becoming comfortable
• ✅ Ready for deeper Linux learning

Week 6: Command Line Mastery & Scripting

Monday - Advanced File Operations

Goal: Master file system from command line

Learn commands:
- find: Search files by name, size, date, permissions
- locate: Fast file search using index
- xargs: Process file lists
- sort, uniq: Organize text
- wc, du: Count lines and disk space

Hands-on practice:
# Find all .txt files modified in last 7 days
find . -name "*.txt" -mtime -7

# Find all Python files larger than 1MB
find . -name "*.py" -size +1M

# Count lines in all code files
find . -name "*.py" | xargs wc -l

Tuesday - Text Processing Mastery

Goal: Process text files like a pro

Learn commands:
- grep: Find patterns in text
- sed: Stream editor for transformations
- awk: Text processing and reporting
- cut: Extract columns
- tr: Translate characters

Example: Process Ubuntu system log
grep "error" /var/log/syslog | wc -l
# How many errors in system log?

grep "sudo" /var/log/auth.log | awk '{print $1}' | sort | uniq -c
# Count sudo commands by date

Wednesday - Writing Your First Bash Script

Goal: Automate tasks with bash scripts

Create file: backup-project.sh

#!/bin/bash
# Automate project backup

PROJECT_DIR="/home/joannah/projects"
BACKUP_DIR="/home/joannah/backups"
DATE=$(date +%Y-%m-%d)

# Create backup
cp -r "$PROJECT_DIR" "$BACKUP_DIR/backup-$DATE"
echo "Project backed up to $BACKUP_DIR/backup-$DATE"

# Make executable
chmod +x backup-project.sh

# Run script
./backup-project.sh

Result: Automation saves time!

Thursday - Understanding File Permissions (Binary Review!)

Goal: Master file permissions using binary knowledge

Permissions structure: rwxrwxrwx (owner, group, others)
In binary: 111 111 111 (all permissions)
In octal: 777

Examples:
755 = 111 101 101 (owner: all, group: read+execute, others: read+execute)
644 = 110 100 100 (owner: read+write, group: read, others: read)
700 = 111 000 000 (owner: all, others: nothing - private!)

Change permissions:
chmod 755 script.sh          # Make executable
chmod 600 private-file.txt   # Only owner can read/write
chmod -R 755 directory/      # Change directory and contents

Understanding ownership:
chown user:group filename    # Change owner
sudo chown root:root /etc/config

This is where Week 3 (binary) becomes practical!

Friday - Scripting Your Workflow

Goal: Create useful scripts for your work

Build these scripts:

1. git-daily-backup.sh
   # Commits changes with date stamp
   git add -A
   git commit -m "Daily backup: $(date +%Y-%m-%d)"
   git push

2. system-update.sh
   # Update system and installed packages
   sudo apt update
   sudo apt upgrade -y
   sudo apt autoremove

3. dev-setup.sh
   # Initialize new project with structure
   mkdir project/{src,tests,docs}
   cd project
   git init
   echo "# New Project" > README.md

Save these in ~/scripts/ and add to PATH
Then run from anywhere!

End of Week 6 Milestone:

• ✅ Comfortable using terminal for all file operations
• ✅ Can write useful bash scripts
• ✅ Understand file permissions deeply
• ✅ Automate repetitive tasks
• ✅ Productivity increased 5x

Week 7: Linux Kernel Basics & System Understanding

Monday - How Linux Kernel Works

Goal: Understand what's running "under the hood"

The Linux Kernel:
- Core of operating system
- Manages hardware (CPU, memory, disk, network)
- Manages processes (programs running)
- Manages files and permissions
- Handles interrupts and system calls

Three main parts:
1. Process management: Schedules CPU time for programs
2. Memory management: Allocates RAM, manages virtual memory
3. Device management: Talks to hardware (disk, USB, network)

You use kernel through system calls:
open()      - Open a file
read()      - Read data
write()     - Write data
fork()      - Create new process
exit()      - Terminate process

Tuesday - Processes and System Calls

Goal: See the kernel in action

View running processes:
ps aux           # List all processes
top              # Real-time process monitor
ps aux | grep python  # Find specific process

Understanding processes:
- Each program is a process
- Each process has ID (PID)
- Kernel allocates CPU time
- Processes can create child processes

Monitor system:
free -h          # Memory usage
df -h            # Disk space
uptime           # System uptime and load
iostat           # I/O statistics

Wednesday - Compiling Kernel (Advanced)

Goal: See that Linux is just code you can modify

Note: This is advanced. Professional activity.

Basic steps (don't do this on production!):
1. Download kernel source
2. Read existing configuration
3. Modify configuration (optional)
4. Compile: make (takes 10-20 minutes)
5. Install: make install
6. Reboot

For learning: Just read kernel source code on GitHub
https://github.com/torvalds/linux

This shows you: Kernel is just C code!
It's not magic - it's just very well-written code.

Read some famous kernel functions:
- memcpy() - Memory copy (performance critical)
- schedule() - CPU scheduling
- do_fork() - Create new process

Thursday - System Logging and Monitoring

Goal: Understand what system is doing

View system logs:
journalctl                    # View system journal
journalctl -f                 # Follow logs (like tail -f)
journalctl -u nginx           # View nginx service logs
less /var/log/syslog          # View system log

Monitor in real-time:
htop                          # Better top
iotop                         # I/O monitoring
nethogs                       # Network monitoring per process
dstat                         # All-in-one system stats

Common troubleshooting:
# Out of disk space?
du -sh /home/*

# High CPU usage?
top

# Network issue?
ping 8.8.8.8
traceroute example.com
netstat -an | grep ESTABLISHED

Friday - Kernel Concepts Deep Dive

Goal: Understand advanced kernel topics

Scheduling:
- Kernel decides which process gets CPU time
- Uses priority queues
- Preemptive: Can interrupt running process
- This is why multitasking works

Memory:
- Virtual memory: Each process thinks it has whole RAM
- MMU (Memory Management Unit): Kernel's helper
- Paging: Swap between RAM and disk
- This is why you can run many programs at once

File system:
- Everything is a file (/dev/sda is disk file!)
- Inodes: Index nodes store file metadata
- Directories: Special files that list other files
- This abstraction makes Linux powerful

End of Week 7 Milestone:

• ✅ Understand Linux kernel architecture
• ✅ Can monitor system performance
• ✅ Know what's happening at low level
• ✅ Can troubleshoot system issues
• ✅ Ready to work with servers

Week 8: Server Administration & Production Deployment

Monday - Server Setup from Scratch

Goal: Set up production-ready Linux server

Choose platform:
- AWS (Amazon Web Services) - Industry standard
- DigitalOcean - Cheaper, easier for beginners
- Linode - Good balance
- Or: Local virtual machine for practice

Create server:
1. Sign up for DigitalOcean (get $200 free credits!)
2. Create Ubuntu 24.04 server (droplet)
3. SSH into server from your Ubuntu machine

SSH access:
ssh root@your.server.ip
# You now have shell on remote computer!

Tuesday - Server Security

Goal: Harden server against attacks

First steps:
# Update system
apt update && apt upgrade -y

# Set up firewall
ufw enable
ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp    # SSH
ufw allow 80/tcp    # HTTP
ufw allow 443/tcp   # HTTPS

# Create regular user (don't use root!)
adduser developer
usermod -aG sudo developer

# Disable root login
# Edit /etc/ssh/sshd_config
# Set: PermitRootLogin no
systemctl restart ssh

# SSH key authentication (no password)
# Generate key on your machine:
ssh-keygen -t ed25519
# Copy to server:
ssh-copy-id developer@server.ip
# Now login without password!

Wednesday - Install Web Server and Deploy Application

Goal: Deploy your application on Linux server

Install Nginx (web server):
sudo apt install nginx
sudo systemctl start nginx
sudo systemctl enable nginx

# Visit your.server.ip in browser - you'll see Nginx welcome page!

Deploy simple application:
cd /var/www/html
sudo chown developer:developer .

# Create a Python environment and install Flask:
python3 -m venv .venv
source .venv/bin/activate
pip install flask gunicorn
# Create app.py with a Flask application

# Run your app:
flask --app app run --host 127.0.0.1 --port 8000

# Configure Nginx to forward requests to your app
# Edit /etc/nginx/sites-available/default
# Add proxy_pass http://127.0.0.1:8000;

# Restart Nginx:
sudo systemctl restart nginx

Result: Your application is live on the internet!
Visit your.server.ip and see your code running.

Thursday - Monitoring and Maintenance

Goal: Keep server healthy and running

Monitor server:
# Check resources
free -h              # Memory
df -h /              # Disk space
top                  # Running processes

# Check services
systemctl status nginx
systemctl status ssh

# View logs
tail -f /var/log/nginx/access.log
tail -f /var/log/nginx/error.log

Automate updates:
# Install unattended-upgrades
sudo apt install unattended-upgrades
# Automatically patches security updates

Backup strategy:
# Backup important data regularly
tar -czf backup-$(date +%Y-%m-%d).tar.gz /home/developer/

This is DevOps work. This is what pays 50-100M+/year.

Friday - Advanced: Docker and Containerization

Goal: Understand modern deployment (containers)

What is Docker?
- Package your application with its dependencies
- Run same application on any server
- Think of it like: Application + all its libraries in a box

Install Docker:
sudo apt install docker.io
sudo usermod -aG docker developer

Create Dockerfile for your app:
FROM python:3.12-slim
WORKDIR /app
COPY . .
RUN pip install --no-cache-dir flask gunicorn
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]

Build and run:
docker build -t my-app .
docker run -p 8000:8000 my-app

Deploy with Docker:
# Now your app runs same on your laptop, staging, production
# This is the modern way to deploy applications

Note: This is Week 9 material (DevOps focus)
You'll be very advanced if you reach this.

End of Week 8 Milestone:

PART 6: Career Positioning After Linux Mastery

The Market Impact

Without Linux mastery:

• Junior Frontend Dev: 20-30M/year
• Takes 2-3 years to become senior
• Limited career advancement

With Linux mastery (after 4 months):

• Junior DevOps/Backend: 50-80M/year
• Can be consulting DevOps by month 6-8
• Fast path to senior roles
• Can start own consulting business

How to Demonstrate This Mastery

Build Portfolio Projects

Project 1: Deployed Web Application

• Git repository on GitHub
• Application running on Linux server
• Documented deployment process
• Shows: Full-stack, server skills, professionalism

Project 2: Automation Scripts

• Collection of useful bash scripts
• Well-documented code
• Solves real problems
• Shows: Linux expertise, problem-solving

Project 3: System Administration

• Managed Linux server (document it)
• Configured web server
• Set up security/monitoring
• Shows: DevOps capability, infrastructure knowledge

Project 4: Contributing to Linux Projects

• Fork Linux project on GitHub
• Make improvement (documentation, code)
• Submit pull request
• Shows: Open source participation, deep knowledge

LinkedIn Profile Update

After Week 8, profile should show:

Headline: 
"Full-Stack Developer | Linux & DevOps | Ubuntu Specialist"

Skills:
- Linux/Ubuntu administration
- Bash scripting and automation
- Server deployment and configuration
- Web servers (Nginx, Apache)
- Process monitoring and troubleshooting
- SSH, networking, security
- Docker and containerization
- Git and GitHub
- [Programming language]

Description:
"Diploma computer science graduate with deep Linux expertise. 
Proficient in Ubuntu server administration, deployment, and DevOps. 
Comfortable managing production systems. Available for:
- Full-time DevOps/Backend roles
- Consulting and freelance projects
- System administration contracts"

GitHub Profile Showing Growth

When employers review github.com/joannah-kuteesa:

Repositories:
1. week-1-git-practice (Week 1)
2. week-2-html-portfolio (Week 2)
3. ubuntu-setup-guide (Week 5) ← Different! Shows Linux focus
4. bash-automation-scripts (Week 6) ← Advanced!
5. deployed-web-app (Week 8) ← Live on server!
6. linux-sysadmin-tools (Week 8) ← Specialized!

Commits show progression:
- Weeks 1-4: Learning fundamentals
- Weeks 5-8: Deep Linux dive
- Consistent daily commits
- Clear commit messages
- Professional documentation

Salary Negotiation After Linux Mastery

When you apply for jobs, you can now negotiate:

Before Linux mastery: "I can build websites, offer me 20M/year"

After Linux mastery: "I can build complete applications, deploy to production servers, manage infrastructure, and troubleshoot system issues. I should receive 50-80M/year minimum, or we can discuss equity/commission"

Companies WILL pay this because:

• Skilled Linux developers are rare
• They've been burned by deployments gone wrong
• You can literally save their business
• You can manage multiple servers alone

Next Steps After Month 8

Option A: Full-Time Employee

• Apply to Jumia, Pesalink, MTN, startups
• Interview: "Can you set up a server?" ✅ YES
• Interview: "Can you deploy our app?" ✅ YES
• Interview: "Can you troubleshoot production issues?" ✅ YES
• Hire: 60-80M/year

Option B: Freelance DevOps

• Market yourself: "Linux server setup, deployment, management"
• Rate: 5-15M per project
• Build 3-5 long-term clients
• Earn: 30-50M/month from consistent work

Option C: Consulting

• "I'll set up your infrastructure properly"
• Typical project: 10-50M per client
• Build reputation through successful projects
• Earn: 50-150M/month (highly variable)

Option D: Start Tech Company/Agency

• Your skills are the business asset
• Hire other developers (you manage)
• You do DevOps, team does development
• Scale from 0 to multiple clients
• Potential: 100M+ per year

PART 7: Real Timeline Example: Joannah's Path

PART 7: Shared Timeline Example: Joannah & Jordan

Month 1: Foundation Learning

Timeline: Weeks 1-4
Income: 0 UGX
Focus: Learn Git, HTML, basics
By end: Solid programming foundation

Month 2: Transition + First Income

Timeline: Weeks 5-6
Income: 1-2M UGX
Activities:
- Continue practising Ubuntu through WSL2 or VirtualBox
- Build portfolio website (GitHub)
- Take first freelance projects
- Earn from simple website projects
Rate: 500K-1M per project
Clients: Facebook groups, Upwork, friends

Month 3: Linux Intensive

Income: May still be UGX 0 while learning Timeline: Weeks 7-8

• Bigger freelance projects Rate: 1-2M per project Client: Repeat clients, small businesses

## Month 4: Server Mastery
Income: Learning remains the priority; paid work is optional
Timeline: Weeks 9-10
Rate: 3-5M per project
Clients: Growing reputation for quality

Month 5: Career Inflection

Income: Build toward reliable small earnings Timeline: Weeks 11-12 Decision: Employee or independent?

## Month 6+: Professional
Income: Progress toward an initial target of around UGX 600,000/month
Timeline: After Week 12
Joannah's Revenue Milestones:
- Month 1: 0
- Month 2: 2M total
- Month 3: 5M total (3M this month)
- Month 4: 13M total (8M this month)
- Month 5: 28M total (15M this month)
- Month 6: 50M+ monthly income

By Month 6:

---

## Summary: Why This Works

1. **Foundation is Strong** - Weeks 1-4 give solid basics
2. **Linux is the Differentiator** - Weeks 5-8 make you rare
3. **Projects Show Capability** - Deploy real apps
4. **Market Need Exists** - Companies desperately hire DevOps
5. **Salary Jumps** - Linux skills command 2-3x premium
6. **Multiple Paths** - Employee, freelance, consulting, business

**The key insight:** While most developers skip deep Linux, you'll master it. This single difference determines your career trajectory.

---

*Career Roadmap for Joannah Kuteesa & Jordan Mulungi Kaweesi*
*From Diploma Students to Professional Developers in 6 Months*

**Created with deep understanding of Uganda's tech market reality**