liveBook · Manning

Compiler

A compiler is software that translates source code into another representation, such as machine code, bytecode, or an intermediate form.

How 9 Manning books explain it

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# development by checking domain-model changes and type-enforced rules before the application runs.
How deep it goes
Works through unexpected type inference and type-enforced prerequisites, but does not describe compiler implementation.
Examples
Uses a train domain model, a mistaken age comparison, and a validated-email function to make compiler feedback concrete.
What you can do after
Diagnose/debug with it by inspecting inferred types and adding temporary annotations; use types to enforce function prerequisites.

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
Uses compiler feedback to guide corrections before running code and to support changes to existing code.
How deep it goes
Walks through diagnostics and type inference without detailing compiler internals.
Examples
Uses a String correction exercise, an unused-variable warning, and integer type annotations.
What you can do after
Diagnose and debug Rust code using compiler suggestions in the Rust Playground.

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.

Read how Refactoring to Rust explains compiler →

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
Introduces rustc as the tool that turns Rust source files into runnable programs.
How deep it goes
Explains compilation, strict checks, type hints, and optimization at a practical level without detailing compiler internals.
Examples
Uses a single-file program that prints OK and a CSV-processing program with an inferred vector element type.
What you can do after
Operate the Rust compiler on a single source file and run the resulting 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.

Read how Modern C, Third Edition explains compiler →

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.

Read how Modern C explains compiler →

.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.

Read how .NET in Action, Second Edition explains compiler →

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
Uses compiler guarantees to focus Rust testing on program logic rather than type and reference validation.
How deep it goes
Explains compile-time type and reference checks and their testing implications without detailing compiler internals.
Examples
Contrasts integer and string checks with testing logic for potentially failing type conversions.
What you can do after
Evaluate testing needs by distinguishing compiler-checked properties from logic that still requires tests.

Read how Code Like a Pro in Rust explains compiler →

Also covered in

What to know first

Related concepts

Questions about compiler

What is compiler?

A compiler is software that translates source code into another representation, such as machine code, bytecode, or an intermediate form.

Which Manning books explain compiler?

F# in Action: A Revised Edition of Get Programming with F#, Learn Rust in a Month of Lunches, C# Concurrency: Asynchronous and multithreaded programming, Refactoring to Rust, Rust in Action: Systems programming concepts and techniques, Modern C, Third Edition, Modern C, .NET in Action, Second Edition and 1 more.

What should I know before learning compiler?

Manning books that teach compiler usually introduce Python, assembly language, application and source file first.

What kinds of compiler are there?

Kinds of compiler include TinyGo.

What are the parts of compiler?

Compiler includes borrow checker.

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.