missing-semester/missing-semester
Missing Semester
The Missing Semester is a free, open-source educational curriculum designed to bridge the gap between theoretical computer science and the practical tooling every software engineer needs. Organized as a structured course, it covers Unix shell mastery, version control with Git, software debugging and profiling, system administration fundamentals, and computer security practices — the skills often left out of traditional degree programs. The project is maintained as a collaborative set of lecture notes, exercises, and guides that function as both a professional development tools course and a Unix and Git mastery resource.
What distinguishes The Missing Semester is its unusually broad scope, extending from core command-line and shell scripting to contemporary workflows like AI-assisted code generation, containerization with Docker and Docker Compose, and integration with external services via MCP and web APIs. The curriculum also addresses data wrangling and text processing, desktop environment customisation, advanced web browsing techniques, and a full security module covering encryption, authentication, and network privacy. This range means a single course can take a learner from basic filesystem navigation through to structured logging, performance profiling, and automated software testing.
The course is delivered through a lecture-video-driven format with accompanying Markdown notes that are rendered into a static website. Content is maintained year by year using separate Git branches, and community-translated versions in dozens of languages are linked directly from the site. Anyone can contribute improvements via pull requests, making the resource itself a living example of the open-source collaboration practices it teaches.
Features
- Video Lectures - Delivers structured lessons primarily through recorded video lectures paired with text notes.
- Shell Mastery Fundamentals - Mastering the Unix shell, including scripting, pipelines, and command-line tools to automate tasks efficiently.
- Benchmarking and Profiling - Teaches performance benchmarking and profiling techniques for measuring CPU time, memory, and I/O.
- Fundamentals - Diagnosing software issues using debuggers, logging, system call tracing, and performance profilers.
- Shell Dotfile Configurations - The Missing Semester covers editing configuration files, setting PATH, creating aliases, and using enhanced history search.
- Git and Version Control - Managing code history and collaborating with Git through branching, merging, and effective commit workflows.
- Command Line Argument Handlers - Teaches accessing positional parameters, flags, and globbing patterns to control program behavior.
- Filesystem Navigation - Covers moving between directories using cd and pwd, resolving absolute and relative paths.
- Git Workflow Utilities - Teaches customizing Git workflows with configuration, ignore files, and worktrees.
- History Rewriting - Teaches rewriting Git history through rebasing, reverting, and stashing.
- Git History Navigation - Teaches inspecting Git history with commit logs, blame, and search.
- Pipeline Compositions - The Missing Semester covers spawning concurrent processes and connecting output of one to input of another via stdin, stdout, and stderr.
- Branch Merging Strategies - Teaches branch merging strategies and conflict resolution for collaborative development.
- Staging Areas - Teaches using the Git staging area to selectively stage changes for commits.
- Practical Computing Courses - A structured course that teaches shell mastery, version control, debugging, and other essential tools for professional software engineers.
- Technical Tooling Courses - A primer covering the command-line, version control, debugging, security, and automation workflows needed in modern software development.
- Version Control Fundamentals - Teaches fundamental version control concepts using snapshots for collaboration and rollback.
- Unix and Git Mastery Courses - A focused curriculum on Unix shell, Git workflows, system administration, and data processing techniques for engineering environments.
- Shells & Scripting - The Missing Semester teaches using bash conditionals, loops, command substitution, and exit status checks to build reusable scripts.
- Shell Program Execution - Teaches running executables by name, passing arguments, and consulting man pages for help.
- Shell Command Substitutions - Covers assigning, exporting, and unsetting shell variables and using command substitution.
- Remote Command Execution and File Transfers - The Missing Semester teaches running commands non-interactively, transferring files, and authenticating with key pairs via SSH.
- Security Best Practices - Protecting data and systems with encryption, authentication, SSH key management, and secure communication.
- Key Pair Authentication Methods - The Missing Semester teaches logging into remote servers by proving possession of a private key through challenge-response.
- Educational Curricula - A collaboratively maintained set of lecture notes, exercises, and guides for bridging theoretical computer science and practical tooling.
- Systemd Unit Control - Teaches controlling systemd services using systemctl and journalctl.
- Command Line System Administration - Configuring and managing Unix systems, services, networks, and resources from the command line.
- System Call Tracing - Teaches system call tracing for diagnosing low-level application interactions.
- System Activity Monitoring - Teaches real-time system activity monitoring for processes, resource usage, and network connections.
- System Logging - Teaches inspecting system and application logs with tools like journalctl and dmesg.
- System Service Managers - Teaches managing system services, daemons, and basic system administration tasks.
- Agentic Context Management - Teaches clearing, rewinding, or compacting the agent's context window to maintain focus and performance.
- AI Code Reviewers - Teaches asking an agent to examine uncommitted changes or pull requests for correctness, security, and style.
- Error Diagnosis Assistants - Teaches feeding error messages and crash dumps to a language model for explanations and fixes.
- Shell Command Generation - Teaches generating shell commands from natural language descriptions using AI models.
- Browser Automation Tools - Teaches browser automation scripting with WebDriver to simulate user interactions.
- AI Coding Assistants - Covers prompting an agent to write, refactor, or fix code with autonomous iteration over tests and linters.
- Automatic Code Formatters - Covers automatically reformatting code to enforce consistent style, handling spacing, quotes, and imports.
- Natural Language Codebase Exploration - Teaches asking an agent questions about project structure, dependencies, and logic for accelerated onboarding and debugging.
- Pre-Commit Validations - Covers automatically running checks on staged files before each commit to prevent issues from entering the repository.
- Educational Code Reviews - Teaches providing human review that distinguishes blocking issues from suggestions and focuses on code.
- Exit Status Signaling - The Missing Semester covers checking exit status with $? and combining them with boolean operators for conditional execution.
- Breakpoint Debugging - Teaches halting execution at breakpoints, inspecting variable state, and stepping through code.
- Agent Session Parallelization - Teaches launching multiple agent copies simultaneously using git worktrees to prevent interference.
- Project Agent Configuration - Covers providing behavioral instructions and documentation references that load automatically when an agent starts on the project.
- Project Task Execution - Teaches defining aliases for common project-specific commands to run tasks with a short invocation.
- Deterministic Dependency Locking - Teaches pinning exact versions of all dependencies in a lock file for identical build environments.
- Terminal Session Persisters - The Missing Semester teaches keeping terminal sessions alive after disconnecting and reattaching to them later.
- Containerized Application Runtimes - The Missing Semester teaches packaging an application with its full filesystem into a lightweight container image using Docker.
- Continuous Integration Checks - Covers automatically executing formatters, linters, and tests on pushed code or pull requests to catch errors early.
- Virtual Environment Dependency Management - Teaches installing and isolating package dependencies per project using tools like pip or uv.
- Multi-Container Orchestration - The Missing Semester teaches defining and managing interconnected services with shared networking using Docker Compose.
- Modal Editing Fundamentals - The Missing Semester covers switching between Vim modes and composing keystrokes for efficient text manipulation.
- Process Signal Management - The Missing Semester teaches sending signals like SIGINT and SIGTERM to pause, resume, or terminate processes and manage background jobs.
- File Search by Attribute - The Missing Semester teaches using find to search for files by name, type, size, or age, with optional command execution on matches.
- Memory and Concurrency Error Detection - Teaches instrumenting code to catch buffer overflows, data races, and undefined behavior.
- Password Management - The Missing Semester covers using a password manager and two-factor authentication to secure accounts.
- Contribution Workflows - Teaches submitting bug reports and pull requests that respect maintainer time with clear rationale.
- Regular Expression-Based Parsing - The Missing Semester teaches using regex syntax to search, validate, and parse strings across command-line tools, IDEs, and programming languages.
- Structured Logging - Teaches adding structured logging statements with severity levels for later diagnostic analysis.
- Automated Software Testing - Teaches creating unit, integration, and end-to-end tests to verify correctness, including regression and property-based tests.
- Static Code Analysis - Teaches running static analysis to detect bugs, style violations, and risky patterns with configurable rules and auto-fixes.
- Keyboard Navigation Shortcuts - Teaches browser keyboard shortcuts for efficient tab and window navigation.
- User Stylesheets - Teaches injecting custom stylesheets to permanently alter web page appearance.
- Script Injections - Teaches injecting user scripts to modify and extend web page functionality.
- Command-Line HTTP Requests - Teaches fetching data from web APIs using HTTP requests in command-line workflows.
- Data Fetching and Repository Access - Teaches accessing online data through web APIs and contributing changes to repositories.
