Compiler
A compiler is software that translates source code into executable code or another representation, while analyzing it according to the source language’s rules.
F# in Action: A Revised Edition of Get Programming with F#
A compiler is a software tool that translates source code into an executable or another lower-level representation while checking it against the language's rules.
- How it is used
- Guides F# domain modeling and code changes by exposing incomplete assignments, missing cases, and type conflicts before execution.
- How deep it goes
- Explains compiler-guided workflow through field additions, optional values, inference diagnostics, invariants, and exhaustive matching rather than compilation internals.
- Examples
- Uses a train domain model, an age-group inference mistake, validated email sending, and instrument pattern matching.
- What you can do after
- Diagnose/debug with it by reading inferred types and first errors, then guiding inference with temporary annotations.
Read how F# in Action: A Revised Edition of Get Programming with F# explains compiler →
Learn Rust in a Month of Lunches
A compiler is a program that translates source code into an executable or another lower-level representation while checking it against the language's rules.
- How it is used
- Checks Rust code before it runs and guides corrections when syntax, types, or mutability cause errors.
- How deep it goes
- Walks through successive errors and a warning, then explains basic type inference; does not examine compiler internals.
- Examples
- Uses a broken String update, successive corrections, an unused-variable warning, and integer type choices.
- What you can do after
- Diagnose/debug with it by following compiler suggestions and distinguishing blocking errors from warnings.
Read how Learn Rust in a Month of Lunches explains compiler →
C# Concurrency: Asynchronous and multithreaded programming
A compiler is a program that translates source code into another representation, such as executable code or an intermediate form.
- How it is used
- Explains how C# provides inline functions, iterators, and asynchronous control flow on a method-based .NET runtime.
- How deep it goes
- Explains generated methods, closure classes, resumable chunks, continuations, and exception handling; detailed async mechanics are developed separately.
- Examples
- Uses timer callbacks, captured local variables, iterator state, asynchronous file reads, and event-handler exception behavior.
- What you can do after
- Evaluate/understand generated control flow to write, debug, and reason about C# lambdas, iterators, asynchronous methods, and exceptions.
Read how C# Concurrency: Asynchronous and multithreaded programming explains compiler →
Refactoring to Rust
A compiler is a program that translates source code into executable or lower-level code while performing analyses such as type checking.
- How it is used
- Enforces ownership, lifetimes, memory safety, and static types before Rust programs execute.
- How deep it goes
- Explains ownership, borrowing, lifetimes, and type inference through examples, while deferring fuller ownership treatment.
- Examples
- Uses Cargo commands, an art-museum program, moved artwork values, and inferred versus explicit map types.
- What you can do after
- Diagnose/debug with it by interpreting ownership, moved-value, lifetime, and type errors before execution.
Rust in Action: Systems programming concepts and techniques
A compiler is a program that translates source code into executable or lower-level code while checking it against the language's rules.
- How it is used
- Turns a Rust source file into a runnable program and checks it before execution.
- How deep it goes
- Explains the compiler’s job and walks through single-file compilation, without detailing its internal stages.
- Examples
- Demonstrates rustc ok.rs followed by running ./ok, and contrasts Cargo development and release runs.
- What you can do after
- Apply it via rustc to compile a single Rust file and run its executable.
Read how Rust in Action: Systems programming concepts and techniques explains compiler →
Modern C, Third Edition
A compiler implementation is the concrete software realization of a compiler that translates source programs according to a language's rules.
- How it is used
- Translates C source into platform-specific executable code and mediates between programmer instructions and computer architectures.
- How deep it goes
- Defines translation, platform dependence, diagnostics, and portability but defers the internal mechanics of compilation.
- Examples
- Uses GCC and Clang diagnostics, compilation commands, and a flawed C program corrected through successive recompilation.
- What you can do after
- Operate a C compiler, compile source files, interpret diagnostics, and iteratively repair programs toward portability.
Modern C
A compiler is a program that translates source code in a programming language into a form suitable for execution on a target platform.
- How it is used
- Compiles C source into executable code and flags potential correctness or portability problems.
- How deep it goes
- Defines translation, linking, and platform dependence but defers the internal mechanics of compilation.
- Examples
- Uses c99, clang, gcc, and icc commands plus diagnostics from a flawed C program.
- What you can do after
- Operate/configure a C compiler to build programs, inspect warnings, and avoid treating one platform’s success as portability proof.
.NET in Action, Second Edition
A compiler is a program that translates source code in a programming language into another executable or intermediate representation.
- How it is used
- Translates high-level .NET languages into CIL so applications can execute across operating systems and processor architectures.
- How deep it goes
- Explains translation, CIL portability, DLL output, JIT behavior, and AOT trade-offs without detailing compiler implementation internals.
- Examples
- Uses C#, F#, Visual Basic, CIL DLLs, processor architectures, JIT compilation, and AOT compilation as concrete examples.
- What you can do after
- Evaluate how .NET code moves from source language through CIL and runtime compilation to processor-specific machine code.
Code Like a Pro in Rust
rustc is the official Rust compiler that translates Rust source code into executable or library artifacts and reports compile-time errors.
- How it is used
- Separates compile-time guarantees from behavior that still needs unit testing.
- How deep it goes
- Identifies rustc and its LLVM foundation, then explains type and reference checks without detailing compiler internals.
- Examples
- Contrasts strings with integers and compiler-checked references with logic that needs tests.
- What you can do after
- Evaluate/understand which checks the compiler already provides and where to focus unit tests.
Related concepts
- Cargoused by · Cargo is Rust’s package manager and build system for managing projects, dependencies, compilation, testing, and related workflows.
- TinyGoincludes · TinyGo is a Go compiler designed to produce small binaries for resource-constrained targets such as microcontrollers, embedded systems, and WebAssembly.
- borrow checkerhas part · A borrow checker is a compile-time mechanism that verifies ownership, borrowing, and reference rules to prevent invalid memory access.
- Svelteincludes · Svelte is an open-source web user-interface framework that compiles declarative component code into JavaScript for browser execution.
- machine languageproduces · Machine language is a processor-specific instruction language encoded in a form that computer hardware can execute directly.
- applicationproduces · An application is a software program or system that performs tasks or provides functionality for users or other software systems.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.