Why is c called c? It sounds like a simple question, and at first glance the answer seems almost too obvious: C follows B in the alphabet, and C followed B as a programming language. But that single sentence conceals one of the most fascinating stories in the entire history of computing. Behind the name lies a chain of intellectual inheritance stretching from Cambridge to New Jersey, from Martin Richards to Ken Thompson to Dennis Ritchie, from a language called BCPL through a stripped-down successor called B to the revolutionary creation that became C. Understanding why is c called c means understanding how programming languages evolve, how brilliant engineers build on each other’s work, and how a name chosen almost casually in a research lab became the label for a language that would quietly power the modern world.
The Question That Stops Many Programmers Cold
Ask a room full of experienced developers why is c called c, and a surprising number will pause. The alphabetic logic seems self-evident, yet it raises an immediate follow-up question: if C came after B, what came before B? And if there was a B, was there ever an A? The answer to that last question is no, and that fact alone begins to reveal how unconventional the naming history of C actually is.
The story does not start with a letter. It starts with a name, BCPL, the Basic Combined Programming Language, and with the practical pressures that drove a small team of extraordinary engineers at Bell Labs to keep rewriting the tools they used to build operating systems. Each iteration shed complexity and gained precision. Each step forward earned a shorter name. By the time the process was finished, a language of profound power wore the simplest possible label: one letter, chosen because it was next in line.
Where It All Began: BCPL and Martin Richards (1967)
To truly answer why is c called c, you must begin in Cambridge, England, in 1967. Martin Richards, a British computer scientist working at the Mathematical Laboratory of the University of Cambridge, created a language he called BCPL: the Basic Combined Programming Language. Richards designed BCPL as a practical tool for writing system software and compilers. It was lean, portable, and typeless, meaning it treated all data as machine words without distinguishing between integers, characters, and memory addresses.
BCPL was a significant advance for its time. It compiled to a portable intermediate code that could be retargeted to different hardware architectures, a remarkable property in an era when most system software was written in assembly language and was therefore completely non-portable. BCPL gave programmers a way to write system-level code in something approaching a human-readable form.
However, BCPL had real limitations. Its typeless nature, while simplifying the language, made it imprecise and sometimes dangerous. On machines where different kinds of data needed to be handled differently at the hardware level, BCPL’s single-type model was a handicap. It was a powerful starting point, but it was not the final destination.
Ken Thompson Takes BCPL to Bell Labs: The Birth of B (1969)
The next chapter in answering why is c called c takes place at Bell Telephone Laboratories in Murray Hill, New Jersey, in 1969. Ken Thompson, one of the most gifted systems programmers of his generation, encountered BCPL while working on the Multics project, a joint effort between MIT, Bell Labs, and General Electric to build an advanced time-sharing operating system. When Bell Labs withdrew from Multics, Thompson did not abandon his vision of building a new operating system. He simply started over, smaller and smarter.
Working on a discarded PDP-7 minicomputer, Thompson began creating what would become UNIX. To write it, he needed a programming language suited to the constrained memory environment of the PDP-7. He took BCPL as his foundation and stripped it down even further, producing a new language adapted specifically for the machine he was working with. He called it B.
Why B? Because BCPL begins with a B, and Thompson’s creation was a direct descendant of it, simplified and adapted. The B language inherited BCPL’s typeless philosophy and its basic structure while removing features that did not fit the tight memory constraints of the PDP-7. B was functional, usable, and genuinely useful for writing system software. Thompson used it to write early components of UNIX and several utility programs.
/* B language style - typeless, word-oriented */
/* All values treated as machine words */
main() {
auto x, y, sum;
x = 10;
y = 20;
sum = x + y;
putchar('S');
putchar('u');
putchar('m');
}This illustrates B’s typeless character: variables declared with auto without any type specification because there was only one type, the machine word. Everything was stored and manipulated as a word-sized value, whether it held an integer, a character, or a memory address.
Why B Was Not Enough: The Problem That Created C
Understanding why is c called c requires understanding the specific technical problem that forced the creation of a new language. When Bell Labs acquired a PDP-11 minicomputer, the limitations of B became impossible to ignore. The PDP-11 had a richer architecture than the PDP-7, and critically, it was a byte-addressable machine. Individual bytes, not just whole machine words, could be directly addressed in memory.
B’s word-oriented, typeless model was a perfect fit for word-addressable machines like the PDP-7. On the PDP-11, it was a serious mismatch. B could not efficiently address individual bytes, could not distinguish between different sizes of data, and could not cleanly handle the variety of data types that real system programming required. Porting UNIX to the PDP-11 was going to require either an uncomfortable series of workarounds in B or a better language.
Dennis Ritchie chose to build a better language. He began extending B, adding a type system that allowed programmers to declare variables as specific kinds of data: integers of various sizes, characters, pointers, and eventually structures grouping multiple data fields together. This was not a minor enhancement. The addition of types fundamentally changed the nature of the language. It was no longer really B at all. It was something new.
Dennis Ritchie Names the Language C (1971 – 1972)
By 1971 and 1972, Dennis Ritchie had developed his new language far enough that it deserved its own identity. The question of why is c called c has its most direct answer here: the name was the next logical step in the lineage. The language came after B and was derived from it, so the name C was the natural successor. Ritchie initially referred to the evolving language as NB, standing for New B, which makes the naming logic transparent. NB became C when the language had diverged sufficiently from B to warrant a distinct identity.
The choice of a single letter was consistent with the minimalist philosophy that permeated Bell Labs’ approach to system design. UNIX commands were given the shortest possible names. Programs were designed to do one thing well. A language named with a single letter fit perfectly into this aesthetic of radical economy. Why is c called c? Because Dennis Ritchie and his colleagues valued simplicity and precision, and nothing is simpler or more precise than the letter that follows the letter your predecessor used.
/* Early C - NB transitional style (circa 1972) */
/* Type system emerging - int explicitly declared */
int add(x, y)
int x;
int y;
{
return x + y;
}
main()
{
int result;
result = add(15, 25);
printf("%d\n", result);
}Notice the emergence of the int type declaration, which was absent in B. This is the critical innovation that made C distinct from its predecessor and justified a new name. The type system was not cosmetic; it was the entire point.
Was There Ever an A Language?
One of the most common questions that arises alongside why is c called c is whether there was ever an A language that preceded B in the same lineage. The answer is no. The alphabetic naming of B and C was not part of a planned sequence that began with A. B was named after BCPL, whose name happens to start with B. C was named after B. The alphabet connection is real but it does not extend backward.
There are other languages with single-letter or near-single-letter names, and some of them arrived at those names through completely unrelated paths. The D programming language, developed by Walter Bright and Andrei Alexandrescu, was named as a successor to C and explicitly continues the alphabetical theme. However, D was created decades after C and chose its name as a deliberate homage to the B-C naming tradition, not as part of the original sequence.
The fact that there is no A language in the BCPL-B-C lineage is actually important evidence about why is c called c. The name was not chosen to complete an alphabetical set or to suggest that C was the third in a comprehensive series. It was chosen because B came before it and because the minimalist culture at Bell Labs embraced the simplest possible identifier for a new tool.
Why Is C Called C: The Technical Differences That Justified a New Name
The naming question and the technical question are inseparable. Why is c called c rather than just being called a new version of B? Because the changes Ritchie made were so fundamental that calling the result B would have been misleading. B was typeless. C had types. B treated all data as machine words. C distinguished between characters, integers of different sizes, floating-point numbers, and pointers. B had no struct keyword. C introduced structures that allowed programmers to bundle related data into named composite types.
These were not refinements. They were architectural changes that altered how programmers thought about data and memory. A language with a full type system operates differently, fails differently, and enables different kinds of software than a typeless language. Calling C a version of B would have been like calling a car a version of a bicycle because both have wheels. The connection was real but the difference was categorical.
/* C demonstrating type system - impossible in B */
#include <stdio.h>
struct Point {
int x;
int y;
};
int main(void) {
char letter = 'A'; /* char type */
int count = 100; /* int type */
float ratio = 3.14f; /* float type */
struct Point p = {10, 20}; /* struct type */
printf("Letter: %c\n", letter);
printf("Count: %d\n", count);
printf("Ratio: %.2f\n", ratio);
printf("Point: (%d, %d)\n", p.x, p.y);
return 0;
}This code would have been impossible to write in B. Every construct here, the char type, the int type, the float type, and especially the struct, represents something C introduced that B could not express. That depth of difference fully justified the new name.
The C Programming Legacy and the Name That Conquered Computing
Once you understand why is c called c, you begin to appreciate the profound irony embedded in that simple name. A language chosen almost pragmatically, named with minimal ceremony by engineers who had more important things to think about, went on to become perhaps the most influential programming language ever created. The C programming legacy reaches into virtually every domain of modern software.
The name C was chosen because it was convenient and logical, not because anyone imagined it would endure for half a century. Dennis Ritchie and Ken Thompson were trying to build a better operating system on a discarded minicomputer. The fact that their tools would outlast every competing language of their era was not part of the plan. It was the consequence of having built something genuinely excellent.
For anyone exploring the history of c programming, the naming story is more than trivia. It is a window into the culture that produced C: practical, minimalist, focused on solving real problems rather than on making grand statements. That culture is encoded in the language itself. C does not protect you from mistakes. It does not hold your hand. It gives you precisely the tools you need and trusts you to use them correctly.
Those who want to understand how C evolved into its most direct successor will find that examining C vs C++ illuminates how Bjarne Stroustrup built on Ritchie’s foundation while preserving the essential character of C, including, notably, its name.
For newcomers ready to experience this legacy firsthand, C programming for beginners is still one of the most rewarding starting points in all of programming education. And for those who want to understand what C looks like at the systems level, studying C syntax basics reveals exactly the kind of lean, precise, typeful design that separated C from B and earned it its own letter.
How the Name C Spread Around the World
The story of why is c called c does not end with its creation. It continues with how the name spread. When Dennis Ritchie and Brian Kernighan published “The C Programming Language” in 1978, the book’s extraordinary clarity introduced C to programmers worldwide. Universities adopted it. Compiler vendors implemented it. The name C became synonymous with system programming.
When ANSI standardized the language in 1989, the formal designation was C89, cementing the single-letter name as the official international standard. Every subsequent standard, C99, C11, C17, C23, has maintained the same naming convention, appending only the year. The letter has remained constant through five decades of evolution because changing it would have been unthinkable. C is C. The name is inseparable from the language.
Languages that followed and drew inspiration from C often chose their names in explicit reference to it. C++ means C plus one increment, a programmer’s joke about the language being one step beyond C. C# takes the musical notation for a note one semitone above C natural. Objective-C announces itself as an objective-oriented extension of C. Every one of these names implicitly answers why is c called c by treating the name as a fixed point around which the entire ecosystem of C-derived languages orbits.
Frequently Asked Questions
Why Is C Called C and Not Something Else?
Why is c called c comes down to linguistic lineage. C was directly derived from B, a language created by Ken Thompson at Bell Labs in 1969. B was itself derived from BCPL, the Basic Combined Programming Language created by Martin Richards in 1967. When Dennis Ritchie created a new language that extended and fundamentally changed B by adding a type system, he named it C because it was the successor to B, just as B had been the successor to the B in BCPL. The alphabetic logic was simple, practical, and consistent with Bell Labs’ culture of minimal, efficient naming.
Was There a Programming Language Called A Before B?
No. There was no A language in the BCPL-B-C lineage. B was named after BCPL, not as the second in an alphabetical series starting with A. The alphabetical sequence begins with B and continues with C. D, the programming language created by Walter Bright, later extended the sequence deliberately as an homage to the B-C tradition, but A was never part of the original chain.
What Was Wrong With B That Required Creating C?
B was a typeless, word-oriented language that treated all data as machine words. When Bell Labs moved to the PDP-11, a byte-addressable machine, B’s limitations became critical. It could not efficiently address individual bytes, could not distinguish between different data sizes, and could not handle the variety of data types that real system software required. Dennis Ritchie solved these problems by adding a full type system, creating a language different enough from B to deserve its own name.
Who Actually Named the C Language?
Dennis Ritchie is credited with creating and naming C, developing it between approximately 1969 and 1972 at Bell Labs. The language evolved from his work extending B, and he initially referred to the evolving language as NB, for New B. As the language developed further from B’s design, the name C emerged naturally. The precise moment of naming was not a dramatic announcement; it was a practical decision made in the course of daily engineering work.
How Did C Get Its Own Standard and Official Name?
C was formally standardized by the American National Standards Institute in 1989, producing the specification known as C89 or ANSI C. The International Organization for Standardization subsequently adopted and published it as ISO/IEC 9899:1990. This official standardization locked in the single-letter name permanently. Subsequent standards, C99, C11, C17, and C23, have all maintained the C designation with only the year appended, confirming that the name chosen informally by Dennis Ritchie in the early 1970s has become permanently embedded in the international standards system.
Did Any Other Languages Influence the Name C?
The name C was influenced entirely by B and through B by BCPL. No other languages contributed to the naming. However, C’s name has since influenced an entire family of successors. C++ appended the increment operator to suggest advancement beyond C. Objective-C combined C with Smalltalk-inspired syntax. C# used musical notation to suggest another step up. All of these names treat C as a fixed reference point, which is perhaps the ultimate evidence of how completely the single letter has come to represent a foundational concept in programming.
Conclusion
Why is c called c is one of those questions that opens into a much larger story than the questioner typically expects. The answer begins with BCPL and Martin Richards in Cambridge in 1967, runs through Ken Thompson’s B language on a discarded PDP-7 at Bell Labs in 1969, and arrives at Dennis Ritchie’s revolutionary addition of a type system that transformed B into something genuinely new by 1972. The name C was chosen because it was next in the alphabet and because the minimalist culture at Bell Labs valued concision in everything, including the names of their tools.
What makes this naming story genuinely remarkable is not the logic of the alphabet but the durability of the result. Why is c called c today, fifty years after that choice was made, is answered not just by history but by the enduring power of the language itself. C earned the right to keep its name by proving indispensable across half a century of computing evolution. It runs operating systems, embedded systems, compilers, databases, and network infrastructure. It shaped the syntax of virtually every major language that followed it.
The C programming legacy is, in the end, the most compelling answer to the naming question. Why is c called c? Because C built the world that all of us, programmers and non-programmers alike, now live inside. A name that simple, attached to a contribution that vast, deserves to be remembered.
