Programs and Source Code Are Different Things
Software exists in two main forms. The executable form is what a computer runs: a sequence of instructions in a format the machine can use directly. The source code is the version written by programmers, in a human-readable programming language, which is then translated by a compiler or interpreter into the executable form.
Both are worth keeping, for different reasons. An executable shows what users actually experienced. Source code shows how it was made: what the author was trying to do, the shortcuts taken, the comments left for colleagues and the way a problem was divided up. For historians of software, reading source is akin to reading a draft manuscript.
Source code is also much rarer than the programs themselves. Companies commonly kept it private, and when a product was discontinued, the source often went with it. Sometimes only the final released program survives, and researchers work backward from it.
What Software Archives Collect
Several kinds of institutions keep software.
Libraries, universities and national archives. Some hold collections of commercial software and related papers, often as part of the effort to keep the cultural record. They tend to focus on documentation, careful cataloging and long-term storage.
Museums. Alongside machines, computer museums keep the software that ran on them, so that exhibits are more than empty hardware.
Companies. A few organizations keep historical collections of their own products or release old code for study. Such releases are usually made under particular conditions, and they differ from one company to another.
Volunteer communities. Enthusiasts have gathered a large share of preserved software, scanning disks, imaging tapes and sharing programs for old home computers, games and utilities. Their work covers material that official bodies have not had the resources to handle.
Typical holdings include operating systems, programming tools, games, business applications and educational programs, together with their manuals and packaging. The earliest software was often delivered as part of a machine or shared among users of the same system, which affects what has survived from the era of early software.
How Code Is Kept
Archiving a program takes more than copying a file. Careful archives aim to capture:
- The exact bits, as an image from the original medium, with checksums to confirm nothing changed. This is where media migration comes in.
- Versions and dates. Software was updated frequently, so a version number or date is vital for knowing what was captured.
- Dependencies. Which hardware, operating system, libraries or settings did the program need?
- Documentation. Manuals and notes, and where available the build instructions that turn source code into a working program.
- Context. Who wrote it, who used it, and why.
Source code that survives only on paper, such as printed listings, may need scanning and careful typing or optical recognition, and the transcription must be checked for errors. Some historic listings have been published or reconstructed by volunteers who compared several copies.
Version control systems, which track every change to a codebase, are a modern bonus. When a project’s history is saved, researchers can follow its development step by step, which was impossible for older software that was not tracked this way.
Running What You Have Saved
An archived program is not much use if no one can run it. Original hardware can run it, but is scarce. Emulation software allows the program to run on current machines, and archives often store the software together with details of a suitable emulator. For some programs, a historian may need to rebuild the original program from the source code, which requires the right tools and sometimes older versions of compilers and interpreters. Without them, the code may not build, or may produce a different result from the original.
Legal and Ethical Hurdles
Software is generally protected by copyright, which in many countries lasts a very long time. Programs that are no longer sold may still be legally restricted, and the owner may be unknown, a company that no longer exists or one whose assets were sold on. This can make it uncertain who can grant permission to copy or share.
Rules differ between countries, and exceptions for libraries and archives vary widely. Some institutions can preserve material but not distribute it freely, while others negotiate permissions with rights holders. Readers who wish to share or use old software should check the terms that apply, since the answer depends on the specific program and place.
There are ethical questions too. Source code may contain personal data, confidential business information or security weaknesses. Early code was also written by many people who were never credited, and archives increasingly try to record their names.
Why Old Code Is Worth Studying
Historic source code supports several kinds of research. It shows how programmers managed tiny memories and slow processors, how conventions of programming languages like COBOL and FORTRAN developed in practice, and how designs changed from one release to the next. It can settle disputes about who wrote what and when, or confirm that a famous program behaved the way people remember. It also gives students concrete examples of earlier approaches, some of which are still instructive.
A caution applies: source code alone does not tell the whole story. Comments can be missing or misleading, and the final behavior of a program depends on its data and its environment. Reading the code together with manuals, correspondence and interviews gives a more reliable picture.
An Open Question
Software preservation is still unsettled. Modern programs depend on online services, constant updates and licenses that stop working when a server is switched off, which makes them harder to keep than the disks of earlier decades. The people working in this field are developing methods now, and many agree on a basic principle: capture the software, its documentation and its context as early as possible, because waiting usually makes the task harder.