Programming Basics for New Hires: A Study Roadmap

We have written software since 2001, and the question we hear most from people joining a team is not about any particular bug. It is: "Where do I start, and in what order?" This page is the answer we send. It tells you which language to start with for the work you will actually do, how to study so that the basics stick, and which of our lectures to read in which order, from beginner to advanced.

Who this is for, and how to use it

This guide is for three kinds of readers:

• New hires who can write a few lines of code but have never shipped anything, and who have been told to "get up to speed" on the team's language.
• People switching stacks, for example a web developer moving to a Flutter team, or a Java developer who inherited a VB.NET tool.
• Mentors who want one link to send instead of writing the same advice again.

How to use it: read the next section on study habits once. Then use the decision table to pick one language, open that language's lecture list and work through it in order. Each of our lectures states its level at the top (beginner, intermediate or advanced) and ends with a link to the next one.

Most lectures contain measurement sections: timings, memory numbers, benchmark tables. On a first pass you can skip them. They exist because a rule of thumb you have measured is one you will trust, but they are not what you need in your first week. Come back to them when your work makes you ask "is this fast enough?"

How we study the basics (and how these lectures are written)

Every lecture on this site was written by running the code and pasting the real output, errors included. That only helps you if you study the same way. These seven habits are the ones we see separate people who are productive after a month from people who are still copying snippets after three.

1. Type the code yourself and run it. Do not copy and paste. Typing makes you notice the semicolon, the colon after if in Python, the ? after a type in Dart. Your first typos produce your first error messages, which is exactly what you need to practise reading.
2. Read the error message before searching. Compiler errors are more helpful than they look. Swift's error tells you the line and often the fix; Java's incompatible types names both types; VB.NET's BC30512 says exactly which implicit conversion Option Strict blocked. Read the whole message, find the line number, then look at that line. Search only after that.
3. Change one thing and predict the output before running. After an example works, change one value: make the list empty, pass null, use a number above two billion. Write down what you expect, then run it. When you are wrong, you have found something you did not understand, which is the point.
4. Do the exercises before reading the answers. The Dart, Swift and PHP lectures end with exercises. Give each one at least fifteen minutes before you open the answer. For lectures without exercises, step 3 is your exercise.
5. Measure instead of believing folklore. Programming is full of rules that were true once. In our Python concurrency lecture, adding threads to a CPU-bound job did not make it faster; in our ML series, gradient descent needed 140,538 epochs on unscaled features and 2 on scaled ones. You do not have to measure everything, but when a claim matters, test it.
6. Use AI assistants to explain errors, not to skip typing. Pasting an error you have already read and asking "why does this happen?" is a good use. Asking it to write the exercise for you skips the part that teaches you. If it suggests a fix, make sure you can say why the fix works before you keep it.
7. Keep it concrete and short. Thirty minutes of running code beats two hours of watching videos. Each study session should end with something you ran, not something you read about.

Which language first, by goal

Pick the language from the work you will do, not from popularity rankings. If your team already has a codebase, its language wins every argument.

If nobody has told you which language the team uses, ask. That is a better first question than any we can answer here.

Every series in order, beginner to advanced

The six-part series follow the same pattern: lectures 1 and 2 are beginner, 3 and 4 intermediate, 5 and 6 advanced. On a first pass, stop after lecture 4.

Python

Java

PHP

If you write PHP that faces the internet, treat lectures 4 and 5 as required, not advanced.

Dart (for Flutter)

For Flutter work, read lecture 5 early: almost every app talks to a network, and a frozen UI is usually an async mistake.

Swift

VB.NET

C

The C# course is not six long lectures but many short articles, one topic each. Read them in this order.

Beginner: setup and the language core

1. Set Up C# in 2026: .NET 10 SDK, dotnet CLI, Editors
2. C# Variables & Types on .NET 10: decimal vs double
3. C# Operators on .NET 10: Overflow, ??, % and Shifts
4. C# if vs switch: Patterns, CS8509 and Speed (.NET 10)
5. C# Loops on .NET 10: foreach Internals and Speed
6. C# break, continue, goto: Exiting Nested Loops
7. C# Arrays on .NET 10: Jagged vs 2D, Span, Resize Cost
8. C# Methods on .NET 10: ref, out, params and Overloads
9. C# Exception Handling, Re-tested on .NET 10

Intermediate: classes and collections

10. C# Classes on .NET 10: Primary Ctors, required, init
11. C# Access Modifiers and this: Two-Assembly Test
12. C# Constructors and Finalizers: Order, GC, Dispose
13. C# Property Basics: get/set, Auto-Properties, init
14. C# Properties in Depth: the field Keyword and required
15. C# Inheritance: override vs new and Constructor Traps
16. C# Interfaces: Default Methods and Static Abstract
17. C# Structs: Copies, Defensive Copies and Boxing Costs
18. C# Extension Methods, partial and Nested Classes
19. C# ArrayList, Hashtable: Boxing Cost and Migration
20. C# List<T> Internals: Capacity Growth and AsSpan
21. Choosing C# Collections: Dictionary, HashSet, Frozen
22. C# File I/O on .NET 10: Async, BOM and Path Traps

Advanced: functions as values, LINQ, generics, events

23. C# Anonymous Types and Anonymous Methods in 2026
24. C# Lambda Expressions, Re-run on .NET 10
25. C# Func and Action Delegates: Pitfalls and Call Cost
26. C# LINQ Basics, Re-run on .NET 10
27. C# LINQ Query vs Method Syntax: What the Compiler Does
28. C# LINQ GroupBy and Join: Keys, ToLookup, CountBy
29. C# Generics on .NET 10: Constraints, Variance, Boxing
30. C# Delegates and Events, Re-tested on .NET 10
31. C# Delegate Callbacks: Progress, Cancellation, Chains
32. C# Events Beyond the Basics: Accessors, Async, Weak
33. C# Reflection & Attributes: Invoke Cost, AOT Warnings

Windows-only topics (read when your job needs them): C# Registry on .NET 10: CA1416, RegistryView, Pitfalls · WinForms ShowDialog vs Show: Modal vs Modeless · WinForms OK/Cancel Buttons: AcceptButton, DialogResult · WinForms Single Instance: One Form, One App (Mutex)

HTTP and web basics (everyone who touches a server or an API)

Every app talks HTTP. These lectures read real curl -v output against local test servers: status codes, redirects, cookies, caching, TLS and compression. Read 1–3 before your first API task.

JavaScript (run on JavaScriptCore)

Language core only: types, functions, objects, classes, promises and performance, all run in the jsc shell that ships with macOS. Browser DOM and Node.js are explained but labelled "not run here".

C (how the machine really works)

Optional for most jobs, but the fastest way to understand memory, pointers and why other languages behave the way they do. Compiled with clang, with AddressSanitizer catching the bugs.

C++ (after C, or straight from another language)

For games, embedded, high-performance code and competitive programming. Compiled with Apple clang 21 and libc++, with sanitizers catching the bugs and every speed claim measured.

Algorithms and data structures (everyone)

The examples are mostly C and C++, with some C#, but the ideas carry to any language. Read them after you are comfortable with loops and functions in your own language.

• Beginner, searching and sorting: Linear Search vs Binary Search vs HashSet, Measured → Binary Search in C: Re-running Our 2021 Code → Bubble, Insertion and Quick Sort in C, Measured
• Beginner to intermediate, linear structures: Singly Linked List in C++: Edge-Case Bugs, Cache Cost → Doubly Linked List in C++: prev/next Order Bugs → Circular Linked List in C++: Loop Traps, Josephus → C++ Stack: Overflow Checks, ASan Findings, Benchmarks → Linked Queue in C++: Leaks, Empty Dequeue, Benchmarks → C++ Circular Queue: Full vs Empty and Modulo vs Mask
• Intermediate, trees and heaps: Tree Traversal in C++: When Recursion Overflows → Binary Search Tree in C: Bugs, Deletion, Sorted Input → Binary Heap: O(n) Heapify, Heapsort, PriorityQueue
• Advanced, graphs and strategy: DFS in C++ and C#: Recursion Limits, Cycles, Topo Sort → BFS in C++: Shortest Paths and the Visited-Mark Bug → Greedy Algorithms in C: When Coin Change Fails vs DP

Regular expressions (everyone)

Every developer ends up writing a regex for log searching, input checks or a quick data cleanup. The examples run in .NET, Python, PHP and JavaScript-style engines.

• Beginner: What Is Regex? Uses, Limits and a .NET Speed Test → Simple Regex String Matching: Case, Culture, Escape → Regex Metacharacters and the $ Newline Trap → Regex Character Sets: [abc], Ranges and \p{L} Tested
• Intermediate: Regex Quantifiers: Greedy, Lazy, Possessive, Measured → Regex Groups: Numbering, Named Groups, .NET Balancing → Regex Backreferences in .NET, Python, PHP and JS
• Advanced: Regex for Repeated Characters: (.)\1+ in 4 Engines → Regex Lookaround in 5 Engines: Python, PHP, .NET, JS

Command line (everyone, start here)

These three series are for everyone, whatever language you picked. Most new hires meet the terminal and Git on day one and SQL within the first month, usually before they are comfortable in their main language. Everything was run on SQLite 3.51, Git 2.54 and macOS zsh/bash; where Linux (GNU) tools behave differently, the lectures say so.

Git (everyone)

SQL (everyone)

Machine learning from scratch (after Python)

Five lectures that use only the Python standard library, so you see what "training" does before a library hides it. Finish Python lectures 1 to 4 first.

1. Linear Regression from Scratch: GD, SGD and Scaling (intermediate)
2. k-means in Pure Python: Local Minima and k-means++ (intermediate)
3. Naive Bayes in Pure Python on 86 Real Blog Posts (intermediate)
4. Perceptron to Neural Network in Pure Python, Measured (advanced)
5. TF-IDF and BM25 From Scratch: Searching Our Own Blog (advanced, the bridge to RAG)

A suggested first four weeks

This plan assumes about one hour a day next to your normal onboarding. It covers one language plus the shared fundamentals. It does not cover the advanced lectures, on purpose.

Before week 1, or alongside it: command line lectures 1–2 and Git lectures 1–2. Most of the "it doesn't run" questions in the first week turn out to be a path, a space in a file name, or an uncommitted change, not the language.

For C#, replace "lectures 1 and 2" with articles 1 to 9 of the beginner list and "lectures 3 and 4" with articles 10 to 22, and expect weeks 1 and 2 to take three weeks. That is normal; the articles are short but there are more of them.

Advanced lectures (5 and 6, async, concurrency, performance, memory) come later, when a real task needs them. Reading them in week 2 mostly produces confusion.

When you get stuck

• Shrink the program. Delete code until the problem disappears, then put back the last thing you removed. A ten-line example that fails is easier to understand, and easier to ask about.
• Print more than you think you need. Print the value and its type (type(x) in Python, x.runtimeType in Dart, x.GetType() in C#). Half of beginner bugs are a value that is not the type you assumed.
• Check the version. python3 --version, java -version, dart --version, php -v, swift --version, dotnet --version. An example written for a newer version can fail on an older one with a confusing error.
• Ask well. Bring the code, the full error text and what you already tried. A mentor can answer that in two minutes; "it doesn't work" takes twenty.
• Stop after 30 minutes and ask. Being stuck for a whole afternoon teaches less than being unstuck in half an hour and spending the rest practising.

An honest note about our environment

The lectures were run on an Apple Silicon Mac (M1 Pro) with specific versions: Python 3.9 and 3.11, OpenJDK 26, PHP 8.5, Dart SDK 3.11, Swift 6.4, .NET 10 and Apple clang 21, SQLite 3.51, Git 2.54, and zsh 5.9 / bash 3.2 on macOS. Each lecture states the exact versions it used. On Windows or Linux, or on other versions, file paths, timings and a few error messages will differ. The WinForms articles were compiled for Windows but not run on the Mac, and they say so. Timings are from one machine and are meant to show which approach wins and by roughly how much, not exact numbers you should expect.

If something in a lecture does not match what you see, check the version first. If it still differs, that is useful to know, and probably a sign that something changed.