Junior Software Developer Course

Lesson 1 • How Computers Execute Code

Covers binary representation, CPU instruction cycles, and memory hierarchy. Grounds all later coding concepts in hardware reality.

Lesson 2 • Debugging and Problem-Solving Strategies

Teaches systematic error diagnosis using print statements and a debugger. Develops the analytical habits required for all subsequent coding work.

Lesson 3 • Core Programming Concepts

Introduces variables, data types, operators, and control flow. These primitives underpin every program written in later chapters.

Lesson 1 • Git Fundamentals

Covers the working tree, staging area, and commit history model. Establishes the mental model required for every branching operation ahead.

Lesson 2 • Remote Repositories and Pull Requests

Pushes branches to a remote host and opens pull requests for review. Introduces the code review gate that governs all team contributions.

Lesson 3 • Team Workflow and Repository Hygiene

Establishes commit message conventions, branch naming, and protected-branch rules. Prepares students for contributing to real open-source and enterprise repos.

Lesson 1 • Arrays and Linked Lists

Contrasts contiguous and pointer-based storage with real performance trade-offs. Provides the baseline for understanding all other structures.

Lesson 2 • Sorting and Searching Algorithms

Implements and benchmarks common sorting and search strategies. Builds intuition for algorithm selection based on data size and shape.

Lesson 3 • Stacks, Queues, and Hash Tables

Covers LIFO and FIFO abstractions plus hash-based key-value storage. These structures appear in parsers, schedulers, and caches throughout the course.

Lesson 4 • Recursion and Dynamic Programming

Solves problems by breaking them into overlapping subproblems with memoization. Extends algorithmic range beyond iterative solutions introduced earlier.

Lesson 1 • SOLID Design Principles

Applies five OOP design rules to evaluate and refactor class designs. Provides the vocabulary used in code reviews in all remaining chapters.

Lesson 2 • Polymorphism and Duck Typing

Enables a single interface to operate on multiple types at runtime. Reduces coupling between components built throughout the chapter project.

Lesson 3 • Inheritance and Code Reuse

Models is-a relationships through class hierarchies to eliminate duplication. Connects directly to polymorphism covered in the next section.

Lesson 4 • Building a Multi-Class Project

Integrates all OOP concepts into a cohesive mini-application with multiple interacting classes. Validates design decisions through peer code review.

Lesson 1 • Connecting a Database to an Application

Integrates a database driver and ORM into application code with connection pooling. Completes the persistence layer of the running project.

Lesson 2 • SQL Querying Essentials

Writes SELECT, INSERT, UPDATE, and DELETE statements with filtering and sorting. These queries form the data access layer of the chapter project.

Lesson 3 • Indexes, Transactions, and Constraints

Adds indexes for query performance and wraps mutations in ACID transactions. Ensures data integrity under concurrent access scenarios.

Lesson 4 • Relational Database Concepts

Explains tables, primary keys, foreign keys, and normalization up to third normal form. Provides the schema design vocabulary used throughout the chapter.

Lesson 1 • HTTP and the Web Request Cycle

Traces a browser request through DNS, TCP, and HTTP to a server response. Establishes the protocol knowledge required to design correct API endpoints.

Lesson 2 • Authentication and Authorization

Implements token-based authentication and role-based access control on API routes. Secures the project API before it is exposed to external consumers.

Lesson 3 • Input Validation and Error Handling

Validates request payloads with schemas and maps domain errors to HTTP codes. Prevents malformed data from corrupting the database layer.

Lesson 4 • API Documentation and Testing

Generates interactive API docs and writes automated endpoint tests. Ensures the API contract is verifiable and consumable by other developers.

Lesson 1 • Testing Fundamentals and Test Pyramid

Defines the three testing layers and their cost-to-feedback trade-offs. Frames the testing strategy applied across all remaining sections.

Lesson 2 • Unit Testing with Mocks and Stubs

Isolates units under test by replacing dependencies with test doubles. Enables fast, deterministic tests for business logic written in earlier chapters.

Lesson 3 • Code Coverage and Continuous Quality

Measures coverage, enforces thresholds, and integrates tests into a CI pipeline. Connects testing practice to the deployment workflow introduced next.

Lesson 4 • Integration and Database Testing

Tests component interactions against a real or in-memory database. Validates that the ORM and query logic from the database chapter work correctly.

Lesson 1 • Continuous Delivery and Deployment

Extends the CI pipeline to push verified artifacts to staging and production. Introduces deployment strategies that minimize downtime and risk.

Lesson 2 • Monitoring and Observability

Instruments the application with logs, metrics, and traces to detect production issues. Closes the feedback loop between deployment and code quality.

Lesson 3 • Containerization with Docker

Packages an application and its dependencies into a portable container image. Eliminates environment inconsistencies encountered throughout earlier chapters.

Lesson 4 • Continuous Integration Pipelines

Configures automated lint, test, and build jobs triggered on every code push. Enforces the quality gates established in the testing chapter.