How to Build a Portfolio Alongside the Open Source CS Curriculum: A Project-Based Roadmap

Treat every course in the ForrestKnight/open-source-cs curriculum as a project milestone by creating corresponding GitHub repositories that demonstrate practical applications of the theoretical concepts you learn.

The ForrestKnight/open-source-cs repository organizes free computer science education into seven progressive categories, from introductory programming to advanced machine learning. While completing the courses listed in README.md builds theoretical knowledge, hiring managers require evidence of practical application. By treating each curriculum block as a project milestone, you create a hierarchical portfolio that demonstrates both breadth across CS domains and depth in implementation skills.

Map Curriculum Sections to Portfolio Projects

Rather than maintaining a single monolithic repository, architect a portfolio directory structure that mirrors the curriculum organization found in the source repository. Create subdirectories for Basics, Programming, Math, Systems, Theory, Applications, and Unix, with each folder containing a standalone project that extends the specific course material referenced at the corresponding line in README.md.

Computer Science Basics

The Introduction to Computer Science course (referenced at line 9 of the curriculum) typically covers C programming and computer science fundamentals. Re-implement the canonical "Hello, World" program, then extend it into a simple HTTP web server using socket programming to demonstrate network layer understanding. Host this in portfolio/basics/cs50x/ with a README.md explaining the socket implementation and memory management concepts learned.

Programming and Data Structures

For Java Programming: Solving Problems with Software (line 15), build a command-line utility that parses CSV files and outputs structured JSON. When you reach Data Structures and Performance (line 18), implement a self-balancing AVL tree from scratch and benchmark its insertion and lookup times against Java's native TreeMap. Store these in portfolio/programming/java-fundamentals/ and portfolio/programming/data-structures/ respectively, including Javadoc-generated documentation and performance graphs.

Mathematical Foundations

Calculus 1A: Differentiation (line 29) provides the mathematical basis for optimization algorithms. Create a Jupyter notebook that visualizes derivative approximations using NumPy and SciPy, implementing numerical differentiation methods and plotting convergence rates. This demonstrates your ability to translate abstract calculus concepts into computational tools essential for machine learning.

Systems Architecture

The Nand to Tetris course (line 41) teaches computer architecture from first principles. Build a functional 8-bit CPU emulator in Python that can process a custom instruction set, then document the architecture with circuit diagrams and a "run Tetris" demonstration. Place this in portfolio/systems/nand2tetris/ to show low-level systems programming capability.

Algorithms and Theory

For Algorithms, Part I from Princeton (line 51), develop a library of classic algorithms including merge sort, quick-select, and union-find. Include comprehensive unit tests using JUnit or pytest, and generate performance plots that visualize time complexity across different input sizes. This showcases your theoretical analysis skills alongside clean code practices.

Practical Applications

Machine Learning from Stanford (line 60) culminates in applied AI projects. Train an image classifier on the MNIST dataset using TensorFlow or Keras, achieve baseline accuracy above 95%, and deploy the model to Hugging Face Spaces or a similar cloud platform. Store the training scripts in portfolio/applications/ml-project/ with a requirements.txt and inference API documentation.

Unix Proficiency

The Linux Command Line Basics course (line 68) covers shell scripting and system administration. Write a Bash automation script that builds your static portfolio site using Jekyll, commits the generated _site/ content to the gh-pages branch, and handles error checking with set -e. This demonstrates DevOps fundamentals while solving the practical problem of portfolio deployment.

Document the Technical Decision-Making Process

For each project subdirectory, create a README.md that captures four critical elements: the problem statement linking back to course concepts, an architecture diagram showing component flow, implementation details with annotated code snippets, and a results section discussing performance benchmarks or lessons learned. This narrative structure allows recruiters to trace your learning journey from the curriculum entry to the shipped artifact.

Showcase Projects on GitHub

Configure each repository with completion badges indicating course status and cross-link to the specific curriculum entry in ForrestKnight/open-source-cs for traceability. Enable GitHub Pages on each project repository to automatically render your documentation as a live site, then aggregate all projects in a master portfolio/README.md that serves as your curriculum vitae. Include a table of contents that maps each repository to its corresponding academic section.

Implementation Examples

The following code snippets demonstrate the depth of implementation expected for portfolio projects extending the curriculum.

Java CSV Processing Utility

This example extends the Java Programming course by building a practical data transformation tool:

// src/main/java/com/portfolio/csv2json/Converter.java
package com.portfolio.csv2json;

import com.opencsv.CSVReader;
import com.google.gson.Gson;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.List;

public class Converter {
    public static void main(String[] args) throws Exception {
        try (CSVReader reader = new CSVReader(new FileReader(args[0]))) {
            List<String[]> rows = reader.readAll();
            String json = new Gson().toJson(rows);
            try (FileWriter writer = new FileWriter(args[1])) {
                writer.write(json);
            }
        }
    }
}

Python CPU Emulator

This implementation applies Systems knowledge from Nand2Tetris:

# emulator/cpu.py

class CPU:
    def __init__(self):
        self.registers = [0] * 8
        self.pc = 0
        self.memory = [0] * 256

    def step(self):
        instr = self.memory[self.pc]
        opcode = (instr & 0b11110000) >> 4
        operand = instr & 0b00001111
        if opcode == 0x1:      # LOAD immediate

            self.registers[0] = operand
        # ... other opcodes ...

        self.pc = (self.pc + 1) % len(self.memory)

Bash Deployment Automation

This script demonstrates Unix course proficiency by automating portfolio updates:

#!/usr/bin/env bash

# deploy.sh – Build and publish portfolio to GitHub Pages

set -e
jekyll build   # Generate _site/ folder

git checkout gh-pages
rm -rf *
cp -r _site/* .
git add -A
git commit -m "Update portfolio site $(date +%F)"
git push origin gh-pages
git checkout main

Summary

• Map each curriculum section to a standalone GitHub repository mirroring the structure in ForrestKnight/open-source-cs.
• Reference specific course lines (e.g., L9 for CS50x, L41 for Nand2Tetris) to create traceable links between academic content and your implementations.
• Document your architectural decisions in each project README using problem statements, diagrams, and performance results.
• Automate deployment using shell scripts and GitHub Pages to maintain a professional, always-current portfolio presence.

Frequently Asked Questions

How many portfolio projects should I build per curriculum section?

Focus on one substantial project per major course that includes source code, documentation, and a live demo. For introductory sections like Basics and Unix, a single well-documented project suffices. For intensive sections like Programming and Systems, consider building two projects that demonstrate different aspects of the coursework, such as one focusing on data structures and another on algorithms.

Should I create separate repositories for each project or use a monorepo?

Create separate repositories for each major project to allow independent versioning, issue tracking, and GitHub Pages deployment. Use a central portfolio repository as an index that links to individual project repos using GitHub's submodule feature or a simple reference table in the README. This modular approach allows recruiters to examine specific skills in isolation while maintaining a cohesive narrative.

How do I portfolio courses without obvious coding assignments, like Mathematics?

Translate theoretical concepts into computational implementations. For calculus or linear algebra courses, build visualization tools or Jupyter notebooks that animate mathematical principles using Python's Matplotlib or Manim. These demonstrate both your understanding of the mathematics and your ability to communicate complex ideas through software—an essential skill for technical roles in data science and machine learning.

Can I combine multiple related courses into a single large project?

Yes, capstone projects that integrate multiple curriculum sections signal advanced capability to employers. For example, combine the Algorithms course (L51) with the Machine Learning course (L60) by implementing custom optimization algorithms from scratch rather than using library functions. Document which specific components relate to each course in your README to maintain clear traceability to the curriculum.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}