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.
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.
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.
Leave a Reply
Why am I here?
WTF?
Meh!
D'oh!
My BTC Address
Bulldozer00's Blog 
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,
“Large systems deny reality and, thus, impede changes in their parts”. Slow, insidious, undetectable, suicide over time. Very true.
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?
Clojure, Scala, Haskell. AFAIK, Erlang is the oldest, battle-tested functional language out there.