How C Came to Be

One of the most important things to come from Bell Labs computer science research was the C language. Here is how it happened.

In my previous post I tell how I came to join the computer science research department at Bell Labs. When I joined it, in 1966, the MULTICS project to build a second-generation time sharing system was well underway and, as many of us thought, well on it’s way to failure. Rather than join directly in the implementation of MULTICS, I opted to work on programming languages to support the MULTICS effort.

A year of so before I joined the project, a consulting firm had been hired by Bell Labs to build a compiler for the PL/1 language, for use with MULTICS. The PL/1 project was well overdue and over budget. I got the job of supervising this effort. For one summer I commuted daily from New Jersey to New York where the contractor had their office. After a couple of months I recommended that the project be terminated. I did not see much hope of it being completed satisfactorily. The compiler in it’s incomplete state, with all supporting documentation, was recorded on a large reel of magnetic tape and stored in a drawer of my desk at Bell Labs. I don’t know what eventually happened to this very expensive reel of tape. I suppose it was thrown away. Shortly after this another PL/1 compiler for MULTICS was built at General Electric (GE).

Meanwhile, we needed a better language for systems programming. At M.I.T. I had come across the BCPL language (Basic Cambridge Programming Language). This small and efficient language was invented by Martin Richards of Cambridge University. He was on sabbatical at M.I.T, so I contacted him and asked for permission to implement BCPL at Bell Labs for the GE 635 computer. He agreed.

As I remember it, Martin Richards invented BCPL as a language to be used in building CPL, the Cambridge Programming Language. CPL, like MULTICS, was too ambitious, unnecessarily complex, and never really succeeded. BCPL, which was designed for building compilers, turned out to be well suited for any programming task that needed to be close to the hardware. In particular it was well suited to building operating systems.

Dennis Ritchie and I implemented a BCPL compiler. I wrote the compiler and Dennis wrote the supporting routines for input and output and the mathematical library (routines for doing mathematics). I wrote the user’s manual. (I wish I still had a copy.) BCPL quickly became the language of choice for many programmers in the research area as well as others in Bell Labs. It is the language in which UNIX was first written.

Meanwhile, an informal contest had arisen among the computer science researchers to see who could write the most complex computer program in a single statement, using any language. Ken Thompson became very active in this contest and decided to write a programming language to use. The language he wrote was named “Bon” after his wife Bonnie. As I remember, Ken won the “most complex statement” contest. This makes sense, since Ken was by far the most brilliant programmer I have ever known.

BCPL became the basis for a new language designed by Dennis and Ken which also incorporated several ideas from Bon. BCPL plus Bon leads to a language called, of course, “B.” B was a short-lived language, not much used, but it is important because Dennis took B and used it as the basis for a new language called “C.”

The C programming language, of course, is one of the most influential computer languages ever built. There is some controversy about how the name “C” came about, but my memory is that it was just the logical name to come after “B,” which was the logical name to come from combining BCPL and Bon. So “C” does not stand for anything. It’s just the name for the language.

Less than two years after I joined the computing science research department, Bell Labs management finally saw the handwriting on the wall and abandoned the MULTICS project. GE, and perhaps M.I.T, continued with the project and MULTICS was finally completed and was offered as a product by GE. It was never much used.

The bitter taste that the MULTICS failure left for Bell Labs management turned out to be significant in the evolution of UNIX and in my career, as I will relate in my next post, How UNIX Came to Be.

– Rudd Canaday (

    – Start of blog: My adventures in software
    – Previous post: How I Beat and Joined MULTICS
    – Next post: How UNIX Came to Be

Share this post:

This entry was posted in Rudd's Blog, Uncategorized and tagged , , , , , . Bookmark the permalink.