Learn programming.
Build with it.

A general roadmap for learning programming from computer fundamentals through practical software development and into a chosen specialization.

The goal is not to memorize technologies. It is to develop the ability to understand computers, write programs, solve problems, work with professional development tools, build software, and continue learning independently.

Understand the computer and operating environment that software runs on.

How computers represent information

Bits and bytes

Binary

Numbers and numeric representation

Text representation

Character encoding

Files and file sizes

Data representation

Computer hardware

CPU

RAM

Storage

Input/output devices

Motherboard and buses — conceptual

GPU — basic purpose

Peripherals

Operating systems

What an operating system does

Processes

Files and directories

Permissions

Memory management — conceptual

Applications vs system software

Environment variables

Programs vs processes

Command line

Terminal and shell

Directory navigation

Creating, moving, copying, and deleting files

Reading files

Running programs

Command arguments

Pipes and redirection

Environment variables

Basic shell scripting

Networking fundamentals

Networks

Client/server model

IP addresses

Ports

DNS

HTTP/HTTPS

TCP/IP — conceptual

Localhost

Internet vs Web

Operate a development environment from the terminal and investigate how a program interacts with the operating system and network.

The learner should be able to:

Explain how computers represent numbers and text.

Explain the roles of CPU, RAM, storage, and the operating system.

Navigate and manipulate files using a terminal.

Run a program from the terminal.

Explain environment variables at a basic level.

Explain, at a high level, how a browser reaches a website.

Concepts

Bit

Byte

Binary

Data Representation

Character Encoding

CPU

RAM

Storage

Operating System

Process

File System

File Permissions

Environment Variables

Client–Server Model

IP Address

Port

DNS

HTTP

HTTPS

TCP/IP

Localhost

Skills

Command Line

File Navigation

Technologies

Operating Systems

Shells

Understand how programs are constructed and develop the ability to write basic programs independently.

Programming concepts

Programs and instructions

Source code

Programming languages

Compilers

Interpreters

Runtime environments

Syntax

Semantics

Variables and values

Values

Variables

Constants

Assignment

Expressions

Primitive data types

Type systems

Type conversion

Mutable vs immutable values

Control flow

Sequential execution

Conditions

Boolean logic

Branching

Loops

Iteration

Early exit

Nested control flow

Functions

Parameters

Arguments

Return values

Scope

Local vs global state

Pure vs impure functions

Function composition

Code reuse

Higher-order functions — conceptual

Collections

Arrays/lists

Objects/records

Sets

Maps/dictionaries

Nested data

Choosing appropriate data structures

Errors and state

Syntax errors

Runtime errors

Logic errors

Exceptions

Error handling

Program state

State changes

Input and output

User input

Program output

Standard input/output

File I/O

Basic serialization

Build small programs such as:

Calculator

Number guessing game

Unit converter

CLI to-do list

Expense tracker

Text analyzer

Contact book

Build a small command-line application that:

Accepts input

Validates input

Stores structured data

Processes that data

Uses conditions and loops

Uses reusable functions

Handles errors

Produces useful output

Can be explained by the learner

Concepts

Program

Source Code

Programming Language

Compiler

Interpreter

Runtime

Syntax

Semantics

Variable

Value

Data Type

Expression

Assignment

Type System

Type Conversion

Mutability

Control Flow

Conditional

Boolean Logic

Iteration

Loop

Function

Parameter

Argument

Return Value

Scope

Function Composition

Higher-Order Function

Array

List

Object / Record

Set

Map / Dictionary

Data Structure

Error

Exception

Program State

Input / Output

Serialization

Skills

Code Reuse

Error Handling

File I/O

Learn how to approach problems systematically before and during implementation.

Programming knowledge is only useful when it can be applied to unfamiliar problems.

Understanding problems

Identify the actual problem

Separate requirements from assumptions

Identify inputs and outputs

Identify constraints

Identify edge cases

Problem decomposition

Break large problems into smaller problems

Separate concerns

Identify reusable operations

Understand dependencies between tasks

Planning

Requirements → plan → implementation

Pseudocode

Flowcharts

Decision tables

Writing solution steps before coding

Patterns and abstraction

Pattern recognition

Generalization

Reusable logic

Abstraction

Avoiding unnecessary abstraction

Constraints

Time constraints

Memory constraints

Input size

Resource limitations

Trade-offs

Basic performance awareness

Debugging as problem solving

Reproduce a problem

Observe actual behavior

Form hypotheses

Test hypotheses

Isolate causes

Fix underlying causes

Verify the fix

Solve increasingly unfamiliar problems where the learner must decide:

What the problem actually asks.

What the inputs and outputs are.

How to break the problem down.

What assumptions are being made.

What approach should be used.

Take an unfamiliar real-world problem from a provided specification, produce a solution plan, implement it in a language of choice, test it against normal and edge cases, and explain the decisions made.

Concepts

Requirements

Constraints

Edge Case

Separation of Concerns

Dependency

Abstraction

Generalization

Computational Constraint

Trade-off

Performance

Scalability

Bug

Root Cause

Skills

Problem Solving

Input / Output Analysis

Problem Decomposition

Pseudocode

Flowchart

Algorithm Design

Implementation Planning

Pattern Recognition

Reusability

Debugging

Root Cause Analysis

Reproduction

Become comfortable operating a development environment and using the tools required to create and maintain software.

Terminal and shell

Terminal

Shell

Commands

Arguments

Flags/options

Working directory

Absolute vs relative paths

Command history

Tab completion

Help and manual pages

Filesystem

Navigate directories

Create files/directories

Copy and move files

Rename files

Delete files

Search files

Inspect files

Hidden files

File extensions

Running programs

Executables

Arguments

Exit codes

Standard output

Standard error

Processes

Background processes

Stopping programs

Environment configuration

Environment variables

PATH

Configuration files

Local vs global configuration

Development vs production environments

Secrets vs ordinary configuration

Dependencies

Libraries vs applications

Dependencies

Package managers

Installing and removing packages

Updating packages

Dependency versions

Lockfiles

Direct vs transitive dependencies

Semantic versioning

Editors and IDEs

Code editors

IDEs

Workspaces

Code navigation

Search

Extensions

Formatting

Integrated terminals

Basic debugging tools

Documentation

Official documentation

API references

Examples

Version-specific documentation

Error messages

Effective technical searching

Documentation vs tutorials

Take an unfamiliar project and:

Navigate it from the terminal.

Identify important files.

Install dependencies.

Understand its available scripts.

Run it.

Investigate errors.

Make a small change.

Run it again.

Find relevant documentation when necessary.

Take an unfamiliar code project, set up its development environment, run it successfully, make a small functional change, verify the change, and document what was done.

Concepts

Terminal

Shell

Command

Argument

Flag / Option

Path

Working Directory

Executable

Process

Exit Code

Standard Error

Environment Variable

PATH

Configuration

Environment

Secret

Dependency

Package

Semantic Versioning

Lockfile

IDE

Technical Documentation

API Reference

Skills

Filesystem Navigation

File Management

Process Control

Dependency Management

Code Navigation

Code Formatting

Documentation Literacy

Technical Research

Technologies

Shells

Package Managers

Code Editors / IDEs

Understand version control, collaborative development, and the basic open-source workflow.

Version control

Why version control exists

Tracking changes

History

Comparing versions

Reverting changes

Local vs remote repositories

Git's model

Working tree

Staging area

Repository

Commit

Branch

HEAD

Diff

Merge

Git workflow

Initialize

Clone

Status

Inspect changes

Stage

Commit

View history

Branch

Merge

Resolve conflicts

Restore/revert changes

GitHub

Remote repositories

Push/pull

Repository structure

README files

Issues

Pull requests

Code review

Releases

Discussions

Forks

Open-source repositories

Collaboration

Feature branches

Pull requests

Reviews

Merge conflicts

Focused changes

Collaborative workflows

Open source

Finding projects

Contribution guidelines

Forking

Branching

Pull requests

Responding to review

Updating contributions

Licenses

Complete both:

Personal project

Put an existing project under Git and create a meaningful history.

Collaboration simulation

Work with another person through:

Feature → Branch → Commit → Pull Request → Review → Changes → Merge

Deliberately create and resolve a small merge conflict.

Take a small project from an unversioned state to a documented GitHub repository, develop a feature on a branch, submit it through a pull request, review a change, resolve a merge conflict, and produce a clean project history.

Concepts

Version Control

Version

Change History

Repository

Local Repository

Remote Repository

Working Tree

Staging Area

Commit

Branch

HEAD

Diff

Merge

Pull Request

Issue

Fork

Contribution

Contributor

License

Skills

Code Review

Commit Message

Change Isolation

Technologies

Git

GitHub

Understand how information can be organized and how computational solutions can be designed and evaluated.

This stage is about developing algorithmic thinking, not completing an endless collection of coding puzzles.

Algorithms

What an algorithm is

Inputs and outputs

Operations and steps

Correctness

Algorithm vs implementation

Different solutions to the same problem

Complexity

Time complexity

Space complexity

Big O notation

Best/average/worst case

Constant, logarithmic, linear, linearithmic, and quadratic growth

Time/memory trade-offs

Data structures

Arrays/lists

Linked lists

Stacks

Queues

Hash tables

Trees

Binary trees

Binary search trees

Graphs

Directed/undirected graphs

Weighted graphs

Searching

Linear search

Binary search

Search prerequisites

Search complexity

Sorting

Selection sort

Insertion sort

Bubble sort

Merge sort

Quicksort

Stability

Comparing approaches

Recursion

Base case

Recursive case

Call stack

Recursive decomposition

Recursion vs iteration

Problem-solving techniques

Brute force

Divide and conquer

Greedy algorithms

Backtracking

Dynamic programming — introductory

Two-pointer technique

Sliding window

Hash-based approaches

Choosing structures

Matching structures to required operations

Lookup requirements

Ordering requirements

Hierarchical relationships

Graph relationships

Performance trade-offs

Concept challenges

Reverse a string

Find duplicates

Count frequencies

Validate parentheses

Search sorted data

Applied problems

Task queue

Contact lookup

Dependency resolver

Navigation system

Inventory index

Analysis Compare two solutions and explain how their performance changes as the input grows.

Design and implement a solution to an unseen problem, choose appropriate data structures and algorithms, explain the trade-offs, analyze time and space complexity, and demonstrate correctness with tests.

Concepts

Algorithm

Algorithm Correctness

Time Complexity

Space Complexity

Big O Notation

Computational Complexity

Array

Linked List

Stack

Queue

Hash Table

Tree

Binary Tree

Binary Search Tree

Graph

Directed Graph

Weighted Graph

Linear Search

Binary Search

Selection Sort

Insertion Sort

Merge Sort

Quicksort

Stable Sort

Recursion

Call Stack

Brute Force

Divide and Conquer

Greedy Algorithm

Backtracking

Dynamic Programming

Two-Pointer Technique

Sliding Window

Skills

Algorithm Design

Algorithm Analysis

Searching

Sorting

Complexity Analysis

Learn to investigate failures systematically and verify that software behaves correctly.

• +Debugging asks: Why is this wrong?
• +Testing asks: Does this behave correctly?

Bugs

Expected vs actual behavior

Reproducible vs intermittent failures

Syntax errors

Runtime errors

Logic errors

Configuration failures

Dependency failures

Integration failures

Debugging

Reproduce

Isolate

Gather evidence

Form hypotheses

Test hypotheses

Find root cause

Fix

Verify

Check for regressions

Debugging tools

Logging

Breakpoints

Debuggers

Stack traces

Variables

Call stacks

Network inspection

Browser developer tools

Error messages

Source maps — basic

Testing fundamentals

Why testing exists

Test cases

Expected results

Assertions

Test inputs

Edge cases

Regression testing

Test isolation

Deterministic tests

Testing types

Unit testing

Integration testing

End-to-end testing

Manual testing

Exploratory testing

Test design

Happy paths

Invalid inputs

Boundary values

Empty inputs

Unexpected states

Equivalence classes — basic

Behavior-focused testing

Regression cases

Test-driven development

Red

Green

Refactor

When TDD is useful

Development lifecycle

Local testing

Commits

Pull requests

Automated checks

Code review

Continuous integration

Debugging challenge

Take broken software, reproduce the failure, identify the cause, fix it, and verify the result.

Testing challenge

Design tests covering normal input, invalid input, boundaries, edge cases, and regressions.

Exploratory challenge

Take a working application and deliberately try to make it fail.

Take an existing program containing a defect, reproduce and diagnose the problem, fix its root cause, create tests covering the corrected behavior and relevant edge cases, and demonstrate that the change does not introduce a regression.

Concepts

Bug

Expected Behavior

Actual Behavior

Reproducibility

Syntax Error

Runtime Error

Logic Error

Configuration Error

Stack Trace

Call Stack

Testing

Test Case

Assertion

Edge Case

Regression Testing

Test Isolation

Unit Testing

Integration Testing

End-to-End Testing

Continuous Integration

Automated Testing

Test-Driven Development

Quality Gate

Skills

Debugging

Logging

Manual Testing

Exploratory Testing

Automated Testing

Root Cause Analysis

Code Review

Choose a domain in which to apply the foundation.

This is a decision point, not another subject that must be completed.

The learner can change direction later.

Web Development

Build software for the Web.

Potential progression:

HTML ↓ CSS ↓ JavaScript ↓ Web APIs ↓ TypeScript ↓ Frontend ↓ Backend ↓ Databases ↓ Deployment

Mobile Development

Build applications for mobile platforms.

Possible directions:

Native Android

Native iOS

Cross-platform

Desktop Development

Build applications for desktop operating systems.

Possible directions:

Windows

macOS

Linux

Cross-platform

Game Development

Build games and interactive simulations.

Potential areas:

Game programming

Game engines

Graphics

Physics

Input

Audio

Game systems

Networking

AI

Optimization

Publishing

Data / AI

Potential directions:

Data analysis

Data engineering

Machine learning

AI engineering

Scientific computing

Systems / Low-Level

Potential areas:

Computer architecture

Operating systems

Systems programming

Networking

Embedded systems

Infrastructure

Security

Ask:

What do I want to build?

Websites / web apps → Web Mobile applications → Mobile Desktop software → Desktop Games → Game Development Data / intelligent systems → Data / AI Systems / infrastructure → Systems

What do I want to build? ↓ Which specialization fits? ↓ What skills does it require? ↓ Which technologies can provide those skills? ↓ What should I build first?

Research a chosen specialization and identify:

The skills required.

Relevant technologies.

The type of work involved.

A realistic first project.

Choose a specialization, identify the skills and technologies required for an initial project, explain the reasoning behind the choice, and define a concrete first project.

Specializations

Web Development

Mobile Development

Desktop Development

Game Development

Data / AI

Systems Development

Each specialization becomes its own Roadmap and connects to the same Craftmish knowledge system.

The common programming roadmap ends here.

It does not attempt to teach every programming domain.

Instead:

CODING / PROGRAMMING │ Common Programming Foundation │ ┌──────────────┼──────────────┐ │ │ │ Web Mobile Systems │ │ │ Roadmap Roadmap Roadmap │ ┌─────┴─────┐ Frontend Backend

Other branches can be developed independently.

The roadmap is a structured path through a larger knowledge system.

A roadmap item can point to:

Technology Concept Skill Resource Challenge Project Proof Task

For example:

Coding / Programming Roadmap ↓ Programming Fundamentals ↓ Functions ↓ JavaScript ↓ Challenges ↓ Project ↓ Proof ↓ TypeScript

The roadmap therefore remains useful even as the wider Craftmish knowledge base grows.

The complete model is:

Explore ↓ Knowledge ↓ Learn ↓ Work ↓ Practice ↓ Build ↓ Prove ↓ Review ↓ Contribute ↓ Next skill

The objective is not simply to finish the roadmap.

The objective is to move from knowing about programming → being able to program → being able to build → being able to demonstrate and improve that ability.