Paradim changes

If we look at the major trend evolutions in software engineering, we can see three big periods since the beginning:

  • until 1980: procedural technology with procedural refinement as the main paradigm
  • from 1980 until 2000/2010: object and component technology with object composition as the main paradigm
  • since 2010: model driven engineering with model transformation as the main paradigm

This is my personal high level view on the evolution of major practices. Of course there are also other important trends, but they have not impacted as much the software production practices.

For example concurrent programming is VERY important and many efforts have been invested since the first efforts of Dijkstra in 1965 with his cooperating sequential processes. But today we are still lacking good languages to express our problems in a concurrent form. Many times we believed we were on the verge of succeeding (remember CSP, Occam, the Transputer for example).

Another paradigm that is surely important is the functional paradigm . Here again functional programming is surely VERY important but it has not yet impacted the major practices. Lisp was one of my first languages and I still remember the lectures in Lisp given by prof. Yvon Siret to our undergraduate class in Grenoble in 1967. We have teached Caml to a lot of generations of students. Today Haskell has a deep impact on many new languages that are appearing. But we do not yet see the large adhesion of programming masses to the functional paradigm and I regret it.

We could also study other paradigms like logic programming and the big hopes that were raised in the 80’s with the Japanese next generation plan. But today Prolog is not the dominant programming language in current practices.

What we can say is that the major trend of structured programming was very influential in the seventies. Top-down or bottom-up programming, procedural refinement were supported by all our great master at theat time, Dijkstra, Hoare, Wirth, Knuth, etc.  And this was the main culture until the 80’s.

Then came the object-oriented programming languages with Smalltalk, Eiffel, C++, Objective-C, Java, C#, etc.  And this changed the way we build software systems. We have been able to undertake the construction of big and huge and sometimes reliable systems with object technology that would probably difficult to build with procedural technology.

Object technology has brought a lot of advantages, including some form of reusability (not as much as we hoped, but still some form of reusability). But the main contribution of these languages is that they have shown us how to design business objects and how to mix these business objects with more technical objects or platform objects in executable programs. Today, with the help of the pattern movement, object technology is main stream and it is one of the major form of  software production with languages like Objective-C, Java or C#.

What I do believe is that with J2EE and similar solutions, object and component technology has lost its conceptual simplicity and has found its limits.

My personal conviction is that there is a big rupture arriving now in software production techniques and that this will be centered on models and model transformations.

This entry was posted in Models, Transformation. Bookmark the permalink.

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