Why C was created
Connect C’s origins to Unix, earlier languages, and the practical problem of writing systems software.
In this chapter9 sections
Why did people create C when other languages already existed? Its designers needed a practical way to build systems software, including Unix. That problem helps explain many choices you will meet in the language.
1. The setting was systems software
An operating system manages resources and provides services to other programs. Its code needs to organise data and work with hardware and existing interfaces. Early Unix work at Bell Labs gave C’s designers real systems problems on which to test their ideas.
Assembly language is closely tied to a machine’s instructions. It can offer necessary control, but moving a large assembly program to another machine can require extensive changes. A higher-level language can express data and operations without spelling out each instruction. That makes larger software more practical to maintain.
2. C had predecessors
C grew from earlier languages. Martin Richards developed BCPL. BCPL influenced B, associated mainly with Ken Thompson. Dennis Ritchie developed C at Bell Labs as Unix evolved. This is a line of influence, not a set of interchangeable languages.
- BCPL
- B
- C
- C used in Unix
The diagram is not a family tree of every influence. Programming languages evolve through experiments, implementation constraints, and feedback from users. Knowing a predecessor’s name can explain a design choice; it does not mean that learning that predecessor is a prerequisite for learning C.
3. The development was a period, not one instant
Ritchie describes C’s emergence over 1969–1973, with especially active development in 1972. That is why histories often mention 1972. Think of a period of experiments and improvements, rather than a single day on which modern C appeared fully formed.
A major Unix milestone was the rewriting of much of its kernel in C in 1973. “Much of” matters: low-level, machine-dependent parts did not all disappear. Neither did that one milestone instantly make every program portable. Later compiler work, porting experience, and standardization helped establish the wider use of C.
4. Types made more structured data practical
C developed a richer type system than B. Types for characters and other data, along with pointers, arrays, and structures, helped describe systems data. You do not need to know all these features yet. The important connection is that the language evolved to express real program needs.
The language also retained a relatively small core and allowed economical expressions of common operations. Its control structures and functions helped organize programs, while pointers and representations allowed work that needs careful control of data. These choices offered useful trade-offs, with responsibilities that a beginner should learn explicitly.
5. Portability is a property to design for
C can make a program easier to move between systems, but portability still needs care. The program may assume a particular integer width, encoding, layout, or operating-system interface. Learn the language guarantees, then record any extra assumptions your program needs.
A modern desktop compiler may accept extensions beyond the chosen C revision. An extension can be useful while still restricting where the program works. “My compiler accepts it” and “the C standard guarantees it” answer different questions. This distinction connects the history of a flexible systems language to everyday decisions in a current program.
6. Read modern C in its own context
The C you study today includes decades of later language and library work. This reader uses C17 as its default baseline and marks C23-specific material. Some old teaching examples rely on conventions that should not be copied as universal rules. Historical importance explains why a feature exists; it does not by itself establish that a particular old practice is appropriate now.
Does rewriting a large part of an operating system in C prove that every C program works unchanged on every computer?
Read the explanation
No. It demonstrates C’s usefulness for that systems work. A program’s portability still depends on language rules, implementation choices, environment interfaces, and its own assumptions.
Primary references and further reading
- Dennis M. Ritchie — The Development of the C Language: The original historical account for the BCPL/B lineage, development period, and Unix context.
- WG14 N1570 — public C11 committee draft: Sections 4 and 5 help distinguish conformance and implementation environments from broad historical claims.
Before you move on
- C developed from earlier language ideas alongside practical Unix systems work.
- Types and structured operations helped express systems data beyond machine-specific instructions.
- Portability still depends on language guarantees and documented environment assumptions.
Keep these ideas separate
- Historical goal / Current guarantee
- A design goal explains motivation; the selected C edition and platform contracts define what a current program may rely on.
Which problem helped make C useful for Unix, and why did that not make every C program automatically portable?
Optional: say it aloud or keep a note. You can continue whenever you are ready.Check your understanding
Optional. Answers are not saved or sent, and reading stays unrestricted.
Read the explanation for every choice
- Implementing systems software, including Unix.
✓ Correct reasoning. C developed alongside Unix and grew from earlier systems-language work.
- Guaranteeing that every program works unchanged on every machine.
C’s history does not remove a program’s implementation and environment assumptions.
- Replacing every machine-specific operation with automatic safety checks.
C still requires explicit attention to bounds, lifetimes, and interfaces.
General
Quick reference from the earlier edition
This compact reference keeps existing links and saved passages available. Read the expanded lesson above for the full context.
C was developed by Dennis Ritchie at Bell Labs during the early 1970s, alongside Unix. Ritchie describes its development as spanning 1969–1973, with the most creative period in 1972. The aim was a practical systems language with useful types and efficient operations, rather than a language invented fully formed on one date.
Its predecessors were Martin Richards' BCPL (developed in the 1960s) and Ken Thompson's B (around 1969–1970). BCPL and B used a word-oriented, largely typeless model. Ritchie's changes to B introduced a richer type system and evolved into C; arrays, pointers, and structures developed as part of that process.
C's initial implementation targeted the DEC PDP-11 and was used to rewrite the Unix kernel, marking a significant milestone in software portability and maintainability. The language's design was influenced by the need for efficient system programming, direct hardware manipulation, and the desire for a concise yet powerful syntax.
Ready for the next idea?
Mark this chapter as read whenever you feel ready.