On October 14, 1985, a book titled The C++ Programming Language arrived in bookstores across the United States. Its author, a 35-year-old Danish computer scientist working at AT&T Bell Labs in Murray Hill, New Jersey, had spent the previous six years building something that would fundamentally reshape software engineering. Bjarne Stroustrup had created C++ — a language that combined the raw hardware-level power of C with the organizational clarity of object-oriented programming. Within a decade, C++ would power operating systems, game engines, databases, browsers, and financial trading platforms. By 2026, it remains the third most popular programming language worldwide according to the TIOBE Index, with an estimated 4.4 million active developers. The Windows kernel, most of Adobe’s Creative Suite, the Unreal Engine, MySQL, MongoDB, and large sections of Google’s infrastructure all rely on C++ code written and maintained over more than four decades. Few languages have demonstrated such staying power, and fewer still have shaped as many other languages as C++ has.
Early Life and Path to Technology
Bjarne Stroustrup was born on December 30, 1950, in Aarhus, Denmark’s second-largest city. He grew up in a working-class family — his father was a laborer and his mother worked at a local office. Stroustrup attended Aarhus University, where he earned a master’s degree in mathematics and computer science in 1975. His master’s thesis work involved the Simula programming language, a language created by Norwegian computer scientists Ole-Johan Dahl and Kristen Nygaard that introduced the concept of classes and objects to programming. Simula left a deep impression on Stroustrup. He admired its expressiveness and organizational power but was frustrated by its poor performance — Simula programs ran far too slowly for systems-level work.
In 1979, Stroustrup completed his PhD at the University of Cambridge in England under the supervision of David Wheeler. His doctoral research focused on the design of distributed computing systems, and during this work he experienced firsthand the tension between high-level abstractions and efficient execution. He then joined AT&T Bell Labs — the same research institution where Dennis Ritchie and Ken Thompson had created Unix and the C language just a few years earlier. This environment, surrounded by the creators of some of computing’s most foundational tools, became the birthplace of C++.
The Breakthrough: Creating C++
The Technical Innovation
When Stroustrup arrived at Bell Labs, he needed a tool for his work on distributed systems — something that had Simula’s ability to organize complex programs with classes and inheritance, but with C’s speed and access to hardware. No such tool existed, so in 1979 he began building one himself. He started with a preprocessor called “Cpre” that translated a language he called “C with Classes” into plain C code, which could then be compiled with any existing C compiler.
The initial version added classes, derived classes, strong type checking, inlining, and default arguments to C. By 1983, the language had grown significantly — adding virtual functions, function and operator overloading, references, and the const keyword — and was renamed C++ (the “++” being the C increment operator, a nod suggested by Rick Mascitti). In 1985, the first commercial implementation, Cfront 1.0, was released along with Stroustrup’s reference book.
A key design decision was the “zero-overhead principle” — you should not pay a runtime cost for features you do not use. This meant that a C++ program using only C-like features would run exactly as fast as the equivalent C program. Object-oriented features like virtual function dispatch only added overhead when explicitly requested by the programmer. This principle made C++ acceptable in performance-critical domains where languages like Simula could never compete.
The class mechanism in C++ allowed programmers to define their own types that behaved like built-in types. Consider a simple example of the core idea:
class Vector {
double* elem; // pointer to elements
int sz; // number of elements
public:
Vector(int s) : elem{new double[s]}, sz{s} {
for (int i = 0; i != s; ++i) elem[i] = 0;
}
~Vector() { delete[] elem; } // destructor: release resources
double& operator[](int i) { return elem[i]; } // subscript access
int size() const { return sz; }
};This pattern — Resource Acquisition Is Initialization (RAII) — became one of C++’s most influential contributions to programming language design. The constructor acquires a resource (heap memory), and the destructor automatically releases it when the object goes out of scope. No garbage collector needed. This deterministic resource management would later influence Graydon Hoare’s design of Rust and its ownership system.
C++ continued to evolve through the 1990s. Templates, introduced in 1990 and standardized in C++98, enabled generic programming — writing code that works with any type. The Standard Template Library (STL), designed by Alexander Stepanov, provided containers (vectors, maps, lists), algorithms (sort, search, transform), and iterators that became the backbone of C++ programming:
#include <vector>
#include <algorithm>
#include <iostream>
int main() {
std::vector<int> numbers = {5, 2, 8, 1, 9, 3};
std::sort(numbers.begin(), numbers.end());
for (const auto& n : numbers)
std::cout << n << " ";
// Output: 1 2 3 5 8 9
}Why It Mattered
Before C++, programmers faced an impossible choice: use a high-level language like Simula or Smalltalk and accept poor performance, or use C and manage all program complexity manually. C++ eliminated that tradeoff. It proved that abstraction and efficiency could coexist in the same language, and this insight changed the software industry.
By the early 1990s, C++ had become the dominant language for systems programming, replacing C in many projects. Microsoft built Windows and Office largely in C++. Adobe rebuilt Photoshop and Illustrator in C++. Every major game engine — from id Software’s Doom to Epic’s Unreal Engine — adopted C++. Database engines like Oracle, SQL Server, and later MongoDB and MySQL were written in C++. Financial firms on Wall Street built their high-frequency trading systems in C++ because no other high-level language could match its performance.
C++ also directly influenced the design of later languages. James Gosling borrowed C++ syntax for Java while deliberately removing features he considered dangerous (pointers, multiple inheritance of implementation). Anders Hejlsberg’s C# similarly drew from C++ while adding garbage collection and a simplified object model. Even Brendan Eich’s JavaScript used C-style syntax partly because of C++’s ubiquity among developers in 1995.
The Evolution of Modern C++
The C++11 standard, ratified in August 2011 after years of development, was the most significant revision since the language’s creation. It introduced move semantics — allowing resources to be transferred between objects without copying, dramatically improving performance for container operations and function returns. Lambda expressions brought anonymous functions to C++, enabling functional programming patterns that had been awkward or impossible before. The auto keyword allowed the compiler to deduce types from initializer expressions, reducing verbosity without sacrificing type safety. Smart pointers (unique_ptr, shared_ptr, weak_ptr) provided automatic memory management that worked with C++’s deterministic destruction model, making manual delete calls unnecessary in well-written modern code.
C++14 and C++17 built on these foundations. C++14 relaxed constexpr rules and added generic lambdas. C++17 introduced structured bindings, std::optional, std::variant, std::filesystem, and parallel versions of standard algorithms. The standard library expanded from a collection of containers and algorithms into a comprehensive platform that covered string processing, file system operations, threading, regular expressions, random number generation, and time measurement. Each revision brought C++ closer to the productivity of higher-level languages while maintaining its zero-overhead performance guarantees.
C++20 was another watershed release. Concepts — a feature Stroustrup had proposed as early as the 1980s — finally gave C++ a way to constrain template parameters, producing clear error messages when types did not meet requirements. Modules replaced the decades-old header file inclusion model with a modern compilation unit system, dramatically improving build times for large projects. Coroutines enabled asynchronous programming patterns. The Ranges library provided composable, lazy sequence operations that modernized how C++ code processes collections of data. These features collectively transformed C++ from a language often criticized for complexity into one that could express sophisticated ideas concisely and safely.
Beyond C++: Other Contributions
While C++ is Stroustrup’s defining achievement, his contributions extend further. He has written four major books — The C++ Programming Language (now in its 4th edition, 2013), The Design and Evolution of C++ (1994), Programming: Principles and Practice Using C++ (2008), and A Tour of C++ (now in its 3rd edition covering C++20). These books have collectively sold millions of copies and trained generations of programmers.
Stroustrup has been deeply involved in the C++ standardization process through the ISO C++ Standards Committee (WG21). He championed the C++11 standard, which was the language’s most significant modernization — adding move semantics, lambda expressions, auto type deduction, range-based for loops, smart pointers, and concurrency support. He continued pushing for C++14, C++17, C++20 (which added concepts, modules, coroutines, and ranges), and C++23. His philosophy has always been that C++ must evolve to stay relevant rather than be replaced by a new language.
After leaving Bell Labs in 2002, Stroustrup held the College of Engineering Chair in Computer Science at Texas A&M University until 2014. He then joined Morgan Stanley as a Managing Director in their technology division, where he works on large-scale distributed systems. Since 2014, he has also been a visiting professor at Columbia University. He was elected to the National Academy of Engineering in 2004.
C++ in Industry: Real-World Impact
The scope of C++’s deployment across industries is staggering. In finance, high-frequency trading firms use C++ for their order routing and matching engines because the language allows sub-microsecond latency — an advantage worth millions of dollars annually. Bloomberg Terminal, used by 325,000 financial professionals worldwide, runs on C++. In gaming, the Unreal Engine — powering titles like Fortnite, which has over 400 million registered accounts — is written in C++ and allows game developers to write game logic in C++ for maximum performance. Unity’s core engine is also C++, even though it exposes C# for scripting.
In telecommunications, Ericsson and Nokia use C++ for 5G network infrastructure. In automotive, self-driving systems from Waymo, Tesla, and Cruise use C++ for real-time perception and planning algorithms where milliseconds matter. In aerospace, NASA’s Mars rover software and the James Webb Space Telescope’s ground systems use C++. In web infrastructure, Chrome’s V8 JavaScript engine (which also powers Node.js), Firefox’s SpiderMonkey engine, and the core of every major database (MySQL, PostgreSQL, MongoDB, Redis) are written in C++. This breadth of application — from embedded controllers to cloud databases to AAA games — is unmatched by any other programming language.
Philosophy and Engineering Approach
Key Principles
Stroustrup has articulated his design philosophy across decades of writing and talks. His core principles are pragmatic rather than dogmatic. He believes a programming language should serve the programmer, not the other way around. “C++ is designed to allow you to express ideas, but if you have no ideas or no taste, it can’t help you,” he has said.
The zero-overhead principle remains central: features should not impose costs on programs that don’t use them. This stands in contrast to languages with mandatory garbage collection or mandatory runtime type information. Stroustrup also insists on backward compatibility — valid C++98 code should still compile under C++23. This commitment to compatibility is sometimes criticized for making the language complex, but it has allowed companies to maintain and gradually modernize codebases spanning decades.
He advocates for type safety and resource safety as engineering goals, not just academic ideals. Modern C++ (C++11 and later) strongly encourages smart pointers (unique_ptr, shared_ptr) over raw pointers, RAII over manual resource management, and compile-time checking over runtime errors. The C++ Core Guidelines project, which Stroustrup co-leads with Herb Sutter, codifies hundreds of best practices for writing safe, efficient C++.
Stroustrup is skeptical of “one true way” approaches to programming. C++ supports procedural, object-oriented, generic, and functional programming styles because real-world problems require different approaches. He sees multi-paradigm support not as a flaw but as a strength — practical software requires practical flexibility. This contrasts sharply with languages like Alan Kay’s Smalltalk, which enforced a pure object-oriented model.
Legacy and Modern Relevance
In 2026, C++ is over 40 years old and shows no signs of fading. The C++23 standard added significant features including std::expected, std::print, multidimensional array support, and improvements to ranges and coroutines. Work on C++26 is underway, focusing on reflection, pattern matching, and contracts — features that will keep C++ competitive with modern languages for decades to come.
C++ remains the language of choice where performance is non-negotiable. Game engines (Unreal, Unity’s native layer), web browsers (Chrome, Firefox, Safari), operating systems (Windows, macOS, Linux kernel modules), embedded systems, autonomous vehicles, high-frequency trading, and machine learning inference (TensorFlow, PyTorch’s backend) all depend on C++. The ISO C++ Foundation reports that the number of C++ developers has grown, not shrunk, in recent years — from an estimated 4.0 million in 2020 to 4.4 million in 2025.
The language Stroustrup built also forced an important conversation in computer science about the relationship between safety and performance. Rust emerged partly as an answer to C++’s memory safety challenges, proving that compile-time safety guarantees and zero-cost abstractions are not mutually exclusive. But rather than seeing Rust as a replacement, Stroustrup has responded by pushing C++ to adopt safety features — the C++ Core Guidelines, lifetime profiles, and the proposed “safe C++” initiatives all aim to bring Rust-like guarantees into C++ without breaking backward compatibility.
Bjarne Stroustrup’s creation did not just give programmers a tool. It proved that a language could be simultaneously high-level and fast, abstract and concrete, evolving and stable. That balance — difficult to achieve and easy to criticize — is precisely why C++ has outlasted nearly every other language designed in the same era. It remains, as Stroustrup intended, a language for people who do serious work with computers.
Key Facts
- Born: December 30, 1950, Aarhus, Denmark
- Known for: Creating C++, advancing object-oriented and generic programming
- Key projects: C++ (1979–present), C++ Core Guidelines, Cfront compiler
- Awards: ACM Grace Murray Hopper Award (1993), IEEE Computer Society Computer Entrepreneur Award (2004), NAE member (2004), IET Faraday Medal (2017), National Academy of Sciences John von Neumann Medal (2018), Charles Stark Draper Prize (2018)
- Current role: Managing Director at Morgan Stanley; Visiting Professor at Columbia University
Frequently Asked Questions
Who is Bjarne Stroustrup?
Bjarne Stroustrup is a Danish computer scientist who created the C++ programming language at AT&T Bell Labs starting in 1979. He is also a technical fellow at Morgan Stanley and a visiting professor at Columbia University. His work on C++ has influenced virtually every major programming language developed since the 1980s.
What did Bjarne Stroustrup create?
Stroustrup created C++, which began as “C with Classes” in 1979 and evolved into one of the most widely used programming languages in history. He also co-authored the C++ Core Guidelines with Herb Sutter and has authored four major books on C++ programming and design.
Why is Bjarne Stroustrup important?
Stroustrup demonstrated that a programming language could provide high-level abstractions like classes and templates without sacrificing the performance of a low-level language like C. This insight shaped the entire field of programming language design and enabled the construction of complex, high-performance software systems — from operating systems and game engines to web browsers and financial trading platforms — that form the backbone of modern computing infrastructure.
