C++

In the 1970s, Bjarne Stroustrup discovered at Cambridge the joys and frustrations of Simula. He liked the language for its ability to structure code with classes, but was exasperated by its slow execution. For his thesis on distributed systems, he had to abandon Simula's elegance and return to BCPL, faster but less organized. This contradiction left a mark: why should one have to choose between performance and code clarity?

When Stroustrup joined AT&T's Bell Labs in 1979, he kept this question in mind. The projects he worked on—analysis of the UNIX kernel, network distribution—demanded both efficiency and structure. He set himself the bold challenge of grafting Simula's classes onto the C language. Thus was born "C with Classes," a hybrid that retained C's speed while adding object-oriented organization.

The first steps were modest. Stroustrup added classes, then constructors and destructors to automatically manage object initialization and destruction. Public-private access control appeared next, followed by virtual functions that enabled polymorphism. Each addition answered a specific need encountered in the field.

In 1983, Rick Mascitti suggested a new name: C++. C's increment operator perfectly symbolized this evolution of the language. The name stuck and history would remember this designation. Two years later, in 1985, the first commercial version emerged from Bell Labs, accompanied by Stroustrup's foundational book, The C++ Programming Language. The Cfront compiler translated C++ code into C, an elegant solution to ensure maximum portability.

Success came quickly. Programmers discovered that they could retain their C habits while accessing the benefits of object orientation. No abrupt change, but a smooth transition. The language didn't slow down execution compared to C, didn't require a specialized environment like Smalltalk. This pragmatic approach won over a growing community.

Between 1985 and 1989, C++ grew richer. Multiple inheritance appeared in 1989, templates opened the way to generic programming, exception handling brought greater robustness. Each feature matured first in use before being integrated into the language. This caution forged C++'s reputation for stability.

The growth was impressive: from a few hundred users in 1985, the number rose to 400,000 in 1991. Application domains multiplied: operating systems, video games, graphical interfaces, scientific computing. Development environments appeared, specialized libraries enriched the ecosystem.

In 1989, the standardization process began under the auspices of ANSI and ISO. The work culminated in 1998 with the publication of the first international standard (ISO/IEC 14882:1998). This standardization freed C++ from its creator and ensured its longevity beyond Bell Labs.

The Standard Template Library deserves special mention. Alexander Stepanov developed a transformative approach: generic containers (vector, list, map) and reusable algorithms that work with all these containers. This library transformed the way C++ was written by favoring the reuse of proven code.

The iostream input-output system advantageously replaced the printf and scanf inherited from C. Type-safer, more extensible, it integrated naturally into the C++ philosophy. These additions to the standard library made the language richer without burdening the compiler core.

Stroustrup defended constant principles throughout the evolution: no performance degradation compared to C, backward compatibility preserved, support for varied programming styles. C++ accepts classic procedural programming, object-oriented with classes and inheritance, generic programming with templates. This flexibility explains its adoption in very diverse contexts.

C++ popularized object orientation in domains traditionally reserved for procedural languages. Java and C# would draw heavily from its concepts, even if they made different architectural choices. Generic programming with templates inspired many subsequent languages.

C++ continues its evolution through successive standards. C++11 modernized the language with lambda expressions and smart pointers. C++14, C++17 and C++20 continue to expand possibilities: modules, coroutines, concepts. The language adapts to multicore architectures, parallel computing needs, and modern programming constraints.

This longevity stems from its designers' pragmatic approach. Rather than revolutionizing for revolution's sake, they always favored practical utility and preservation of the existing. C++ remains true to its origins: a powerful tool for those who want fine-grained control over resources without sacrificing code expressiveness. The history of this language illustrates how a good idea, nourished by field experience, crosses decades by adapting without losing its identity.