Basic Core Programming Language 60: Why It Mattered

Basic Core Programming Language 60 (BCPL-60) was a 1960s teaching and systems programming language that mattered because it introduced a minimal, portable approach to writing compilers and operating systems, directly influencing C and countless modern languages. You enter a simple BCPL-style expression, and the calculator below shows how its core operations (addition, multiplication, and bitwise shifts) evaluate, giving you a feel for the language’s stripped-down arithmetic model.

Formula

The calculator uses three basic BCPL-60 arithmetic operations:

• Addition: sum = a + b, where a and b are integers.
• Multiplication: product = a * b, where a and b are integers.
• Left shift: shifted = a * 4, which is equivalent to shifting the binary representation of a left by two bit positions.

All values are unitless integers, as BCPL-60 treated everything as a machine word (typically 16 or 32 bits).

Worked Example

Using the default values a = 5 and b = 3:

1. Sum: 5 + 3 = 8
2. Product: 5 * 3 = 15
3. Left shift: 5 * 4 = 20 (binary 0101 becomes 10100, which is 20)

The calculator outputs 8, 15, and 20, matching these manual calculations.

Background: The Birth of BCPL

BCPL (Basic Combined Programming Language) was developed in 1966 by Martin Richards at the University of Cambridge. It was designed as a systems programming language—one meant for writing operating systems and compilers—rather than for business or scientific applications. BCPL-60 refers to the version of the language described in Richards’s 1969 paper “BCPL: A Tool for Compiler Writing and System Programming.” The “60” in the name is not a version number but a reference to the year the underlying ideas were first sketched (1960), when Richards began working on a language called CPL (Combined Programming Language) with Christopher Strachey. CPL was large and complex; BCPL was its stripped-down, practical descendant.

BCPL-60 mattered because it proved that a language could be both high-level (with structured control flow and procedures) and low-level enough to write an operating system. It introduced the concept of a portable compiler: the compiler was written in BCPL itself, and to port it to a new machine, you only needed to write a small bootstrap routine. This was revolutionary in an era when every computer had its own assembly language and compilers were machine-specific.

How BCPL-60 Worked

BCPL-60’s core design was deliberately minimal. It had only one data type: the word, which was the machine’s natural word size (often 16 or 32 bits). There were no built-in string types, no floating-point numbers, and no records. Instead, the programmer manipulated words using a small set of operators:

• Arithmetic: +, -, *, / (integer division)
• Bitwise: & (AND), | (OR), ~ (NOT), << (left shift), >> (right shift)
• Comparison: =, ~= (not equal), <, >, <=, >=
• Assignment: := (the colon-equals symbol, later adopted by Pascal and others)
• Control flow: IF, UNTIL, WHILE, REPEAT, and a GOTO statement

One of BCPL-60’s most influential features was vector addressing, which allowed a single word to be interpreted as a pointer to an array. This unified pointers and integers, a concept that C later adopted. BCPL-60 also had a global vector, a fixed-size array of words that held all global variables and function pointers—this made it easy to write relocatable code and to implement dynamic linking.

Why It Mattered: The Bridge to C

BCPL-60’s greatest legacy is its direct influence on the C programming language. In 1969, Ken Thompson at Bell Labs created the B language, which was a simplified version of BCPL. B retained BCPL’s typeless word model and its syntax (with some changes). Then, in 1972, Dennis Ritchie evolved B into C by adding types, structures, and other features. The lineage is clear:

• BCPL introduced the { } block syntax that C uses (though BCPL used $( )$ for blocks, the braces came later through B).
• BCPL’s := assignment became = in B and C.
• BCPL’s UNTIL loop became while in C.
• BCPL’s pointer arithmetic and array/pointer equivalence directly influenced C’s pointer model.

Without BCPL-60, C might have looked very different, and without C, Unix, Linux, Windows, and most modern software would not exist as we know them. BCPL-60 also influenced other languages like Go (which borrowed its simplicity), and its compiler-writing techniques are still used in bootstrapping compilers today.

Common Problems and Misconceptions

A common misconception is that BCPL-60 was a “toy” language because of its minimalism. In reality, it was used to write real operating systems, including the TRIPOS operating system (which later ran on the Commodore Amiga) and parts of early Unix research. Another misconception is that BCPL-60 was slow; in fact, because it compiled to efficient machine code, it was often as fast as assembly language.

One real problem with BCPL-60 was its lack of type checking. Since everything was a word, the compiler could not catch mistakes like passing a string where an integer was expected. This led to subtle bugs, and it was one of the main reasons C added a type system. Another problem was that BCPL-60’s global vector could overflow if a program had too many global variables, and debugging was difficult because there was no symbolic debugger for early versions.

How to Choose: When to Use BCPL-60 Today

You would not use BCPL-60 for a modern application—it lacks features like garbage collection, exceptions, and standard libraries. However, it remains relevant in two contexts:

• Learning compiler design: BCPL-60’s compiler is small (about 5000 lines) and readable, making it an excellent study tool for understanding how compilers are structured.
• Historical research: If you are studying the history of programming languages, BCPL-60 is a key milestone.

For new projects, you would choose a modern language like C, Go, or Rust, which offer similar low-level control with better safety. But if you want to see how a minimal language can still be powerful, BCPL-60 is worth examining.

Costs and Availability

BCPL-60 itself is not sold commercially; it is a historical artifact. The original source code and documentation are available from Martin Richards’s website (www.cl.cam.ac.uk/~mr10/bcpl.html) and from various archives. There are also modern compilers for BCPL that run on contemporary systems, such as the Cintcode BCPL compiler, which is free to download. The only cost is your time to learn a language that is quite different from modern ones.

Safety and Accuracy Considerations

When working with BCPL-60 or any low-level language, safety is a concern. Because BCPL-60 has no bounds checking, writing past the end of an array can corrupt memory and cause crashes or security vulnerabilities. If you are experimenting with BCPL-60, run it in a virtual machine or a sandboxed environment. For modern programming, always use languages with memory safety features (like Rust or Go) or use careful bounds checking in C.

Frequently Asked Questions

Is BCPL-60 the same as BASIC?

No. BCPL stands for Basic Combined Programming Language, but it is not the same as BASIC (Beginner’s All-purpose Symbolic Instruction Code). BCPL-60 was a systems programming language for experts, while BASIC was designed for beginners. They share the word “Basic” but have different syntax, philosophy, and use cases.

What does the “60” in BCPL-60 mean?

The “60” refers to the year 1960, when the precursor language CPL was first conceived. It is not a version number; it is a historical marker. The language itself was developed in the mid-1960s.

Can I run BCPL-60 programs today?

Yes, you can. Martin Richards maintains a modern BCPL compiler (Cintcode) that runs on Windows, Linux, and macOS. You can download it from his website and compile BCPL-60 programs, though you may need to adapt them to the modern compiler’s syntax.

Why did C become more popular than BCPL?

C added a type system, which caught many errors at compile time, and it had a more familiar syntax (using braces and semicolons). C also was developed alongside Unix, which became the dominant operating system, giving C a massive advantage. BCPL-60 remained popular in academia but never gained the commercial traction of C.

What is the most important thing BCPL-60 taught us?

BCPL-60 demonstrated that a language can be simple enough to fit in a small compiler yet powerful enough to write an entire operating system. This philosophy of minimalism and portability is still relevant today, as seen in languages like Go and in the design of modern virtual machines.

Related

• JEV Security: Isolation, Permissions & Incident Response
• Future Tech Enhance Humans? Facts & Limits
• How to Upgrade Skill Gems in Path of Exile

in a | First value | - | 5 | -1000000 | 1000000
in b | Second value | - | 3 | -1000000 | 1000000
out sum | Sum (a + b) | - | a + b | 0
out product | Product (a * b) | - | a * b | 0
out shifted | a shifted left by 2 | - | a * 4 | 0