Software Engineering Atlas

A navigable knowledge map of software engineering — ideas, authors, works, languages, paradigms, architecture, and practices.

📖 Website: akardapolov.github.io/software-atlas

What is this?

Software Engineering Atlas is a structured, interconnected reference on how software development thinking evolved — from lambda calculus (1936) to modern distributed systems and DevOps practices.

It is not a textbook. It is a navigable map:

Authors — who shaped the field, with biography cards
Works — papers, books, and talks that became canon
Languages — programming languages as embodiments of ideas
Topics — paradigms, architecture, design, types, FP, testing, delivery, distributed systems, developer tools, large language models
Examples — runnable, comparable code in multiple languages
Maps — visual diagrams showing how everything connects
Reading paths — guided sequences for deep dives

The Atlas Approach

Software Engineering Atlas is organized as a connected map of software ideas.

Instead of treating software knowledge as a single linear curriculum or a fixed taxonomy, the atlas shows how concepts relate to each other across time, context, and practice.

The goal is practical: to help readers move between:

origins and predecessors
related ideas and parallel developments
concrete embodiments in languages, tools, and styles
trade-offs and design choices
historical context and later refinements

In this view, a topic is often easier to understand when you can see not only what it is, but also:

where it came from
what it reacted to
what it influenced
how it was applied in practice
which neighboring ideas solve similar problems differently

Software knowledge in the atlas is therefore treated as a graph of connected entities, not as a single hierarchy.

What counts as an entity

The atlas includes a small set of entity types:

ideas — concepts, principles, patterns, and models
authors — people who introduced, refined, or popularized ideas
works — papers, books, and talks
languages — programming languages as concrete embodiments of ideas
practices — methods, workflows, and engineering habits

Typical relationships

Common relationship types include:

influenced by
extended by
contrasts with
implemented in
popularized by
applied in
historically preceded by

These links are meant to support navigation and comparison.
Some are strong and well documented; others are editorial and meant as helpful context rather than strict historical claims.

Inclusion policy

The atlas is selective, not exhaustive.

An item is usually included when it:

introduced a new conceptual model,
formalized an existing idea,
embodied an idea in a language or tool,
or significantly popularized it in practice.

This means the atlas is curated. It reflects editorial judgment, and not every connection is treated as equally strong or equally important.

What the atlas is for

The atlas is meant to support:

exploration
comparison
historical understanding
cross-linking between theory and practice
guided reading paths

It is not meant to replace textbooks, primary sources, or careful study.
It is a map for orientation, not a complete theory of software development.

Overview map

The main lineage graph. Four subgraphs represent the primary tracks of the atlas — not strictly disjoint domains, but convenient lenses for navigation. Dotted edges mark cross-track connections.

For a more detailed version with 7 tracks and type annotations see Detailed overview.

%%{init: {'theme': 'default', 'themeVariables': {'fontSize': '15px'}}}%%
flowchart LR

  subgraph A["🏗 Architecture · Modularity"]
    Conway["Conway · 1967<br/>Conway's Law"]
    Dijkstra["Dijkstra · 1968<br/>Structured Programming"]
    Parnas["Parnas · 1972<br/>Information Hiding"]
    Brooks["Brooks · 1975–86<br/>MMM · No Silver Bullet"]
    Shaw["Shaw & Garlan · 1996<br/>SW Architecture"]
    Bass["Bass et al. · 1998<br/>Arch in Practice"]
    Evans["Evans · 2003<br/>DDD"]
    Cockburn["Cockburn · 2005<br/>Hexagonal"]
    Newman["Newman · 2015<br/>Microservices"]
    Brown["Simon Brown · 2011+<br/>C4 Model"]
    Skelton["Skelton & Pais · 2019<br/>Team Topologies"]

    Dijkstra --> Parnas
    Parnas --> Brooks
    Parnas --> Shaw
    Shaw --> Bass
    Bass --> Cockburn
    Evans --> Newman
    Bass --> Brown
    Conway --> Skelton
  end

  subgraph B["🧩 OOP · Design · Types · FP · Logic"]
    Church["Church · 1936<br/>Lambda Calculus"]
    McCarthy["McCarthy · 1958<br/>Lisp"]
    Simula["Dahl & Nygaard · 1967<br/>Simula"]
    Kay["Alan Kay · 1972<br/>Smalltalk"]
    Colmerauer["Colmerauer · 1972<br/>Prolog"]
    Liskov["Liskov · 1974–94<br/>ADT · LSP"]
    Hewitt["Hewitt · 1973<br/>Actor Model"]
    Hoare["Hoare · 1978<br/>CSP"]
    Milner["Milner · 1978<br/>ML · HM types"]
    Backus["Backus · 1978<br/>FP manifesto"]
    Meyer["Meyer · 1988<br/>DbC · CQS"]
    Hughes["Hughes · 1989<br/>Why FP Matters"]
    GoF["GoF · 1994<br/>Design Patterns"]
    Fowler["Fowler · 1999<br/>Refactoring"]
    Martin["R.C. Martin · 2003<br/>SOLID"]
    Armstrong["Armstrong · 2003<br/>Erlang thesis"]
    Hickey["Hickey · 2007+<br/>Clojure · Simple Made Easy"]
    Bernhardt["Bernhardt · 2012<br/>FC / IS"]
    Wlaschin["Wlaschin · 2018<br/>Domain Modeling FP"]

    Church --> McCarthy
    Church --> Milner
    Church --> Backus
    Church --> Colmerauer
    Simula --> Kay
    Kay --> GoF
    Liskov --> Martin
    Meyer --> Martin
    GoF --> Fowler
    Backus --> Hughes
    Hughes --> Hickey
    Milner --> Wlaschin
    Hickey --> Bernhardt
    Hewitt --> Armstrong
    Kay --> Armstrong
    Colmerauer --> Armstrong
  end

  subgraph C["🧪 Process · Testing · Delivery"]
    NATO68["NATO conf. · 1968<br/>Software Engineering"]
    Deming["Deming · 1982<br/>Systems thinking"]
    Beck["Kent Beck · 1999–2002<br/>XP · TDD"]
    Agile["Agile Manifesto · 2001"]
    Feathers["Feathers · 2004<br/>Legacy Code"]
    CD["Humble & Farley · 2010<br/>Continuous Delivery"]
    Forsgren["Forsgren et al. · 2018<br/>Accelerate · DORA"]

    NATO68 -.-> Beck
    Deming --> Beck
    Beck --> Agile
    Beck --> Feathers
    Agile --> CD
    CD --> Forsgren
  end

  subgraph D["🌐 Distributed Systems"]
    Lamport["Lamport · 1978–89<br/>Clocks · ByzGen · Paxos"]
    Gray["Jim Gray · 1981<br/>Transactions · ACID"]
    Brewer["Brewer · 2000<br/>CAP conjecture"]
    Helland["Helland · 2007<br/>Life Beyond DT"]
    Kleppmann["Kleppmann · 2017<br/>DDIA"]

    Lamport --> Brewer
    Gray --> Brewer
    Brewer --> Helland
    Helland --> Kleppmann
  end

  subgraph E["🤖 Large Language Models"]
    Vaswani["Vaswani · 2017<br/>Attention Is All You Need"]
    Kaplan["Kaplan · 2020<br/>Scaling Laws"]
    GPT3["Brown · 2020<br/>GPT-3"]
    Instruct["Ouyang · 2022<br/>InstructGPT"]
    CoT["Wei · 2022<br/>Chain-of-Thought"]
    ReAct["Yao · 2022<br/>ReAct"]

    Vaswani --> Kaplan --> GPT3 --> Instruct
    GPT3 --> CoT --> ReAct
    Instruct -.-> ReAct
  end

  Parnas -. "modularity" .-> Martin
  Parnas -. "modularity" .-> Evans
  Evans -. "DDD + FP" .-> Wlaschin
  Hoare -. "concurrency" .-> Armstrong

  style A fill:#dbeafe,stroke:#3b82f6,stroke-width:2px
  style B fill:#fef9c3,stroke:#eab308,stroke-width:2px
  style C fill:#dcfce7,stroke:#22c55e,stroke-width:2px
  style D fill:#f3e8ff,stroke:#a855f7,stroke-width:2px
  style E fill:#fecaca,stroke:#ef4444,stroke-width:2px

  classDef arch fill:#93c5fd,stroke:#2563eb,color:#1e3a5f,font-weight:bold
  classDef design fill:#fde68a,stroke:#ca8a04,color:#713f12,font-weight:bold
  classDef process fill:#86efac,stroke:#16a34a,color:#14532d,font-weight:bold
  classDef dist fill:#d8b4fe,stroke:#9333ea,color:#581c87,font-weight:bold
  classDef llm fill:#fca5a5,stroke:#dc2626,color:#7f1d1d,font-weight:bold

  class Conway,Dijkstra,Parnas,Brooks,Shaw,Bass,Evans,Cockburn,Newman,Brown,Skelton arch
  class Church,McCarthy,Simula,Kay,Colmerauer,Liskov,Hewitt,Hoare,Milner,Backus,Meyer,Hughes,GoF,Fowler,Martin,Armstrong,Hickey,Bernhardt,Wlaschin design
  class NATO68,Deming,Beck,Agile,Feathers,CD,Forsgren process
  class Lamport,Gray,Brewer,Helland,Kleppmann dist
  class Vaswani,Kaplan,GPT3,Instruct,CoT,ReAct llm

Overview timeline: Major lineages × era

timeline
    title Overview · Major lineages × era

    section 1936–1967 · Foundations
        FP                        : λ-calculus (Church 1936)
                                  : Lisp (McCarthy 1958)
        OOP                       : Simula (Dahl & Nygaard 1967)
        Architecture              : Conway's Law (1967)

    section 1968–1989 · Formalization
        Process                   : NATO conference — software engineering (1968)
                                  : Royce — phased lifecycle (1970)
        Architecture              : Information Hiding (Parnas 1972)
                                  : Mythical Man-Month (Brooks 1975)
        OOP                       : Smalltalk (Kay 1972)
                                  : Design by Contract (Meyer 1988)
        Types                     : Abstract Data Types (Liskov 1974)
                                  : ML / Hindley–Milner (Milner 1978)
                                  : LSP introduced (Liskov 1987)
        FP                        : FP Manifesto (Backus 1978)
                                  : Why FP Matters (Hughes 1989)
        Concurrency               : Actor Model (Hewitt 1973)
                                  : CSP (Hoare 1978)
                                  : Erlang (Armstrong 1986)
        Logic                     : Prolog (Colmerauer 1972)
        Distributed               : Logical Clocks (Lamport 1978)
                                  : Byzantine Generals (Lamport et al. 1982)
                                  : ACID (Gray 1983)

    section 1990–2005 · Consolidation
        FP                        : Haskell 1.0 (1990)
        Types                     : LSP formalized (Liskov & Wing 1994)
        OOP                       : Design Patterns (GoF 1994)
                                  : Refactoring (Fowler 1999)
                                  : SOLID principles (Martin, 1990s–2000s)
        Architecture              : Shaw & Garlan / Bass et al. (1996 / 1998)
                                  : DDD (Evans 2003)
                                  : Hexagonal Architecture (Cockburn 2005)
        Process                   : Scrum (Schwaber & Sutherland 1995)
                                  : XP / TDD (Beck 1999 / 2002)
                                  : Agile Manifesto (2001)
        Distributed               : Paxos (Lamport 1989; published 1998)
                                  : CAP conjecture (Brewer 2000; formalized 2002)

    section 2006–present · Scaling & operations
        FP                        : Clojure (Hickey 2007)
        Types                     : Ownership / affine types (Rust 2010)
        Architecture              : Microservices (~2011–2015)
                                  : C4 Model (Brown 2011+)
                                  : Team Topologies (Skelton & Pais 2019)
        Process                   : DevOps movement (2009)
                                  : Continuous Delivery (Humble & Farley 2010)
                                  : SRE / DORA (2016 / 2018)
        Concurrency               : Go / channels (2009)
        Distributed               : Dynamo / cloud era (Amazon 2007)
                                  : CRDTs (Shapiro et al. 2011)
                                  : Raft (Ongaro & Ousterhout 2014)

🔍 Detailed maps: Detailed overview · Master timeline · Ideas evolution · Languages genealogy · Paradigms · Architecture · Concurrency · Process · Containers · Databases

Topics

🧠 Concepts

Fundamental ideas and abstractions that shape how we think about software.

#	Topic	Key ideas	Details
1	Paradigms	Imperative↔Declarative, Procedural/OOP/FP/Logic, Sequential/Concurrent	How we think about computation
2	Concurrency	Threads, CSP, Actors, async/await	How we handle parallelism
3	Type Systems	Static/dynamic, nominal/structural, ADTs, generics	How types help us reason
4	Functional Programming	Purity, immutability, composition, monads	How we avoid accidental complexity

🏗 Architecture & Structure

#	Topic	Key ideas	Details
5	Architecture & Modularity	Layered, Hexagonal, DDD, Microservices, C4	How we structure systems

🎨 Design

#	Topic	Key ideas	Details
6	OOP & Design	SOLID, GoF patterns, Refactoring	How we design components

⚙️ Engineering

Verifiable principles for building and operating software systems.

#	Topic	Key ideas	Details
7	Testing	TDD, Pyramid, PBT, BDD, mutation, fuzzing, contracts	How we verify code behavior
8	Verifiable Engineering	Three questions, falsifiability, system vs event	How we know what we claim

🌐 Systems & Data

#	Topic	Key ideas	Details
9	Distributed Systems	Clocks, CAP, consensus, consistency, streaming	How we scale across machines
10	Databases	Relational model, transactions, NoSQL, OLTP/OLAP, indexing	How we store and query data

🧪 Process & Methodologies

How teams organize to build software.

#	Topic	Key ideas	Details
11	Process	Agile, XP, Scrum, Kanban, DevOps, SRE	How we organize work

🛠 Tools

The instruments we use to build, deploy, and operate software.

#	Topic	Key ideas	Details
12	Build Systems	Make, Maven, Gradle, Bazel, npm, Cargo	How we turn source into artifacts
13	Containers & Orchestration	Docker, Podman, Kubernetes, OCI, runtimes	How we package and run workloads
14	Developer Tools	IDE, HTTP clients, terminal, debuggers	Tools developers use every day
15	Version Control	RCS → CVS → SVN → Git, branching strategies, monorepos	How we manage change over time

🤖 Machine Learning & LLMs

#	Topic	Key ideas	Details
16	Large Language Models	Transformers, prompting, RAG, agents, evaluation, safety	How we build and integrate LLM systems

Languages

Language	Year	Creator(s)	Style / model	Typing	Page	Examples
Fortran	1957	John Backus (IBM)	Imperative, array-oriented	Static	→	—
Lisp	1958	John McCarthy	Functional, symbolic	Dynamic	→	→
ALGOL	1960	International committee	Imperative, structured	Static	→	—
BASIC	1964	Kemeny, Kurtz	Imperative	Weak / dynamic	→	—
Simula	1967	Dahl, Nygaard	OOP	Static	→	—
Smalltalk	1972	Alan Kay et al.	OOP, message passing	Dynamic	→	—
C	1972	Dennis Ritchie	Imperative, procedural	Static, weak	→	→
ML	1978	Robin Milner	Functional	Static, inferred	→	—
Ada	1983	Jean Ichbiah et al.	Multi-paradigm, concurrent	Static, strong	→	—
Erlang	1986	Joe Armstrong	Functional, concurrent	Dynamic	→	→
Haskell	1990	Committee	Functional, pure	Static, inferred	→	→
Python	1991	Guido van Rossum	Multi-paradigm	Dynamic, strong	→	→
Java	1995	James Gosling	OOP, imperative	Static, nominal	→	→
Clojure	2007	Rich Hickey	Functional, Lisp	Dynamic, strong	→	→
Go	2009	Pike, Thompson, Griesemer	Imperative, concurrent (CSP)	Static, structural	→	→
Rust	2010	Graydon Hoare	Multi-paradigm	Static, affine	→	→
Kotlin	2011	JetBrains (Breslav)	Multi-paradigm, concurrent	Static, inferred	→	—
TypeScript	2012	Anders Hejlsberg	Multi-paradigm	Static, structural	→	→

📊 Visual: Language genealogy map

Authors

Author	Years	Known for	Related	Page
Alan Turing	1912–1954	Turing machine, computability	Foundations	→
Alonzo Church	1903–1995	Lambda calculus	FP, types	→
John McCarthy	1927–2011	Lisp, AI	FP, Lisp	→
Ole-Johan Dahl	1931–2002	Simula, OOP	OOP	→
Kristen Nygaard	1926–2002	Simula, OOP	OOP	→
Ivan Sutherland	1938–	Sketchpad, computer graphics	GUI, OOP	→
Christopher Alexander	1936–2022	Pattern language, architecture	Design patterns	→
Dan Ingalls	1944–	Smalltalk, design principles	Smalltalk, design	→
Edsger Dijkstra	1930–2002	Structured programming	Architecture	→
David Maciver	1960–	QuickCheck, property testing	FP, testing	→
David Parnas	1941–	Information hiding, modularity	Architecture	→
Meir Lehman	1942–	Lehman's laws, software evolution	Process	→
Barbara Liskov	1939–	CLU, ADT, LSP	Types, OOP	→
Bjarne Stroustrup	1950–	C++, language design	C++, OOP	→
Brad Cox	1961–	Objective-C	Objective-C, OOP	→
Percy Bridgman	1882–1961	Operationalism	Metrics, verification	→
Carl Hewitt	1940–2022	Actor Model	Concurrency, distributed	→
Seymour Papert	1928–2016	Logo, constructionism, Mindstorms	Education, AI	→
Tony Hoare	1934–	CSP, null reference, quicksort	Concurrency, types	→
Luca Cardelli	1954–	Type systems, objects	Types, OOP	→
Fred Brooks	1931–2022	MMM, No Silver Bullet	Architecture	→
Alan Kay	1940–	Smalltalk, OOP, messaging	OOP, design	→
Grady Booch	1955–	OOAD, UML	OOP, design	→
Ivar Jacobson	1933–	OOSE, use cases	Process, architecture	→
James Rumbaugh	1947–	OMT, UML	OOP, design	→
Erich Gamma	1961–	Design Patterns (GoF), frameworks	Design, patterns	→
Ralph Johnson	1955–	Design Patterns (GoF), patterns	Design, patterns	→
John Vlissides	1957–	Design Patterns (GoF), patterns	Design, patterns	→
Rebecca Wirfs-Brock	1953–	Designing OO, responsibility-driven	OOP, design	→
Robin Milner	1934–2010	ML, type inference, π-calculus	Types, FP	→
Alain Colmerauer	1941–2017	Prolog, logic programming	LP, FP	→
John Backus	1924–2007	Fortran, FP manifesto	FP	→
James Gosling	1955–	Java, JVM	Java, OOP	→
Guido van Rossum	1956–	Python, Python	Python, FP	→
Yukihiro Matsumoto	1965–	Ruby, Ruby	OOP, FP	→
Leslie Lamport	1941–	Logical clocks, Paxos, LaTeX	Distributed	→
Jim Gray	1944–2007	Transactions, ACID	Distributed, DB	→
Bertrand Meyer	1950–	Eiffel, DbC, CQS, OOSC	OOP, design	→
Kurt Gödel	1906–1978	Incompleteness theorems	Foundations, logic	→
John Hughes	1958–	Why FP Matters, QuickCheck	FP, testing	→
Koen Claessen	1961–	QuickCheck, property testing	FP, testing	→
Kent Beck	1961–	XP, TDD, JUnit, SUnit	Process, testing	→
Ward Cunningham	1944–	Wiki, technical debt, CRC cards	Process, design	→
Martin Fowler	1963–	Refactoring, EAA patterns	Design, architecture	→
Robert C. Martin	1952–	SOLID, Clean Code	Design, OOP	→
Michael Feathers	1964–	Legacy code, characterization tests	Testing	→
Mike Cohn	1961–	User stories, INVEST	Process	→
Eric Evans	—	DDD	Architecture, design	→
Alistair Cockburn	1953–	Hexagonal architecture, Agile	Architecture	→
Joe Armstrong	1950–2019	Erlang, let-it-crash	Concurrency, FP	→
Rich Hickey	1961–	Clojure, Simple Made Easy	FP, design	→
David MacIver	1960–	QuickCheck, property testing	FP, testing	→
Sandi Metz	1965–	POODR, Practical OO in Ruby	OOP, design	→
Scott Wlaschin	—	Domain Modeling Made Functional	FP, DDD	→
Gary Bernhardt	—	FC/IS, Boundaries talk	Design, FP	→
Martin Kleppmann	—	DDIA	Distributed	→
Eric Brewer	—	CAP conjecture, CAP theorem	Distributed	→
Diego Ongaro	—	Raft consensus algorithm	Distributed	→
Sam Newman	—	Microservices	Architecture	→
Walter Shewhart	1891–1967	Control charts, SQC	Quality, verification	→
Simon Brown	—	C4 Model, software architecture	Architecture	→
Matthew Skelton	—	Team Topologies	Process, architecture	→
Manuel Pais	—	Team Topologies	Process, architecture	→
Jez Humble	—	Continuous Delivery	Delivery	→
David Farley	—	Continuous Delivery	Delivery	→
Nicole Forsgren	—	Accelerate, DORA	Process, delivery	→
Gene Kim	—	Accelerate, DORA	Process, delivery	→
Steve Smith	—	DORA metrics, DevOps	Process, SRE	→
Ashish Vaswani	—	Transformer architecture	LLM	→
Ilya Sutskever	1986–	GPT series, scaling	LLM	→
Jared Kaplan	—	Scaling Laws	LLM	→
Tom Brown	—	GPT-3	LLM	→
Jason Wei	—	Chain-of-thought prompting	LLM	→
Long Ouyang	—	InstructGPT / RLHF	LLM	→
Andrej Karpathy	1986–	nanoGPT, LLM education	LLM	→
Lilian Weng	—	Agents, prompting, alignment blog	LLM	→

📊 Full list with influence graph: Authors index

Key works

📄 Papers

Year	Author(s)	Title	Topic	Local	Page
1936	Church	Lambda calculus	FP foundations	—	→
1968	Dijkstra	Go To Considered Harmful	Structured programming	pdf	→
1972	Parnas	On the Criteria To Be Used in Decomposing Systems into Modules	Modularity	pdf	→
1973	Hewitt, Bishop, Steiger	A Universal Modular ACTOR Formalism	Concurrency	—	→
1978	Backus	Can Programming Be Liberated…?	FP	pdf	→
1978	Hoare	CSP	Concurrency	pdf	→
1978	Lamport	Time, Clocks, and the Ordering of Events…	Distributed	pdf	→
1989	Hughes	Why Functional Programming Matters	FP	pdf	→
1994	Liskov & Wing	A Behavioral Notion of Subtyping	Types, OOP	pdf	→
2000	Brewer	CAP conjecture (keynote)	Distributed	—	→
2002	Amazon	Dynamo: Amazon's Highly Available Key-value Store	Distributed	—	→
2007	Helland	Life Beyond Distributed Transactions	Distributed	—	→
2017	Vaswani	Attention Is All You Need	LLM / Transformers	—	→
2020	Kaplan	Scaling Laws for Neural Language Models	LLM / Scaling	—	→
2020	Brown	Language Models are Few-Shot Learners (GPT-3)	LLM / In-context	—	→
2022	Ouyang	InstructGPT / Training language models to follow instructions	LLM / Alignment	—	→
2022	Wei	Chain-of-Thought Prompting Elicits Reasoning	LLM / Prompting	—	→
2022	Yao	ReAct: Synergizing Reasoning and Acting	LLM / Agents	—	→

📚 Books

Year	Author(s)	Title	Topic	Page
1936	Church	The Calculi of Lambda-Conversion	FP foundations	→
1975	Brooks	The Mythical Man-Month	Architecture, process	→
1980	Papert	Mindstorms	Education, AI	→
1988	Hoare	Communicating Sequential Processes	Concurrency	→
1991	Jacobson	Object-Oriented Software Engineering	Process, architecture	→
1992	Martin	Agile Software Development: Principles, Patterns, and Practices	Process	→
1992	Metz	Practical Object-Oriented Design in Ruby (POODR)	Design	→
1994	GoF	Design Patterns	Design	→
1994	Cohn	User Stories Applied	Process	→
1995	Stroustrup	The C++ Programming Language	C++, OOP	→
1999	Fowler	Refactoring	Design	→
1999	Fowler	Patterns of Enterprise Application Architecture	Architecture	→
2000	Rumbaugh	Object Modeling Technique	OOP, design	→
2002	Beck	Test-Driven Development: By Example	Testing	→
2002	Beck & Cunningham	Using CRC Cards	Design	→
2003	Evans	Domain-Driven Design	Architecture	→
2003	Wirfs-Brock	Designing Object-Oriented Software	OOP, design	→
2003	Armstrong	Making Reliable Distributed Systems in Erlang	Concurrency, FP	→
2003	Wirfs-Brock & McKim	Object Design: Roles, Responsibilities, and Collaborations	OOP, design	→
2004	Feathers	Working Effectively with Legacy Code	Testing	→
2005	Martin	UML Distilled	OOP, design	→
2006	Martin	Clean Code	Design	→
2007	Gosling	The Java Language Specification	Java	→
2010	Humble & Farley	Continuous Delivery	Delivery	→
2011	Alexander	A Pattern Language	Design patterns, architecture	→
2012	Metz	Practical Object-Oriented Design in Ruby (2018)	Design	→
2012	Cardelli & Abadi	A Theory of Objects	Types, OOP	→
2012	Gamma et al.	Frameworks and Patterns	Design	→
2014	Gosling et al.	The Java Language Specification (Java 7)	Java	→
2014	Ongaro & Ousterhout	Elements of Distributed Systems	Distributed	→
2015	Newman	Building Microservices	Architecture	→
2016	Google	Site Reliability Engineering	SRE, operations	→
2017	Kleppmann	Designing Data-Intensive Applications	Distributed	→
2018	Forsgren, Humble & Kim	Accelerate	Delivery	→
2018	Wlaschin	Domain Modeling Made Functional	FP, DDD	→
2018	Ousterhout	A Philosophy of Software Design	Design	→
2019	Skelton & Pais	Team Topologies	Architecture, process	→

🎤 Talks

Year	Author	Title	Topic	Page
2011	Hickey	Simple Made Easy	Design, FP	→
2012	Bernhardt	Boundaries	FP, architecture	→
2013	MacIver	QuickCheck, property testing	FP, testing	→

📖 Full bibliography: Bibliography · Open-access links: Open access

Code examples

Each language directory contains numbered examples progressing from basics to more idiomatic features. The goal is not only to show syntax, but to compare how different languages express the same core ideas.

#	Example	C	Java	Python	Haskell	Go	Rust	Erlang	Clojure	TS
01	Hello, World	✅	✅	✅	✅	✅	✅	✅	✅	✅
02	Variables & types	✅	✅	✅	✅	✅	✅	✅	✅	✅
03	Functions	✅	✅	✅	✅	✅	✅	✅	✅	✅
04	Control flow	✅	✅	✅	✅	✅	✅	✅	✅	✅
05	Data structures	✅	✅	✅	✅	✅	✅	✅	✅	✅
06	OOP / modules	✅	✅	✅	✅	✅	✅	✅	✅	✅
07	FP features	✅	✅	✅	✅	✅	✅	✅	✅	✅
08	Error handling	✅	✅	✅	✅	✅	✅	✅	✅	✅
09	Concurrency	✅	✅	✅	✅	✅	✅	✅	✅	✅
10	Testing	✅	✅	✅	✅	✅	✅	✅	✅	✅

✅ = done · 🔲 = planned

📁 All examples: examples/

Reading paths

Guided sequences for focused study.

Path	Focus	Start	End	Page
🏗 Architecture	Modularity → Hexagonal → DDD	Dijkstra 1968	Skelton 2019	→
🧩 OOP & Design	Simula → Smalltalk → GoF → SOLID	Dahl 1967	Metz 2012	→
λ Functional Programming	Lambda calculus → ML → Haskell → Clojure	Church 1936	Wlaschin 2018	→
🧪 Testing & Delivery	XP → TDD → CI/CD → DORA	Beck 1999	Forsgren 2018	→
🌐 Distributed Systems	Clocks → ACID → CAP → Streaming	Lamport 1978	Kleppmann 2017	→
🤖 Large Language Models	Transformers → RAG → Agents	Vaswani 2017	Rafailov 2023	→

Chronological highlights

timeline
    title Key milestones in software development
    1936 : Church — Lambda calculus
    1958 : McCarthy — Lisp
    1967 : Dahl & Nygaard — Simula
         : Conway — Conway's Law
    1968 : Dijkstra — Go To Considered Harmful
         : NATO Software Engineering Conference
    1972 : Kay — Smalltalk
         : Parnas — Information Hiding
         : Ritchie — C language
         : Colmerauer — Prolog
    1973 : Hewitt — Actor Model
    1974 : Liskov — CLU / ADT
    1978 : Backus — FP manifesto
         : Hoare — CSP
         : Milner — ML
         : Lamport — Logical Clocks
    1981 : Gray — Transaction Processing / ACID
    1982 : Lamport et al. — Byzantine Generals
    1986 : Brooks — No Silver Bullet
         : Armstrong — Erlang
    1988 : Meyer — OOSC / DbC / CQS
    1989 : Hughes — Why FP Matters
         : Lamport — Paxos (circulated; published 1998)
    1990 : Haskell 1.0
    1994 : GoF — Design Patterns
         : Liskov & Wing — Behavioral Subtyping (LSP formalized)
    1995 : Java 1.0
         : Schwaber & Sutherland — Scrum
    1996 : Shaw & Garlan — Software Architecture
    1999 : Beck — Extreme Programming
         : Fowler — Refactoring
    2000 : Brewer — CAP conjecture
    2001 : Agile Manifesto
    2002 : Beck — Test-Driven Development (book)
         : Gilbert & Lynch — CAP theorem formalized
    2003 : Evans — Domain-Driven Design
         : Armstrong — Erlang thesis
         : R.C. Martin — SOLID principles
    2005 : Cockburn — Hexagonal Architecture
    2007 : Hickey — Clojure
         : Amazon — Dynamo paper
         : Helland — Life Beyond Distributed Transactions
    2009 : Go language
         : DevOps movement
    2010 : Humble & Farley — Continuous Delivery
         : Rust announced
    2011 : Hickey — Simple Made Easy
         : Brown — C4 Model
         : Shapiro et al. — CRDTs
    2012 : Bernhardt — Boundaries talk
         : TypeScript announced
    2014 : Ongaro & Ousterhout — Raft
    2017 : Kleppmann — DDIA
    2018 : Forsgren — Accelerate / DORA
         : Wlaschin — Domain Modeling Made Functional
    2017 : Vaswani et al. — Attention Is All You Need (Transformer)
    2019 : Skelton & Pais — Team Topologies
    2020 : Kaplan et al. — Scaling Laws
         : Brown et al. — GPT-3 / Few-Shot Learning
    2022 : Ouyang et al. — InstructGPT / RLHF
         : Wei et al. — Chain-of-Thought Prompting
         : Yao et al. — ReAct
    2023 : Rafailov et al. — Direct Preference Optimization

📊 Full interactive timeline: Master timeline

Glossary

Unified list of abbreviations and terms used in the maps and text above.

Term	Full name	Meaning
ACID	Atomicity, Consistency, Isolation, Durability	Properties that guarantee reliable database transactions.
ADT	Abstract Data Type	A type defined by its operations, not its representation (Liskov / CLU).
C4	Context, Containers, Components, Code	Lightweight software architecture visualization model (Simon Brown).
CAP	Consistency, Availability, Partition tolerance	During a network partition one must choose between C and A. Conjecture by Brewer (2000), formalized by Gilbert & Lynch (2002).
CMM	Capability Maturity Model	Process maturity framework (SEI, late 1980s).
CRDT	Conflict-free Replicated Data Type	Data structures that converge across replicas without coordination.
CQRS	Command Query Responsibility Segregation	Separating write and read models at the architecture level.
CSP	Communicating Sequential Processes	Formal model of concurrency via message-passing channels (Hoare 1978).
DbC	Design by Contract	Method of specifying component obligations via pre/postconditions (Meyer 1988).
CQS	Command–Query Separation	A method should either change state or return a value, never both (Meyer). Precursor to CQRS.
DDD	Domain-Driven Design	Approach to modeling complex systems around the business domain (Evans 2003).
DDIA	Designing Data-Intensive Applications	Book by Kleppmann (2017) synthesizing modern distributed-systems knowledge.
DORA	DevOps Research and Assessment	Research program and metrics for delivery performance (Forsgren et al.).
ES	Event Sourcing	Storing state as an append-only sequence of domain events.
FC/IS	Functional Core / Imperative Shell	Architecture pattern: pure logic inside, side-effects at the boundary (Bernhardt 2012).
FP	Functional Programming	Programming paradigm emphasizing pure functions, immutability, and composition.
GoF	Gang of Four	Authors of Design Patterns (1994): Gamma, Helm, Johnson, Vlissides.
HM	Hindley–Milner	Type inference algorithm for parametric polymorphism (basis of ML, Haskell).
LP	Logic Programming	Paradigm where programs are facts + rules; execution is proof search (Prolog, Datalog).
LSP	Liskov Substitution Principle	Subtypes must be substitutable for their base types. Introduced 1987, formalized 1994.
MMM	The Mythical Man-Month	Book by Fred Brooks (1975) on the non-linear cost of adding people to a late project.
NATO	North Atlantic Treaty Organization	In this atlas: the 1968 NATO conference that coined the term software engineering.
OOP	Object-Oriented Programming	Programming paradigm centered on objects, messages, and encapsulation.
REST	Representational State Transfer	Architectural style for networked applications (Fielding 2000).
SDLC	Software Development Life Cycle	General term for the phases of software planning, creation, and maintenance.
SOLID	Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion	Five OOP design principles (R.C. Martin; acronym crystallized early 2000s).
SRE	Site Reliability Engineering	Engineering discipline applying software practices to operations (Google; public book 2016).
TDD	Test-Driven Development	Write a failing test first, make it pass, refactor. Practiced in XP from late 1990s; book by Beck 2002.
LLM	Large Language Model	Neural network trained on text to predict the next token; powers modern AI assistants and coding tools.
RAG	Retrieval-Augmented Generation	Architecture that grounds LLM outputs in retrieved external documents to reduce hallucination.
RLHF	Reinforcement Learning from Human Feedback	Alignment technique training LLMs on human preference rankings (InstructGPT, ChatGPT).
XP	Extreme Programming	Agile methodology emphasizing feedback, simplicity, and technical practices (Beck 1999).

Local library

This repository includes local copies of open-access papers only. Commercial books are referenced by citation and official sources.

See Copyright policy for details.

Category	Location	Count
Open-access papers	`library/open-access-papers/`	—
Personal reading notes	`library/notes/`	—

Repository structure

software-atlas/
├── README.md              ← you are here
├── .gitignore
├── CONTRIBUTING.md
├── LICENSE
├── index.html
├── pom.xml
├── docs/
│   ├── index.md
│   ├── maps/              ← visual diagrams and timelines
│   │   ├── index.md       ← maps index and detailed overview
│   │   ├── architecture-map.md
│   │   ├── concurrency-map.md
│   │   ├── containers-map.md
│   │   ├── databases-map.md
│   │   ├── ideas-evolution.md
│   │   ├── languages-genealogy.md
│   │   ├── master-timeline.md
│   │   ├── paradigms-map.md
│   │   └── process-map.md
│   ├── topics/            ← knowledge organized by topic
│   │   ├── concepts/      ← fundamental ideas: paradigms, concurrency, types, FP
│   │   ├── architecture/  ← system structure and modularity
│   │   ├── design/        ← OOP, patterns, SOLID, refactoring
│   │   ├── engineering/   ← verifiable practices, testing, observability
│   │   ├── process/       ← methodologies: agile, XP, DevOps, SRE
│   │   ├── tools/         ← build systems, containers, dev-tools, version control
│   │   ├── distributed/   ← distributed systems
│   │   ├── databases/     ← data storage and models
│   │   ├── testing/       ← verification techniques
│   │   ├── vcs/           ← version control and Git
│   │   └── llm/           ← large language models
│   ├── languages/         ← language pages
│   ├── authors/           ← author biography cards
│   ├── works/             ← papers, books, talks
│   ├── reading-paths/     ← guided study sequences
│   ├── glossary/          ← terms dictionary
│   └── references/        ← bibliography and links
├── examples/              ← runnable code by language
├── library/               ← copyright policy
│   └── README.md
├── templates/             ← page templates for contributors
│   ├── author-template.md
│   ├── language-template.md
│   └── work-paper-template.md

Contributing

See CONTRIBUTING.md.

This is primarily a personal knowledge base, but corrections, suggestions, and additions are welcome.

License

Content: CC BY-SA 4.0 Code examples: MIT

"The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise."
— Edsger Dijkstra

Name		Name	Last commit message	Last commit date
Latest commit History 62 Commits
.claude		.claude
docs		docs
examples		examples
library		library
templates		templates
.gitignore		.gitignore
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
index.html		index.html
pom.xml		pom.xml

Folders and files

Latest commit

History

Repository files navigation

Software Engineering Atlas

What is this?

The Atlas Approach

What counts as an entity

Typical relationships

Inclusion policy

What the atlas is for

Overview map

Overview timeline: Major lineages × era

Topics

🧠 Concepts

🏗 Architecture & Structure

🎨 Design

⚙️ Engineering

🌐 Systems & Data

🧪 Process & Methodologies

🛠 Tools

🤖 Machine Learning & LLMs

Languages

Authors

Key works

📄 Papers

📚 Books

🎤 Talks

Code examples

Reading paths

Chronological highlights

Glossary

Local library

Repository structure

Contributing

License

About

Topics

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages