YOUR C LEARNING COMPANION

Find your next idea.

Learning path
Before CChapter 5 of 73

Why C was created

Connect C’s origins to Unix, earlier languages, and the practical problem of writing systems software.

5 min readFoundationsHistory
Offline reading
In this chapter9 sections
0% through this chapter

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.

  1. BCPL
  2. B
  3. C
  4. C used in Unix
A simplified relationship between earlier languages and C’s practical setting; Unix and C influenced each other during development.

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.

Think it through

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

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.
Explain it in your own words

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.

Which practical need helped shape C’s early development?
Read the explanation for every choice
  1. Implementing systems software, including Unix.

    ✓ Correct reasoning. C developed alongside Unix and grew from earlier systems-language work.

  2. Guaranteeing that every program works unchanged on every machine.

    C’s history does not remove a program’s implementation and environment assumptions.

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

CHAPTER 05 / 73

In this chapter

Why C was created

Search all 73 chapters in both languages.EN + HG

Try “pointer”, “why int”, or “undefined behavior”.

Concepts connect. Follow your curiosity.↑ ↓ to explore · Enter to open
MAKE YOURSELF COMFORTABLE

Your reading space

Appearance

A clear canvas with balanced contrast.

Text size

100%
AA

Reading tools

Your data stays in this browser

Export a backup before changing browsers or replacing an older version of the reader.

YOUR PERSONAL MARGINS

My notebook

Saved on this device
A LITTLE CLARITY

The glossary

A starting meaning, then a chapter to go deeper.

A QUICK DEFINITION

A little clarity

Read the full explanation →

A thought worth keeping