Site index

Every section, subsection and indexed language in this atlas, in one alphabetical list. This page is generated from the built pages themselves, so it cannot fall out of step with them.

There is no search box here. The site loads no JavaScript and its Content-Security-Policy forbids it, so this index plus the browser’s own find-in-page does the same job without shipping a runtime. Use Ctrl+F, or ⌘+F on macOS.

#¶

Entry	Kind	Page
<complex.h> under Annex G	section	Complex arithmetic

1 entries beginning with #.

A¶

Entry	Kind	Page
A digression that turns out to be the point	subsection	Retrieval
Access control	subsection	Swift
Actors	subsection	Swift
Ada	language, 1980	Language record
ALGOL 60	language, 1960	Language record
API design guidelines	section	Swift reference
APL	language, 1962	Language record
Architecture decision guide	section	C ecosystem
Architecture decision guide	section	Rust
Array and statistical	section	Languages
Assembly, dispatch, and hardware frames	subsection	C ecosystem
Assignment: a scan, or a map	section	Calling conventions
Asynchronous functions	subsection	Swift
At a glance	section	Overview
Atomics and a lock-free queue	section	Concurrency
Attribute reference	section	Swift reference

16 entries beginning with A.

B¶

Entry	Kind	Page
BASIC	language, 1964	Language record
Basic syntax	subsection	Swift
Branch cuts and the sign of zero	section	Complex arithmetic
Build, test, lint, and documentation commands	section	Rust reference

4 entries beginning with B.

C¶

Entry	Kind	Page
C	language, 1972	Language record
C family	section	Languages
C#	language, 2000	Language record
C++	language, 1985	Language record
C23: the current standard	section	C
cacos	subsection	Complex arithmetic
cacosh	subsection	Complex arithmetic
Callable objects	subsection	Swift
Capacity as a vector against a scalar	subsection	Calling conventions
Cargo and rustc build architecture	section	Rust
casinh	subsection	Complex arithmetic
catanh	subsection	Complex arithmetic
Caveats	section	Comparison
ccosh	subsection	Complex arithmetic
cexp	subsection	Complex arithmetic
Choosing	section	Concurrency
Classification as a join over a chain	section	Calling conventions
Classification axes	section	Overview
clog	subsection	Complex arithmetic
Clojure	language, 2007	Language record
Closures	subsection	Swift
COBOL	language, 1959	Language record
Comparisons to other languages	section	Swift
Compilation and code generation	section	Swift reference
Compilers, libraries, and tooling	section	C
Complete index	section	Languages
Component and relationship register	section	C ecosystem
Component and relationship register	section	Rust
Components	subsection	C ecosystem
Components	subsection	Rust
Concurrency	section	Comparison
Concurrency and data-race safety	section	Swift
Concurrency models	section	Paradigms
Condition variables: the loop is not optional	section	Concurrency
Contexts, subsystems, and drivers	subsection	C ecosystem
Convergence	section	Paradigms
Conversion specifiers	section	C reference
csinh	subsection	Complex arithmetic
csqrt	subsection	Complex arithmetic
ctanh	subsection	Complex arithmetic
Current direction and durable role	section	C ecosystem
CX_LIMITED_RANGE and FP_CONTRACT	section	Complex arithmetic

42 entries beginning with C.

D¶

Entry	Kind	Page
Dart	language, 2011	Language record
Data isolation	subsection	Swift
Deadlock, and the three ways out	section	Concurrency
Debugging and diagnostics	section	Swift
Declaration modifiers	section	Swift reference
Declaration, definition, and where each belongs	subsection	C
Dependencies, features, and resolution	section	Rust reference
Deployment consequences	section	Memory & runtime
Development and other implementations	section	Swift
Dialects, subsets, and freestanding C	section	C
Division: scaling the denominator	section	Complex arithmetic
Documentation comments and DocC	section	Swift reference
Drones and autonomous vehicles	section	C ecosystem
Dynamic scripting	section	Languages

14 entries beginning with D.

E¶

Entry	Kind	Page
Elixir	language, 2012	Language record
Embedded and real-time architecture	section	C ecosystem
Entries by decade	section	Timeline
Erlang	language, 1986	Language record
Error handling and typed throws	subsection	Swift
Evolution, governance, and limits	section	Rust
Exceptions and unspecified signs	subsection	Complex arithmetic
Exclusive access to memory	subsection	Swift
Execution models	section	Memory & runtime
Extensions	subsection	Swift

10 entries beginning with E.

F¶

Entry	Kind	Page
F#	language, 2005	Language record
False sharing: the contention you did not write	section	Concurrency
FFmpeg and multimedia dataflow	section	C ecosystem
Finding the term: six layouts of one key set	section	Retrieval
Flow and process	section	Visual system
Fortran	language, 1957	Language record
Full ecosystem context map	section	C ecosystem
Full system context map	section	Rust
Function pointers and indirect calls	subsection	C
Functions: the unit of code	section	C
Future outlook	section	C
Futures	section	Visual system

12 entries beginning with F.

G¶

Entry	Kind	Page
Generics, opaque types, and existentials	subsection	Swift
Gleam	language, 2019	Language record
Go	language, 2009	Language record

3 entries beginning with G.

H¶

Entry	Kind	Page
Hare	language, 2022	Language record
Haskell	language, 1990	Language record
History	section	Swift
History: from Unix tool to systems substrate	section	C ecosystem
How memory got its levels	section	Retrieval
How retrieval got its index	section	Retrieval
How these numbers were produced	section	Retrieval
How this reached the standard	section	Complex arithmetic
How to read an entry	section	Overview

9 entries beginning with H.

I¶

Entry	Kind	Page
Identities and symmetry	section	Complex arithmetic
Inspection and assurance workflow	section	Rust reference
Interoperability and tooling	section	Comparison
Intersecting the lists: five representations	section	Retrieval

4 entries beginning with I.

J¶

Entry	Kind	Page
Java	language, 1995	Language record
JavaScript	language, 1995	Language record
Julia	language, 2012	Language record

3 entries beginning with J.

K¶

Entry	Kind	Page
Kconfig and kbuild	subsection	C ecosystem
Keywords by revision	section	C reference
Kotlin	language, 2011	Language record

3 entries beginning with K.

L¶

Entry	Kind	Page
Language families	section	Overview
Language features	section	Comparison
Language features	section	Swift
Language modes and feature tests	section	C reference
Linux kernel architecture	section	C ecosystem
Lisp	language, 1958	Language record
Lisp family	section	Languages
Logic and declarative	section	Languages
Longevity	section	Timeline
Lua	language, 1993	Language record

10 entries beginning with L.

M¶

Entry	Kind	Page
Macros	subsection	Swift
Managed runtimes	section	Languages
Manifest and workspace keys	section	Rust reference
Memory management	section	Swift
Memory management models	section	Memory & runtime
Memory safety and trust boundaries	section	C ecosystem
Memory, interrupts, and devices	subsection	C ecosystem
Migrating to the Swift 6 language mode	subsection	Swift
Military, avionics, and high assurance	section	C ecosystem
ML	language, 1973	Language record
ML and functional	section	Languages
Mojo	language, 2023	Language record
Motion system	section	Visual system
Multiplication: recovering the infinities	section	Complex arithmetic

14 entries beginning with M.

N¶

Entry	Kind	Page
Nullability as a type-system decision	section	Type systems

1 entries beginning with N.

O¶

Entry	Kind	Page
Objective-C	language, 1984	Language record
Objects, storage, and representation	section	C
OCaml	language, 1996	Language record
One history, told twice	section	Retrieval
One regime that fits, and one that will not hold still	subsection	Calling conventions
One syntax, several contracts	section	C ecosystem
Operators and precedence	section	C reference
Operators and precedence	section	Swift reference
Optionals and chaining	subsection	Swift
Origins and the low-level bargain	section	C
Ownership, borrowing, and noncopyable types	subsection	Swift
Ownership, borrowing, and resource lifetime	section	Rust

12 entries beginning with O.

P¶

Entry	Kind	Page
Paradigm groups	section	Paradigms
Parameters, arguments, and the binding between them	section	Calling conventions
Partitioning and open interfaces	subsection	C ecosystem
Pascal	language, 1970	Language record
Passing parameters	subsection	C
Period detail	section	Timeline
Periods	section	Timeline
Perl	language, 1987	Language record
PHP	language, 1995	Language record
Platforms and support tiers	section	Swift
Pointers, arrays, and provenance	section	C
Preprocessor directives and predefined macros	section	C reference
Principles	section	Visual system
Profiles, artifacts, and reproducibility	section	Rust reference
Project anatomy	section	Rust reference
Prolog	language, 1972	Language record
Property wrappers and result builders	subsection	Swift
Protocol-oriented programming	subsection	Swift
Publication and compatibility	section	Rust reference
Python	language, 1991	Language record

20 entries beginning with P.

Q¶

Entry	Kind	Page
Quantitative charts	section	Visual system

1 entries beginning with Q.

R¶

Entry	Kind	Page
R	language, 1993	Language record
Racket	language, 1995	Language record
Reader-writer locks and where they stop paying	section	Concurrency
Reading a declaration	section	C reference
Reading the crossovers	section	Retrieval
Real-time design	subsection	C ecosystem
Recursion and the stack	subsection	C
Reference cycles	section	Memory & runtime
References and sources	section	C
References and sources	section	Swift
Relationships	subsection	C ecosystem
Relationships	subsection	Rust
Release model and language modes	section	Swift
Representative ecosystem layers	section	Rust
Representative languages by axis	section	Overview
Reproducing this page	section	Calling conventions
Reproducing this page	section	Concurrency
Return types and parameter lists	subsection	C
Returning	subsection	C
Robotics and deterministic middleware	section	C ecosystem
Ruby	language, 1995	Language record
Runtime and deployment shapes	section	Rust
Runtime, libraries, and interoperability	section	Swift
Rust	language, 2010	Language record

24 entries beginning with R.

S¶

Entry	Kind	Page
Sanitizers and hardening flags	section	C reference
Scala	language, 2004	Language record
Scheme	language, 1975	Language record
Scope and deep-review findings	section	C ecosystem
Scope and method	section	Overview
Scope and review findings	section	Rust
Self	language, 1987	Language record
Sendable and crossing boundaries	subsection	Swift
Simula 67	language, 1967	Language record
Smalltalk-80	language, 1980	Language record
Source is not the final artifact	subsection	C ecosystem
Source-to-silicon toolchain	section	C ecosystem
Sources	section	C ecosystem
Sources	section	C reference
Sources	subsection	Calling conventions
Sources	section	Complex arithmetic
Sources	section	Concurrency
Sources	section	Retrieval
Sources	section	Rust reference
Sources	section	Rust
Sources	section	Swift reference
SQL	language, 1974	Language record
Standard headers by revision	section	C reference
Standard library map	section	C reference
Standard library map	section	Swift reference
Start reading	section	Overview
Strings, Unicode, and regex	subsection	Swift
Structural diagrams	section	Visual system
Supply-chain and execution boundaries	section	Rust
Swift	language, 2014	Language record
Swift Evolution	section	Swift reference
Swift Package Manager	section	Swift reference
Systems and ownership	section	Languages

33 entries beginning with S.

T¶

Entry	Kind	Page
Targets, no_std, linking, and FFI	section	Rust reference
Tasks, task groups, and cancellation	subsection	Swift
Testing	section	Swift reference
The ABI layer, where the language stops	section	C
The abstract machine	section	C
The anatomy of an inverted index	section	Retrieval
The C and assembly boundary	section	C ecosystem
The hierarchy, measured	section	Retrieval
The infinity properties	section	Complex arithmetic
The language architecture	section	Rust
The main actor and global actors	subsection	Swift
The memory model since C11	section	C
The Microsoft size predicate	subsection	Calling conventions
The operator formula tables	section	Complex arithmetic
The primitives, and what separates them	section	Concurrency
The reference implementation	subsection	Complex arithmetic
The shape of the record	section	Timeline
The special-value catalogue	section	Complex arithmetic
The standard lineage	section	C
The symmetry reduction	subsection	Complex arithmetic
The tree C produced	section	C
The type algebra of the operators	section	Complex arithmetic
The type system	subsection	Swift
The unit of transfer is a line	section	Retrieval
The wall since 1995, and the next one	section	Retrieval
Threads, async, and cancellation	section	Rust
Three separate questions	section	Type systems
Three types, one plane	section	Complex arithmetic
Toolchain and command line	section	C reference
Toolchain and command line	section	Swift reference
Toolchains, channels, and components	section	Rust reference
Translation phases and linkage	section	C
Trends	section	C
Two articles, one cost model	section	Retrieval
Type-generic macros and imaginary arguments	section	Complex arithmetic
Type-system matrix	section	Type systems
Types, limits, and fixed-width integers	section	C reference
Types, traits, errors, and dispatch	section	Rust
TypeScript	language, 2012	Language record

39 entries beginning with T.

U¶

Entry	Kind	Page
Undefined behaviour: the common cases	section	C reference
Undefined, unspecified, implementation-defined	section	C
Unison	language, 2020	Language record
Unsafe APIs	subsection	Swift
Unsafe Rust and foreign boundaries	section	Rust
Untrusted media and temporal correctness	subsection	C ecosystem
Use-case architecture register	section	C ecosystem

7 entries beginning with U.

V¶

Entry	Kind	Page
Value types and copy-on-write	subsection	Swift
Variadic functions	subsection	C
Version history	section	Swift

3 entries beginning with V.

W¶

Entry	Kind	Page
What C says about memory, and what it does not	section	Retrieval
What each one costs, measured	section	Concurrency
What has moved	section	Comparison
What is not claimed	subsection	Retrieval
What the catalogue adds up to	section	Complex arithmetic
What the copy costs	section	Calling conventions
What the language gives you	subsection	Retrieval
What the language guarantees, and what it does not	section	Concurrency
What the language withholds	subsection	Retrieval
What the tables cost in real operations	section	Complex arithmetic
What the textbook examples leave out	section	Concurrency
Where C actually runs	section	C
Where this meets the rest of the atlas	section	Calling conventions
Which wall you hit: cache, or TLB	section	Retrieval
Why the obvious benchmark measures nothing	subsection	Calling conventions
Workspace, package, crate, and module model	section	Rust

16 entries beginning with W.

Z¶

Entry	Kind	Page
Zig	language, 2016	Language record

1 entries beginning with Z.