Find your next idea.
From first principles to memory, program design, and modern C. Browse freely, or follow the learning path to connect the concepts.
73 chapters to explore
What is programming?
Turn an everyday problem into precise steps, and distinguish a program, an algorithm, and the result you want.
How computers follow instructions
Understand program state, sequence, decisions, repetition, and the difference between an instruction in a language and a machine instruction.
CPU, memory, storage, and the operating system
Build a practical model of the parts involved when an ordinary computer runs a program, without mistaking that model for C’s rules.
Why programming languages exist
Connect human-readable source, grammar, meaning, translation, and the abstractions that make a programming language useful.
Why C was created
Connect C’s origins to Unix, earlier languages, and the practical problem of writing systems software.
From source code to a running program
Separate editing, translation, linking, loading, and execution, and understand where a useful diagnostic can come from.
Variables, values, and types
Give meaning to data: understand the difference between an object, its name, its type, and its current value before moving into declaration, initialization, assignment, and conversion.
Data types, ranges, and representations
Choose types by meaning, range, and precision, and distinguish C guarantees from familiar machine sizes.
Declarations, initialization, and assignment
Separate introducing a name, defining an object, supplying its first value, and changing it later.
Reading C: tokens, expressions, and statements
Recognize the small language units inside a line of C, then connect them to declarations, expressions, and statements.
Expressions and operators: meaning before precedence
Reason about operands, types, comparisons, short-circuiting, side effects, and the difference between grouping and evaluation order.
Conditions, choices, and loops
Follow how execution selects a path, repeats work, and transfers control, with careful attention to boundaries and progress.
Functions: inputs, results, and contracts
Understand declarations, calls, parameters, return values, scope, and pass-by-value without assuming that a function prints its result.
Recursion: following separate calls
Understand stopping cases, progress, separate local state, returned results, and the limits of recursive designs.
Comments: explaining intent in C
Understand comment syntax, translation, limitations, and the difference between documenting a decision and changing program behavior.
Qualifiers: read-only access and observable effects
Understand const access paths, then revisit optional pointer, volatile, restrict, and atomic contracts.
Storage classes: duration, scope, and linkage
Ask separate questions about names, object lifetimes, definitions, initialization, and shared declarations.
Constants, constant expressions, and compile-time checks
Choose between literals, enumeration constants, macros, const objects, and C23 constexpr with the right contract.
Reading keywords by the job they do
Connect types, declarations, control flow, type queries, generic selection, and function specifiers.
C keyword index: C17 and C23
Browse every standard keyword spelling by edition, role, and a link to its deeper explanation.
Objects and memory
Distinguish an object, its value, its representation, and its physical implementation before reasoning about addresses.
Scope, lifetime, and storage duration
Separate where a name is visible from when an object exists, then connect those rules to safe pointer use.
Understanding pointers
Build a clear model of pointer objects, their targets, aliasing, null values, and indirect access through function parameters.
Understanding arrays
Connect element counts, contiguous storage, initialization, indexing, and permitted one-past boundaries.
Arrays and pointers together
Explain array-to-pointer conversion, adjusted parameters, pointer-to-array declarations, and two-dimensional rows.
Characters, buffers, and strings
Understand termination, capacity, length, literals, copies, and why text-handling functions need explicit contracts.
Text, Unicode, UTF-8, and locale
Separate storage units, code points, displayed characters, UTF-8 validation, and locale-dependent conversion.
Dynamic memory and ownership
Connect allocation, initialization, size checks, replacement, and release to a deliberate ownership contract.
Understanding memory mistakes
Diagnose invalid access through lifetime, bounds, type, initialization, and ownership instead of guessing whether code will crash.
Structures: related data
Give related values one record type, then distinguish contained members, pointer links, tags, and object identity.
Structure values and functions
Understand record copying, pointer members, value parameters, returned results, semantic equality, and serialization limits.
Enumerations: named choices
Name states clearly while separating enum types, numeric representations, accepted inputs, and C23 extensions.
Unions and tagged data
Use shared storage for alternatives and maintain a clear contract connecting an explicit tag to the selected payload.
Initializing records and aggregates
Connect braced and designated initialization to typed values, then understand compound literals, lifetimes, and C23 additions.
Padding, alignment, and layout
Separate logical fields from their representation and query layout without guessing portable sizes or bit patterns.
Flexible array members
Build a checked header-plus-payload model with explicit allocation size, logical length, copying, and ownership.
Types, declarations, and data interfaces
Read aliases and qualifiers precisely, validate invariants, and introduce opaque interfaces with explicit lifetime contracts.
Function pointers and callbacks
Pass a choice of behavior through a compatible function pointer, and state the call and lifetime contracts.
Preprocessing: preparing the source
Understand directives, configuration branches, and the difference between selecting source and choosing a runtime path.
Macros: tokens, arguments, and pitfalls
Follow replacement tokens, grouping, repeated evaluation, stringizing, token pasting, and C23 variadic distinctions.
Headers: sharing an interface
Read a self-contained header, understand include guards, and separate shared declarations from program definitions.
Translation units and linkage
Connect separate source contexts through compatible declarations, internal and external linkage, and consistent definitions.
Linking and libraries
Follow object files into an executable, build a small static archive, and distinguish language guarantees from toolchain conventions.
The standard library: facilities and contracts
Choose library families, read buffer and error contracts, and distinguish hosted, freestanding, C17, C23, and platform facilities.
Modular programs: contracts and builds
Design a small score module with a clear invariant, private validation, failure behavior, and correct rebuild dependencies.
Arguments, conversion, and the environment
Check argc and argv bounds, validate numeric text with strtol, and treat environment strings as borrowed external input.
Variadic functions: arguments need an agreement
Understand count and type contracts, default argument promotions, va_list traversal, cleanup, and safer interface choices.
Searching and sorting by a comparison rule
Connect qsort and bsearch to arrays, element sizes, callback contracts, ordering, and duplicate values.
Streams, buffering, and EOF
Understand stream state, standard streams, buffering, read results, and the difference between end-of-file and an error.
Formatted output and format contracts
Match output conversions to argument types, distinguish width from precision, and check bounded formatting and stream failures.
Formatted input: matching and limits
Read scanf destination contracts, assignment counts, field widths, whitespace behavior, and numeric conversion limits.
Lines, boundaries, and checked parsing
Separate input acquisition, complete-record boundaries, text conversion, and application validation.
Opening files, modes, and lifetimes
Choose read, write, append, update, and exclusive-creation modes while managing stream ownership and close failures.
Block I/O, positions, and update streams
Count complete transfer elements, handle partial records, follow update-stream transitions, and interpret file positions carefully.
Errors, status, errno, and assertions
Design clear failure outcomes, respect documented errno contracts, keep validation outside assert, and recognize nonlocal-jump limits.
Ownership, cleanup, and partial work
Follow a checked file copy through acquisition, short transfers, close failures, borrowing, and partial-output limits.
Dates, clocks, and measuring time
Separate calendar time, local display, processor time, elapsed duration, resolution, and C23 clock support.
Behavior, guarantees, and undefined behavior
Separate undefined, unspecified, and documented implementation choices, then justify the preconditions before an operation.
Evaluation order and side effects
Trace full expressions, short-circuit guards, comma operators, function calls, and unsequenced conflicts without guessing an output.
Effective types, aliases, and access
Connect permitted access types, representation copies, allocated storage, alignment, and restrict contracts.
Portability and explicit assumptions
State supported targets, check ranges, encode a defined octet format, and separate C17/C23 guarantees from platform conventions.
Floating-point calculations and mathematical functions
Understand precision, rounding, tolerance policies, math domains, special values, and the difference between C guarantees and observed formats.
Defensive C and security boundaries
Validate sizes and meanings, preserve buffer contracts, keep formats trusted, and understand what hardening can and cannot establish.
External data formats: an agreement about bytes
Design an explicit record format, validate its boundaries and version, and separate serialization from raw object storage.
Threads, atomics, and shared state
Reason about data races, atomic updates, mutex invariants, release/acquire publication, and thread lifetime.
Diagnostics, debugging, and evidence
Build a reproducible case, investigate with the right tools, understand detector limits, and turn repairs into contract-focused checks.
Style, contracts, and code review
Use names, invariants, scope, control flow, guidelines, and review to make program assumptions visible.
C’s timeline: history, editions, and standards
Trace C’s development and published revisions, and distinguish nicknames, dates, drafts, and compiler modes.
Why C looks this way: design and tradeoffs
Connect concise operations, low-level control, portability, efficiency, and explicit program contracts.
C’s influence: languages, runtimes, and interfaces
Separate shared history, familiar syntax, implementation language, and foreign interfaces.
Modern C: C23 features and adoption
Understand C23’s language and library changes, remaining contracts, and feature-by-feature implementation support.
Reading complete programs through their contracts
Connect validation, objects, arithmetic, state changes, and output through two worked C17 programs.
Carry the model forward: review and next steps
Connect the nine units, review your reasoning habits, and choose a useful next learning step.
No chapters match this filter. Try another term.