Home > C++ > Regime Change

Regime Change


Revolution is glamorous and jolting; evolution is mundane and plodding. Nevertheless, evolution is sticky and long-lived whereas revolution is slippery and fleeting.

As the figure below from Neal Ford’s OSCON “Functional Thinking” talk reveals, it took a glacial 16 years for Object-Oriented Programming (OOP) to firmly supplant Procedural Programming (PP) as the mainstream programming style of choice. There was no revolution.

Starting with, arguably, the first OOP language, Simula, the subsequent appearance of Smalltalk nudged the acceptance of OOP forward. The inclusion of object-oriented features in C++ further accelerated the adoption of OOP. Finally, the emergence of Java in the late 90’s firmly dislodged PP from the throne in an evolutionary change of regime.

I suspect that the main reason behind the dethroning of PP was the ability of OOP to more gracefully accommodate the increasing complexity of software systems through the partitioning and encapsulation of state.

Proc to OO

Mr. Ford asserts, and I tend to agree with him, that functional programming is on track to inherit the throne and relegate OOP to the bench – right next to PP. The main force responsible for the ascent of FP is the proliferation of multicore processors. PP scatters state, OOP encapsulates state, and FP eschews state. Thus, the FP approach maps more naturally onto independently running cores – minimizing the need for performance-killing synchronization points where one or more cores wait for a peer core to finish accessing shared memory.

regime change

The mainstream-ization of FP can easily be seen by the inclusion of functional features into C++ (lambdas, tasks, futures) and the former bastion of pure OOP, Java (parallel streams). Rather than cede the throne to pure functional languages like the venerable Erlang, these older heavyweights are joining the community of the future. Bow to the king, long live the king.

Categories: C++ Tags: , , ,
  1. Dick Danjin
    November 12, 2014 at 6:31 am

    Richard,puts me in mind of the axiom “there is nothing new in the world,the problem is to think of it again “Back in the early 90’s I co-authored an article ASQ has it now ” Here we go again will TQM go the way of QWL “AS to the length of time thing Myron Tribus wrote about large systems denying reality and impeding change in a piece ” The Germ Theory of Management ” Both of these pieces IMHO are as timely as ever,

    • November 12, 2014 at 7:40 am

      “Large systems deny reality and, thus, impede changes in their parts”. Slow, insidious, undetectable, suicide over time. Very true.

  2. November 12, 2014 at 8:22 am

    F# is no slouch of a language either. Microsoft research put some of their best and brightest on the F# team. It also has access to the .NET collective and since it builds intermediate code linkable with C# and C++ it can be easily phased into projects. Dare I say that Microsoft was actually ahead of the game on this particular bandwagon?

    • November 12, 2014 at 10:53 am

      Clojure, Scala, Haskell. AFAIK, Erlang is the oldest, battle-tested functional language out there.

  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: