← all systems · see it in The System
Software
Software (SW) consists of computer programs that instruct the execution of a computer; it also includes design documents and specifications (src:wp:software). A computer program is 'a sequence or set of instructions in a programming language for a computer to execute' (src:wp:computer-program). Where software ends (programs only, programs plus documents, or any data that 'implies a flow of control') is booked as contention C-1161.
Properties published scienceour proposal
Sourced fields, and our own readings.
| aliases | Software (what the rule unpacks into: programs, languages, compilers, operating systems) |
| born at | end of the 1940s (stored-program computers; EDSAC 1949 'used the first stored computer program'); earlier claims kept in contention C-1132 |
| born precision | decade; contested |
| boundary | Inside: the programs (source code and the machine code it becomes), the processes that run them, and the libraries, runtimes and operating system they are built on; the design documents and specifications that go with them (src:wp:software). Outside: the computer hardware that executes them (software runs on sys:computer), the people who write, use and maintain it, the networks and storage it reads and writes. Where the line falls between software and the data it handles is contested (C-1161): an executable 'is data, but distinct from data that does not imply a flow of control' (src:wp:executable). |
| nested level | Runs on the computer's processor and memory (the stored-program Seed puts instructions in the same store as data); built in layers, each depending on the one below (machine code, operating system, runtime and libraries, programs in a language, applications); embedded in package ecosystems, the Internet and the human activities it mechanizes. |
| scale | technological |
Measures (20) published science
| characteristic clock: reclamation cycle of LISP's garbage collector (IBM 704, 1960) | several seconds |
| time for a proficient programmer to comprehend a Python snippet (code problems, English identifiers) | 17.56 (SD 9.05) seconds |
| interpreted vs compiled execution speed | 10 to 100 times slower ratio |
| energy to run the benchmark set: C vs Python (Pereira 2017) | 57 vs 4390 joules |
| execution time for the benchmark set: C | 2019 milliseconds |
| CPU share of energy, compiled languages | 88.94 percent |
| maintenance share of lifetime cost | 75 or more percent |
| annual cost of software bugs to the US economy (NIST 2002) | 59 billion (about 0.6% of GDP) US dollars per year |
| cost of poor quality software | 20 to 40 percent of sales (some estimates) |
| neutral random mutations (22 programs) | over 30 percent |
| transitive dependencies of half of dependent packages (Cargo, npm, NuGet) | at least 41, 21, 27 (median direct: 2) packages |
| reverse-dependency concentration | fewer than 17% of required packages hold more than 80% of reverse dependencies share |
| left-pad removal (npm, March 2016) | over 5,000 transitive dependents broken (> 2% of npm) packages |
| '90% debugged' plateau (1968 industry joke) | about 25 percent of total implementation time |
| installed computers in Europe, 1968, and growth | about 10,000; +25 to 50% a year computers |
| OS/360 cost to IBM during preparation | over $50 million a year; at least 5000 man-years US dollars; person-years |
| first use of the word 'software' for programs | 1958 (Tukey) year |
| high-level programming languages introduced | 1958 year |
| code comprehension accuracy (Python, Experiment 1) | 85 percent |
| experience of expert programmers in the logic study | average 11 years |
Open contentions (5) open contention
Where sources or readings disagree. Both stay on the map.
- C-1122 Does reading computer code use the brain's language areas?
booked: The map follows the findings that reading code engages reasoning networks rather than the language network, and keeps earlier contrary results alongside.
the other reading: Ivanova et al. 2020: the bilateral multiple demand (domain-general executive) system responds strongly; language system weakly or not at all; Liu et al. 2020: a left-lateralized fronto-parietal network overlapping most with formal logic, less with math; overlap with executive control and language low; earlier studies (as cited by Ivanova) found left-lateralized activity roughly in language regions - C-1132 What was the first computer program?
booked: The map names no single first and places the start with the stored-program machines of the late 1940s, noting Ada Lovelace's 1843 program as a claim some historians make.
the other reading: Lovelace's Note G (1843): 'recognized by some historians as the world's first computer program'; EDSAC (1949) 'used the first stored computer program' (encyclopedia, Computer program); related: C-568 (first computer) - C-1136 Does the choice of programming language change how much energy software uses?
booked: The map keeps both: a 2017 study finding large differences between languages, and a 2024 study finding none once implementation and running time are controlled.
the other reading: language choice itself changes energy (Pereira 2017, as widely read); only the implementation and execution time matter (van Kempen 2024, 'notable discrepancies in prior work vanish') - C-1161 What counts as software: just programs, or their documents too?
booked: The map defines software as computer programs plus the design documents and specifications that go with them, and keeps the narrower 'programs only' usage alongside.
the other reading: programs only: a computer program 'is one component of software, which also includes documentation and other intangible components' (so documents are part, but some usage means programs alone); code is data: an executable 'is data, but distinct from data that does not imply a flow of control' (src:wp:executable), so the line between software and the data it handles is one of use, not kind; Osterweil 2013 'What Is Software?' (cited by the encyclopedia; not read) - C-1162 Was there really a 'software crisis' in 1968?
booked: The map keeps 'software crisis' as a debated label and doesn't rule.
the other reading: a crisis: Ross, 'I am still very much in a crisis'; Dijkstra 1972: caused by machines becoming 'several orders of magnitude more powerful'; not a crisis: Kolence, 'I do not like the use of the word crisis'; difficulties only for large systems ('There are many areas where there is no such thing as a crisis')
Partners and parts published science
Built from / builds (15)
- Operating system
- Programming language
- Machine code
- Application software
- Libraries and packages
- Compiler
- Processes (programs running)
- Competition for a host program's memory and execution (virus vs host program)
- Competition for control of a running program (exploit vs patch)
- New languages competing for C's performance-critical niche (after 2010)
- The eternal war in memory (top-level competition)
- Campaign: control-flow hijacking against deployed protections
- High-assurance evaluated systems against speedy approval of low-assurance systems
- Competition for a language's standard-library sort
- Open-source projects displaced by stronger competitors
Sits inside / holds (12)
- Internet
- Computer
- Human culture
- Package ecosystems (dependency networks)
- Operating system
- Programming language
- Compiler
- Open-source software
- Malware
- Software vulnerability
- Data structure
- Sorting algorithm
Trades with (valence) (32)
- Human (Homo sapiens) via sys:sensory-environment · Software gain
- Internet via sys:electromagnetic-field · Software gain
- Large language model via sys:written-record · Software even
- Human brain via sys:electromagnetic-field · Software gain
- Computer via sys:electromagnetic-field · Software gain
- Algorithm (the practice of step-by-step procedures and the structure they compute) via sys:written-record · Software gain
- Malware via sys:written-record · Software loss
- Package ecosystems (dependency networks) via sys:written-record · Software mixed
- Stored-program principle (instructions held in the same memory as data) via sys:electromagnetic-field · Software gain
- Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them via sys:computer · Software gain
- LLM-based agent via sys:written-record · Software even
- Central processing unit via sys:electromagnetic-field · Software gain
- Operating system via sys:software · Software mixed
- Programming language via sys:written-record · Software gain
- Computer-aided design via sys:electromagnetic-field · Software gain
- Software engineering via sys:written-record · Software gain
- Computer security via sys:written-record · Software gain
- Artificial intelligence via sys:written-record · Software gain
- Compiler via sys:electromagnetic-field · Software gain
- Open-source software via sys:written-record · Software gain
- Organization via sys:written-record · Software mixed
- Computer hardware via sys:electromagnetic-field · Software gain
- Database via sys:software · Software gain
- Computer network via sys:electromagnetic-field · Software gain
- Software vulnerability via sys:software · Software loss
- Logic gate via sys:electromagnetic-field · Software gain
- Secure software development via sys:software · Software gain
- Computer ethics via sys:software · Software gain
- Computer law via sys:software · Software mixed
- Computer science (the field: the practice and the computation it studies) via sys:sensory-environment · Software gain
- Data structure via sys:electromagnetic-field · Software gain
- Sorting algorithm via sys:electromagnetic-field · Software gain
expressed by (24)
- Generation/Synthesis
- Recombination/Composition
- Scaffolding/Enablement (Meta-Tooling)
- Templating / Standardization
- Niche Construction (alter environment)
- Quality Improvement/Refinement
- Interoperability/Transduction (Bridging)
- Encapsulation & Modularity (Abstraction)
- Amplification/Scale-Up (Manufacture & Distribution)
- Evolvability/Plasticity Engineering (Design for Future Variation)
- Internal Coordination/Regulation
- Sensing/Scanning
- Mapping/Modeling
- Trail-Marking / Externalized Memory (Stigmergy)
- Surprise / Change-Point Detection
- Reactive Response
- Physical/Virtual Barrier
- Self-Monitoring
- Validation of Identity/Intention
- Validation of Effectiveness
- Resilience & Repair
- Triage & Prioritized Allocation
- Quality Control & Error Correction
- Scheduled Build-and-Dismantle (On-Demand Structure)
floor filled by (31)
- Human (Homo sapiens)
- Stored-program principle (instructions held in the same memory as data)
- Large language model
- Computer
- Algorithm (the practice of step-by-step procedures and the structure they compute)
- Central processing unit
- Operating system
- Programming language
- Human culture
- Machine code
- Application software
- Libraries and packages
- Compiler
- Processes (programs running)
- Package ecosystems (dependency networks)
- Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them
- LLM-based agent
- Data centre
- Computer-aided design
- Software engineering
- Computer security
- Open-source software
- Computer hardware
- Database
- Computer network
- Software vulnerability
- Secure software development
- Vulnerability management
- Computer ethics
- Computer law
- Sorting algorithm
Kinds (16)
- Operating system
- Application software
- Libraries and packages
- Compiler
- Software as a service (SaaS)
- Open-source software
- S-program (Lehman)
- P-program (Lehman)
- E-program (Lehman)
- Script (interpreted program)
- Native executable (machine code)
- Malware
- Quine (self-reproducing program)
- Source-available software
- Proprietary software
- Freeware and shareware
Notes published science
- Standard error, the separate stream programs use for error messages, exists because Unix kept printing its error messages onto expensive phototypesetting runs instead of the user's screen: 'Standard error was added to Unix in the 1970s after several wasted phototypesetting runs ended with error messages being typeset' (src:wp:standard-streams).
- A compiler can learn: Ken Thompson taught the C compiler what '\v' means by giving it the number 11 once; after that the compiler's own binary 'knows' it and the source can say it in its own terms. The same trick lets a compiler hide a Trojan horse that no reading of its source will ever find (src:thompson-1984-trust).
- Linux and E. coli both run on hierarchical control networks, but upside down from each other: the bacterium has a few master regulators over many targets, Linux has many callers over a few generic functions, because biology is built for robustness and software for reuse (src:yan-2010-genomes-os). And reading code doesn't use the brain's language areas much: it lights up the problem-solving (multiple demand) network (src:ivanova-2020-code).
- The 2003 blackout that hit 50 million people began with an alarm that went silent: the control room's alarm software failed at 14:14 and nobody knew, operators' screens slowed from refreshing every 1-3 seconds to every 59, and power lines touching overgrown trees did the rest (src:task-force-2004-blackout).
Layers
The ways it takes in its world, where they meet, and how it acts back, each from L1 (where it meets the world) up.
source text: the program as written and translated (compiler phases)
- L1: Source text: characters typed by programmers (or generated), kept in files under version control
- L2: Lexical analysis and parsing: text into tokens and syntax
- L3: Semantic analysis and an intermediate representation
- L4: Optimization and machine-specific code generation; linking with libraries into an executable
- L5: The executable loaded by the operating system as a process
the boardroom (shared floors)
- L4: Runtime and libraries: the ports where every input arrives (event loop, reads on stdin, files and sockets, registered signal and exception handlers), linked libraries, interpreter or virtual machine, garbage collector
- L5: The program's logic as written in its language: control flow, functions and modules, each hiding a design decision; the call graph of many callers over a small set of generic functions
- L6: The application: the task performed for users, as specified and designed
- L7: The activity the program mechanizes: E-type programs embedded in the part of the real world they model, valid against that world rather than a specification, and changed as it changes
the software stack: machine code up to the activity it mechanizes (reader's view)
- L1: The machine it runs in: instructions and data as bits in the computer's memory, executed by the processor (fetch, decode, execute)
- L2: Machine code: the instruction set architecture, the language the CPU interprets directly
- L3: Operating system: loads programs as processes, virtualizes the CPU and memory, serves system calls, turns interrupts into signals
- L4: Runtime and libraries: linked libraries, interpreters and virtual machines, the event loop and registered handlers, garbage collection; where inputs arrive (the ports)
- L5: The program in a programming language: source code's control flow, functions and modules, each module hiding a design decision
- L6: The application: the task it performs for users, as specified and designed (design documents and specifications are part of software)
- L7: The activity it mechanizes: an E-type program embedded in the part of the world it models, its outputs acting back on that world (appliances, elevators, communication), and changed as that world changes
way in: Clock and timers
- L1: The computer's clock (its clock channel)
- L2: Timer interrupts
- L3: The scheduler preempts and resumes the process; timers fire as events
way in: Environment and configuration
- L1: User-definable values in the environment a process runs in
- L2: Inherited from the parent process at start, with the standard streams
- L3: Queried by the running program
way in: Faults and exceptions (the program's own errors)
- L1: An anomalous condition in execution, first caught as a CPU-defined interrupt (the first of three layers)
- L2: Re-raised as an operating-system signal
- L3: Re-raised as a language exception that breaks the normal flow
way in: Files and stored data
- L1: Records held on storage media (the computer's storage channel)
- L2: The device driver and storage controller read blocks into memory
- L3: The file system serves a system call; bytes land in the program's buffer
way in: Messages and calls from other programs (IPC, APIs)
- L1: Another process's output: a pipeline, shared memory, a client request
- L2: The kernel's IPC mechanism (pipe, socket, message queue), synchronous or asynchronous
- L3: The call arrives at the interface the program exposes
way in: Network messages
- L1: Signals on links carrying packets from other hosts (the Internet's o-delivery)
- L2: The network interface raises an interrupt; the driver takes the packet
- L3: The kernel's network stack hands the data to the process's socket
way in: Signals (asynchronous notifications from the OS)
- L1: An event in the system that concerns the process (interrupt, suspend, terminate, kill)
- L2: The kernel turns it into a signal (it may pass a hardware interrupt on as a signal)
- L3: Delivery interrupts the process's normal flow
way in: Source code (the build channel: the program's own instructions)
- L1: Programmers type the program (a novel cognitive tool, read through sight); models may write it too (LLM walk o-code)
- L2: Source files in a version history
- L3: The compiler's phases (or an interpreter at run time) translate it to machine code
- L4: Linked with libraries and loaded by the OS as a process; reproducible builds check binary against source
way in: User input (keys, pointer, touch, voice)
- L1: A person presses keys, moves a pointer, touches a screen or speaks (the computer's keyboard, touch-pointer and microphone channels)
- L2: The device raises an interrupt; the processor saves state and runs the driver's handler
- L3: The kernel delivers it to the process as an event or on standard input
way out: Control of machines (embedded software)
- L1: Motion and state of the machine in the world
- L3: Device commands through drivers (the computer's o-control)
- L7: The machine's behaviour the program sets
way out: Energy spent (heat, through the computer)
- L1: Heat to the surroundings (the computer's o-heat)
- L5: Every instruction run costs energy; most of it in the CPU
way out: Messages and calls to other programs and machines
- L1: Signals on links (the Internet's host-traffic channel) or another process's input
- L3: The kernel's network stack or IPC mechanism
- L7: A request or reply to another program
way out: New processes and new programs (spawning, compiling)
- L1: A new process in memory, inheriting the parent's streams
- L3: A system call creates and executes a new process
- L7: A program that starts or builds another
way out: Screen output (standard output, windows)
- L1: Light from the screen, read on Human's sight channel
- L3: A system call hands it to the kernel and drivers (the computer's o-display)
- L5: The program writes to standard output or draws; errors go to standard error
- L7: A result for the person whose activity it serves
way out: Sound
- L1: Sound in the room (Human's hearing channel)
- L3: System call to the audio driver
- L7: A result as sound
way out: Writes to storage (files, logs, version history)
- L1: Records on storage, read later by this or other programs (the files channel)
- L3: A write system call through the file system
- L7: What is kept for later
Sources (68) published science
Computer program (encyclopedia) (behind its links)
Lehman's laws of software evolution (encyclopedia) (behind its links)
Wikipedia: Operating system (behind its links)
Programming language (Wikipedia via Wikimedia Enterprise, cached research/showcase/cache/wme) (behind its links)
Compiler (Wikipedia, rev 1373605841, 2026-09-06, via Wikimedia Enterprise) (behind its links)
Open-source software (Wikipedia, Wikimedia Enterprise snapshot 2026-11-01 via tools/wme) (behind its links)
Malware (Wikipedia, via Wikimedia Enterprise snapshot) (behind its links)
Data structure (encyclopedia, Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Sorting algorithm (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
McCarthy 1960, Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I, Communications of the ACM 3(4), doi:10.1145/367177.367199 (behind its links)
Ivanova et al. 2020, Comprehension of computer code relies primarily on domain-general executive brain regions, eLife 9:e58906, doi:10.7554/eLife.58906 (behind its links)
Pereira et al. 2017, Energy Efficiency across Programming Languages, SLE'17, doi:10.1145/3136014.3136031 (behind its links)
Software bug (encyclopedia) (behind its links)
Schulte et al. 2014, Software Mutational Robustness, Genetic Programming and Evolvable Machines (arXiv:1204.4224) (behind its links)
Naur & Randell (eds.) 1969, Software Engineering: Report on a conference sponsored by the NATO Science Committee, Garmisch, 7-11 October 1968 (behind its links)
Liu et al. 2020, Computer code comprehension shares neural resources with formal logical inference in the fronto-parietal network, eLife, doi:10.7554/eLife.59340 (behind its links)
Event-driven programming (encyclopedia) (behind its links)
Cunningham 1992, The WyCash Portfolio Management System, OOPSLA '92 experience report (behind its links)
Chen et al. 2014, Bio-inspired Mechanism and Model Exploration of Software Aging (arXiv:1409.1879) (behind its links)
Software testing (encyclopedia) (behind its links)
Exception handling (encyclopedia) (behind its links)
Thompson 1984, Reflections on Trusting Trust, Communications of the ACM 27(8):761-763, doi:10.1145/358198.358210 (behind its links)
Machine code (encyclopedia) (behind its links)
Arpaci-Dusseau & Arpaci-Dusseau, Operating Systems: Three Easy Pieces, ch. 4 'The Abstraction: The Process' (free online textbook) (behind its links)
Application programming interface (encyclopedia) (behind its links)
Parnas 1972, On the Criteria To Be Used in Decomposing Systems into Modules, Communications of the ACM 15(12):1053-1058, doi:10.1145/361598.361623 (behind its links)
Inter-process communication (encyclopedia) (behind its links)
Version control (encyclopedia) (behind its links)
System call (encyclopedia) (behind its links)
Standard streams (encyclopedia) (behind its links)
Lamb & Zacchiroli 2021, Reproducible Builds: Increasing the Integrity of Software Supply Chains, IEEE Software (arXiv:2104.06020) (behind its links)
Software aging (encyclopedia) (behind its links)
Garbage collection (computer science) (encyclopedia) (behind its links)
Buffer overflow (Wikipedia, rev 1374582723, 2026-09-12, via Wikimedia Enterprise) (behind its links)
Schick et al. 2023, Toolformer: Language Models Can Teach Themselves to Use Tools (arXiv:2302.04761) (behind its links)
Sumers, Yao, Narasimhan & Griffiths, Cognitive Architectures for Language Agents (arXiv:2309.02427v3) (behind its links)
Wikipedia: Central processing unit (behind its links)
Computer-aided design (Wikipedia, WME snapshot 2026-11-01) (behind its links)
Software engineering (Wikipedia, Wikimedia Enterprise snapshot 2026-11-01 via tools/wme) (behind its links)
Anderson, Why Information Security is Hard: An Economic Perspective, ACSAC 2001 (doi:10.1109/ACSAC.2001.991552) (behind its links)
Artificial intelligence (Wikipedia, via the Wikimedia Enterprise snapshot of 2026-11-01) (behind its links)
Conway ME (1968) How Do Committees Invent? Datamation, April 1968 (author's reprint) (behind its links)
Computer hardware (Wikipedia, via Wikimedia Enterprise snapshot) (behind its links)
Database (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Computer network (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Logic gate (Wikipedia, WME snapshot) (behind its links)
Secure coding (Wikipedia, via Wikimedia Enterprise snapshot) (behind its links)
Therac-25 (encyclopedia) (behind its links)
Lessig L (1999). The Law of the Horse: What Cyberlaw Might Teach. Harvard Law Review 113:501 (author's final draft, Berkman Klein Center). (behind its links)
Computer science (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Mankowitz DJ, Michi A, et al. (2023) Faster sorting algorithms discovered using deep reinforcement learning. Nature 618:257-263. doi:10.1038/s41586-023-06004-9 (behind its links)
Wikipedia: Interrupt (behind its links)
Signal (IPC) (encyclopedia) (behind its links)
Process (computing) (encyclopedia) (behind its links)
Environment variable (encyclopedia) (behind its links)
van Kempen et al. 2024, It's Not Easy Being Green: On the Energy Efficiency of Programming Languages (arXiv:2410.05460) (behind its links)
Executable (encyclopedia) (behind its links)
Quine (computing) (encyclopedia) (behind its links)
Software rot (encyclopedia) (behind its links)
Kocher et al. 2018, Spectre Attacks: Exploiting Speculative Execution (arXiv:1801.01203) (behind its links)
Software crisis (encyclopedia) (behind its links)
Wirth's law (encyclopedia) (behind its links)