EVOPEDIA

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

aliasesSoftware (what the rule unpacks into: programs, languages, compilers, operating systems)
born atend of the 1940s (stored-program computers; EDSAC 1949 'used the first stored computer program'); earlier claims kept in contention C-1132
born precisiondecade; contested
boundaryInside: 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 levelRuns 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.
scaletechnological

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 speed10 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: C2019 milliseconds
CPU share of energy, compiled languages88.94 percent
maintenance share of lifetime cost75 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 software20 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 concentrationfewer 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 growthabout 10,000; +25 to 50% a year computers
OS/360 cost to IBM during preparationover $50 million a year; at least 5000 man-years US dollars; person-years
first use of the word 'software' for programs1958 (Tukey) year
high-level programming languages introduced1958 year
code comprehension accuracy (Python, Experiment 1)85 percent
experience of expert programmers in the logic studyaverage 11 years

Open contentions (5) open contention

Where sources or readings disagree. Both stay on the map.

Partners and parts published science

Built from / builds (15)

Sits inside / holds (12)

Trades with (valence) (32)

expressed by (24)

floor filled by (31)

Kinds (16)

Notes published science

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)

  1. L1: Source text: characters typed by programmers (or generated), kept in files under version control
  2. L2: Lexical analysis and parsing: text into tokens and syntax
  3. L3: Semantic analysis and an intermediate representation
  4. L4: Optimization and machine-specific code generation; linking with libraries into an executable
  5. L5: The executable loaded by the operating system as a process

the boardroom (shared floors)

  1. 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
  2. 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
  3. L6: The application: the task performed for users, as specified and designed
  4. 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)

  1. L1: The machine it runs in: instructions and data as bits in the computer's memory, executed by the processor (fetch, decode, execute)
  2. L2: Machine code: the instruction set architecture, the language the CPU interprets directly
  3. L3: Operating system: loads programs as processes, virtualizes the CPU and memory, serves system calls, turns interrupts into signals
  4. L4: Runtime and libraries: linked libraries, interpreters and virtual machines, the event loop and registered handlers, garbage collection; where inputs arrive (the ports)
  5. L5: The program in a programming language: source code's control flow, functions and modules, each module hiding a design decision
  6. L6: The application: the task it performs for users, as specified and designed (design documents and specifications are part of software)
  7. 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

  1. L1: The computer's clock (its clock channel)
  2. L2: Timer interrupts
  3. L3: The scheduler preempts and resumes the process; timers fire as events

way in: Environment and configuration

  1. L1: User-definable values in the environment a process runs in
  2. L2: Inherited from the parent process at start, with the standard streams
  3. L3: Queried by the running program

way in: Faults and exceptions (the program's own errors)

  1. L1: An anomalous condition in execution, first caught as a CPU-defined interrupt (the first of three layers)
  2. L2: Re-raised as an operating-system signal
  3. L3: Re-raised as a language exception that breaks the normal flow

way in: Files and stored data

  1. L1: Records held on storage media (the computer's storage channel)
  2. L2: The device driver and storage controller read blocks into memory
  3. 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)

  1. L1: Another process's output: a pipeline, shared memory, a client request
  2. L2: The kernel's IPC mechanism (pipe, socket, message queue), synchronous or asynchronous
  3. L3: The call arrives at the interface the program exposes

way in: Network messages

  1. L1: Signals on links carrying packets from other hosts (the Internet's o-delivery)
  2. L2: The network interface raises an interrupt; the driver takes the packet
  3. L3: The kernel's network stack hands the data to the process's socket

way in: Signals (asynchronous notifications from the OS)

  1. L1: An event in the system that concerns the process (interrupt, suspend, terminate, kill)
  2. L2: The kernel turns it into a signal (it may pass a hardware interrupt on as a signal)
  3. L3: Delivery interrupts the process's normal flow

way in: Source code (the build channel: the program's own instructions)

  1. L1: Programmers type the program (a novel cognitive tool, read through sight); models may write it too (LLM walk o-code)
  2. L2: Source files in a version history
  3. L3: The compiler's phases (or an interpreter at run time) translate it to machine code
  4. 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)

  1. L1: A person presses keys, moves a pointer, touches a screen or speaks (the computer's keyboard, touch-pointer and microphone channels)
  2. L2: The device raises an interrupt; the processor saves state and runs the driver's handler
  3. L3: The kernel delivers it to the process as an event or on standard input

way out: Control of machines (embedded software)

  1. L1: Motion and state of the machine in the world
  2. L3: Device commands through drivers (the computer's o-control)
  3. L7: The machine's behaviour the program sets

way out: Energy spent (heat, through the computer)

  1. L1: Heat to the surroundings (the computer's o-heat)
  2. L5: Every instruction run costs energy; most of it in the CPU

way out: Messages and calls to other programs and machines

  1. L1: Signals on links (the Internet's host-traffic channel) or another process's input
  2. L3: The kernel's network stack or IPC mechanism
  3. L7: A request or reply to another program

way out: New processes and new programs (spawning, compiling)

  1. L1: A new process in memory, inheriting the parent's streams
  2. L3: A system call creates and executes a new process
  3. L7: A program that starts or builds another

way out: Screen output (standard output, windows)

  1. L1: Light from the screen, read on Human's sight channel
  2. L3: A system call hands it to the kernel and drivers (the computer's o-display)
  3. L5: The program writes to standard output or draws; errors go to standard error
  4. L7: A result for the person whose activity it serves

way out: Sound

  1. L1: Sound in the room (Human's hearing channel)
  2. L3: System call to the audio driver
  3. L7: A result as sound

way out: Writes to storage (files, logs, version history)

  1. L1: Records on storage, read later by this or other programs (the files channel)
  2. L3: A write system call through the file system
  3. L7: What is kept for later

Sources (68) published science

Von Neumann architecture (Wikipedia, rev 1381757639, 2026-10-24, via Wikimedia Enterprise)
Software (encyclopedia)
Computer program (encyclopedia) (behind its links)
Lehman's laws of software evolution (encyclopedia) (behind its links)
Decan, Mens & Grosjean 2019, An empirical comparison of dependency network evolution in seven software packaging ecosystems, Empirical Software Engineering (arXiv:1710.04936) (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)
Vulnerability (computer security) (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)
RFC 9293: Transmission Control Protocol (TCP) (W. Eddy, ed., August 2022; STD 7) (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)
Yan et al. 2010, Comparing genomes to computer operating systems in terms of the topology and evolution of their regulatory control networks, PNAS 107:9186, doi:10.1073/pnas.0914771107 (behind its links)
Software crisis (encyclopedia) (behind its links)
Wirth's law (encyclopedia) (behind its links)