Non-fiction: B (programming language)

Overview

B is a small, typeless systems programming language created by Ken Thompson at Bell Labs in 1969. It descended from Martin Richards' BCPL but was pared down and simplified to suit the severe memory and processor constraints of late 1960s minicomputers. Designed as a higher-level alternative to assembly, B provided a concise syntax and a single machine-word data model that made it possible to write operating-system code and utilities more quickly than was practical in assembler.
B was developed in the environment that produced early Unix, and it played a direct role in the move away from hand-coded assembler toward portable, maintainable system software. Its design prioritized compactness and expressiveness for low-level programming tasks, trading away a rich type system in favor of flexibility and minimal runtime overhead.

Language design

At the core of B is a typeless philosophy: data is represented as machine words rather than distinct, strongly-typed entities. Variables hold untyped words; operations treat those words as integers, pointers, or sequences of bits depending on context. This simplicity reduced the language implementation footprint and matched the realities of hardware where a "word" was the natural unit of computation.
The syntax and semantics of B are terse and expressive, with control structures and expression forms that echo BCPL but are streamlined. The language omitted many of the higher-level abstractions that later languages would provide, such as a full suite of scalar types and structured user-defined types. That omission made some programming patterns awkward or error-prone by modern standards, but it also kept the compiler and generated code compact.

Implementation and use

B was implemented to run on the small minicomputers of its day and was closely tied to the hardware characteristics of those machines. Thompson used B to rewrite portions of early Unix and to develop utilities and tools more rapidly than would have been feasible in assembly. The language was suitable for system-level programming because it provided direct control over memory and representation while offering slightly more structure and readability than raw machine code.
Because B was intended for constrained hardware, its compilers and runtime were deliberately lightweight. Programs often relied on implicit conversions and on a programmer's awareness of the underlying machine representation. That freedom made it efficient but also led to portability and safety issues when software moved to different architectures or grew in complexity.

Influence and legacy

B's chief legacy is as a technical and historical bridge between BCPL-era typeless languages and the strongly typed systems languages that followed. Its use in the Unix environment highlighted both the advantages of higher-level system programming and the limitations of a typeless model. Those lessons were central to Dennis Ritchie's development of C, which preserved B's efficiency and systems-orientation while introducing a richer type system, explicit data types, and structures that made large-scale system programming more robust and portable.
While B itself saw only limited adoption beyond its original context, its ideas shaped the trajectory of systems programming. The practical demonstration that operating systems could be written in a high-level language helped shift industry practice away from assembler. Today, B is primarily of historical interest, studied for its role in the evolution of Unix and C and for the way it reflects programming tradeoffs on memory-constrained hardware.