ostechtalk Procedural Programming vs Rule based Programming

Every friday for the past month we have been having debates among the knowledge sharing teams in orangescape.  This last friday (24th Sept 2010) was ours.  The debate topic was Procedural programming vs Rule Engine based programming.  Me & @sivaacbe represented Procedural programming.  @balajivg and @vimalkumar_v represented Ruled Based Programming.   The essence of what we (Procedural Programming)  spoke during the presentation phase is going to be content of the post.  you can follow our team’s progress here.  you can check #ostechtalk in twitter

Both Procedural as well as rule based programming have their own advantages.  As the advocates of procedural programming we started of with the explanation of the evolution of languages.  Instead of talking the usual generations and stuff, we went with a different approach based on the decades.  starting the with the birth in the 40’s, to the innovations of the 60’s and enhancements of 70’s and 80’s and closing with the productivity empasis of the 90’s and 00’s, and continuing with the future of programming languages.

What do we have against Rule Engines?

Actually speaking, nothing.  Rule Engine based Programming which comes under the logical programming paradigm may has its own advantages.  but they do have their own problems.

  • First of all it is just a small piece of software in the large picture.  How many times are we going to need a Rule Engine.
  • They are powerful.  But they are mighty powerful, that many a times using it becomes a overkill, unless and until you have a problem that can only be solved by Rule Engine, using it is not advised.
  • Rule Based System do not know how to handle maybe conditions.
  • It is a new learning, and sometimes the learning curve might be high.
  • Testing the rules alone is difficult.  and also you can never be sure which other rules are going to get affected because of this rule change.
  • There are no standards for Rule Engines.

This is the transcript of what i spoke with the presentation.

Evolution of Programming Languages

A programming language is an artificial language designed to express computations that can be performed by a machine, particularly a computer.


Though Wikipedia says a programming language is a language to express things to a computer, the existence of programming languages predates the birth of computers (Yes, the one on which you are reading, and not the generic computers).

  • The profession of programming is traced back to the mid 1800’s.
  • In the early days of computing, there was no difference between the software and hardware.
  • Programs were written directly into the hardware.
  • Often the Hardware restrictions defined the language.


  • The first general purpose computers started to appear during the 1940’s.
  • These Computers were capable of storing and loading the programs.
  • Developers used machine code to program these Computers.  Machine Code is nothing but 1’s and 0’s.
  • Still these were difficult to write programs, and even more difficult to debug and fix errors.
  • These were the First Generation Languages.
  • Soon these were replaced by mnemonic codes (Assembly Language) which were slightly easier to code.
  • Still these too were difficult to debug.  These were the Second Generation Languages.


  • In the 1950’s the first modern programming languages came into being.
  • The Big Daddies of all programming languages which exist today – FORTRAN, Cobol were created in this period.
  • There was a move towards abstraction of complexities and making the language as easy as possible for the human to understand.
  • The programs written in these languages were converted to Assembly or Machine Code using Compilers, which led to this era being named as the Compiler Era.  This led to the wide spread adoption of these High Level Languages.
  • The Third Generation of the programming Languages began.
  • Even at this stage of evolution, the language capabilities diverged as to solve specific programming problems.


  • Software was beginning to become bigger and complex, during 1960’s and 1970’s.
  • Developers were trying to make complex programming easier by increasing the abstraction levels.
  • Various Programming Languages emerged supporting various paradigms.  Object Oriented, Functional, Procedural, Logical etc, came in being during this period.
  • C, Pascal, SQL all came into being during this period.
  • A major shift was under way to make programs easier to develop and maintain through new language enhancements and programming paradigms.
  • Towards the 1980’s emphasis turned towards paradigms and language maturation.
  • C++ which came in ’79 was originally called C with Classes, brought the advantages of Object Oriented Programming to a language strong in systems programming.


  • In the 90’s the developer productivity was the driver of the languages evolution.
  • Even more complex programming was abstracted out.
  • Runtime Environments tried to remove the burden of memory allocation and de-allocation etc from the programmer, and there by concentrating him only on the essence of programming for the problems.
  • Integrated Development Environments started to come in.  And then, the World Wide Web came in.
  • Java came to the world as a language which could execute on top of any environment and a lot of operating systems.
  • Simplicity, Portability, removing unnecessary programming overheads (memory allocation, management etc.) became the force behind the evolution.
  • Then came support for programs written in multiple languages.
  • JVM and .nET Common Language Runtime provided platform support for multiple languages.
  • This platform support for many languages eliminated the support for many a programming language.
  • Then came in the frameworks, which tried to abstract out even more of what was complex and repeatedly used programs.
  • But these in themselves introduced the same problem which they tried to solve.
  • To remove one complexity, it introduced another one.  Coz sometimes learning a framework was as daunting as learning a new language itself.

The Future

  • The future is interesting.
  • Just because we have seen the final programming languages of today’s era, it does not mean that programming languages are through evolving.
  • There are even more complex programming puzzles to solve like NLP, fuzzy, Expert Systems etc.
  • The Evolutionary process is just beginning & will have many more surprises for us.


Loops & Conditions :
We have all the beautiful pieces to solve the puzzle, like if….Then…Else,  for,  while,  do…while,  GOTO
Design Patterns :
What do you want to do :
Can do anything and everything.


Can be Complex:
Sometimes going thru the code, you may find it like puzzle in itself.  could be confusing.  you can get easily lost.
Tower of Babel:
There are toooo many languages today.  Each have their own distinctions, but still, can’t there be just one language.


For, In a way,

We (programmers) are God.