Software Development

The mental muscles that come before syntax. Compact, deliberately not encyclopedic. Learn to decompose problems, reason about state, and read code you did not write — the three skills every programmer uses every day regardless of language.

• Computational Thinking(12 concepts)

  • What Abstraction Is (and Is Not)
  • Spotting Similar Problems
  • What Is an Algorithm
  • Breaking Problems into Parts
  • Modeling the Real World as Data
  • Classic Programming Patterns
  • Pseudocode: Thinking Before Typing
  • Top-Down vs Bottom-Up Thinking
  • Knowing When to Stop Decomposing
  • Levels of Abstraction
  • Tracing Algorithms by Hand
  • When Is One Algorithm Better Than Another
• Reading and Reasoning About Code(9 concepts)

  • Line-by-Line Execution
  • Memory as Labeled Boxes
  • Entry Points and File Structure
  • Tracking Variable State on Paper
  • References vs Copies
  • Search as a Reading Tool
  • Predicting Output Before Running
  • The Call Stack
  • Tests, Comments, and Types as Signal

Depth-first Python. One language, learned well, is worth five languages learned shallowly. Covers syntax and types, functions and scope, the collection types you use every day, and the handful of I/O and error skills that turn a script into a useful tool. Python chosen for readability, AI-era relevance, and the fact that almost every downstream skill in this curriculum can be demonstrated in it.

• Python Fundamentals(18 concepts)

  • Installing Python
  • Variables and Assignment
  • Arithmetic Operators
  • if, elif, and else
  • for Loops and range()
  • Your First Program
  • Integers, Floats, Strings, Booleans
  • Boolean Operators and Short-Circuit Evaluation
  • Compound Conditions
  • while Loops and Termination
  • The REPL vs Script Files
  • Type Conversion and Coercion
  • Operator Precedence and Parentheses
  • Guard Clauses and Early Returns
  • break and continue
  • Naming Things Well
  • Strings and f-Strings
  • Nested Loops and Conditionals
• Functions and Modularity(12 concepts)

  • Defining a Function
  • Positional and Keyword Arguments
  • Local vs Global Scope
  • What a Pure Function Is
  • Calling Functions and Using Return Values
  • Default Parameter Values
  • The LEGB Lookup Rule
  • Side Effects: Useful but Noisy
  • One Function, One Job
  • *args and **kwargs
  • Why Global Mutable State Is Dangerous
  • Functional Core, Imperative Shell
• Collections and Data Shaping(14 concepts)

  • Creating and Indexing Lists
  • Creating Dictionaries and Accessing Values
  • Sets: Unordered, Unique
  • enumerate, zip, reversed
  • Slicing
  • Core Dict Methods
  • Set Operations: union, intersection, difference
  • List Comprehensions
  • Mutating Lists: append, extend, pop, insert
  • Modeling Structured Data with Dicts
  • Tuples: Immutable Groupings
  • Dict and Set Comprehensions
  • Aliasing and Copying Lists
  • When a Loop Is Clearer
• Errors, Types, and I/O(14 concepts)

  • Types of Errors: Syntax, Runtime, Logic
  • Basic Type Annotations
  • open() and the with Statement
  • JSON: Load, Dump, and Shape
  • try/except Basics
  • Collections and Optional Types
  • Reading and Writing Text
  • CSV: Rows and Columns
  • Reading Tracebacks
  • Type Checking in Practice
  • Paths with pathlib
  • argparse: Command-Line Arguments
  • Raising Your Own Exceptions
  • Your First Real Script

Scripts become software here. Version control so your work survives mistakes, OOP so code scales past a single file, tests and debugging so you can change code without fear, and design-for-change habits that separate throwaway code from code you can live with in six months.

• Design for Change(13 concepts)

  • Naming Is Design
  • The Long Function
  • What Refactoring Is (Precisely)
  • One Logical Change per Commit
  • Short, Focused Functions
  • Duplicated Logic
  • Small, Always-Working Steps
  • Separate Refactors from Features
  • Boring Over Clever
  • Deep Nesting
  • When to Rewrite Instead of Refactor
  • PR Descriptions That Help Reviewers
  • Resist Premature Abstraction
• Object-Oriented Programming(11 concepts)

  • What a Class Is (and Is Not)
  • One Class, One Job
  • Composition: Has-A Is the Default
  • __init__ and Instance Attributes
  • Hiding Implementation Detail
  • Inheritance Basics
  • Methods: Functions That Know About Their Object
  • Properties: Computed Attributes
  • When Inheritance Hurts
  • __repr__ for Readable Debugging
  • Dependency Injection: Pass It In
• Version Control with Git(13 concepts)

  • Working Directory, Staging Area, Commit
  • init, add, commit
  • Remotes, push, and pull
  • Resolving Merge Conflicts
  • Commits Are Snapshots, Not Diffs
  • status, diff, log: Knowing Where You Are
  • Pull Requests and Code Review
  • Undoing Commits, Amending, and Unstaging
  • Branches Are Just Pointers
  • Creating Branches, Switching, Merging
  • Keeping Your Branch Current
  • The Reflog: Git's Safety Net
  • Writing Good Commit Messages
• Testing and Debugging(14 concepts)

  • Tests Enable Change
  • Installing and Running pytest
  • Fixtures: Setup and Teardown
  • Reproduce First
  • Using a Real Debugger
  • What to Test and What to Skip
  • Writing Good Assertions
  • Mocking Dependencies
  • Isolate, Hypothesize, Test
  • Conditional Breakpoints
  • Parametrized Tests
  • When Not to Mock
  • Rubber-Duck Debugging
  • Binary-Search Bisection

The mile between 'works on my laptop' and 'users are using it.' Command line, a real web app, a real database, a real deploy — plus the 2026 meta-skill: working with AI assistants without letting them put garbage in your codebase. Security basics are woven in, not bolted on.

• Deploying and Observing(14 concepts)

  • A Minimum-Viable Dockerfile
  • Picking a PaaS
  • Never Commit Secrets
  • Structured Logging
  • Images vs Containers
  • Your First Deploy
  • Rotating a Leaked Secret
  • Error Tracking (Sentry-style)
  • Layer Caching and Fast Rebuilds
  • Attaching a Managed Database
  • Auditing Your Dependencies
  • Uptime Checks
  • Custom Domain and HTTPS
  • An OWASP Shortlist for Everyday Apps
• Working with Databases(14 concepts)

  • SELECT, WHERE, ORDER BY
  • Primary and Foreign Keys
  • SQLite: Zero-Config Database
  • Migrations: Versioned Schema Changes
  • INSERT, UPDATE, DELETE
  • Constraints: Making Bad Data Impossible
  • Postgres: The Production Default
  • Safe Migration Patterns
  • Joins: Connecting Tables
  • Indexes: Fast Lookups (With a Cost)
  • Writing Portable-Enough SQL
  • ORMs: Python Objects for Rows
  • Aggregations and GROUP BY
  • When to Drop to Raw SQL
• AI-Assisted Development(13 concepts)

  • Scope and Constraints
  • Treat It Like a PR from a Stranger
  • What Agents Are Good At (Today)
  • Tests as the Forcing Function
  • Supplying the Right Context
  • Common AI Failure Modes
  • Where Humans Still Belong
  • Types for Safety
  • Iterating on a Reply
  • Never Merge What You Don't Understand
  • Scoping a Task for an Agent
  • Keep AI Diffs Small
  • Learning to Reject
• Building a Web App(16 concepts)

  • Request and Response
  • Hello, Web
  • HTML Templates
  • Authentication vs Authorization
  • Routes, Services, and Data
  • Verbs and Status Codes
  • Routes and Handlers
  • Forms and Validation
  • Password Hashing Done Right
  • Configuration Out of Code
  • Headers in Practice
  • Path Params and Query Strings
  • JSON Endpoints
  • Sessions vs Tokens
  • A README That Actually Helps
  • Protecting Routes
• The Command Line and Your Environment(12 concepts)

  • Navigating the Filesystem
  • Redirecting Output
  • Environment Variables
  • Virtual Environments with venv
  • Copying, Moving, Deleting Files
  • Pipes: Commands as Lego
  • .env Files in Projects
  • pip and requirements.txt
  • Tab Completion and History
  • Essential Text Utilities
  • Processes: ps, kill, bg, fg
  • A Tour of Modern Package Tools