The Working Programmer's Guide To Language Paradigms
Written by Mike James   
Thursday, 25 May 2017
Article Index
The Working Programmer's Guide To Language Paradigms
Functional, Logic & Dynamic
Graphical Languages



The final paradigm is the graphic language - if they can be called languages.

This is a strange mix of the object-oriented approach and the declarative with a little procedural thrown in. However to classify the approach in this way is to miss the bigger picture.

The idea is that if code objects are to mimic real world objects let's give them a physical appearance. In the world of the user interface we are very well accustomed to this approach - a button that you drag and drop onto a page is a physical representation of the button code object.

You get to work with the button as if it was a real button - you can click it, drag it, size it, change its color and so on. Graphical objects in the UI lead to the component revolution which we are still developing - from ActiveX to WPF, Widgets, Components and so on.




Now consider using the same approach to building programs in general. You could have a loop component, a conditional component, a module component and so on. This could be assembled just like a user interface by a drag-and-drop designer and "writing the code" would be a matter or connecting them together in a flow of control graph. Some components would need you to write a few lines of procedural code to specify their actions more precisely but mostly components fit together naturally without extra code, just specify a few properties.

This approach to building programs has to date mostly been used in languages such as Scratch and the Lego Mindstorms robots to get children interested in programming. However, what is easy for children should be very easy for us and the method could well translate to more ambitious projects. 

Of all the techniques described so far it is graphical programming that I'd bet was the way of the future - but how far in the future is another matter.

The Rest

There are a large number of other approaches to programming that we haven't considered but they are mostly side issues and special environments.

For example, there is the whole issue of synchronous v asynchronous or event driven programming. Then there is the big question of sequential v parallel programming and so on. There is also the convergence of AI and programming. For example, using genetic algorithms you can evolve a program rather than writing it.

There are lots of variations on the approaches described so far and they get mixed and re-expressed in so many different ways that it can be difficult to see what you actually have. 

Today's dominant approach is the object oriented procedural language but we seem to be sliding towards including functional aspects and as many declarative features as needed to make some tasks seem easier.

One thing that deserves to be made very clear is that it is very difficult to think up new programming paradigms. Programming languages are easy because you can simply make your own re-mix. Take a little functional programming, some object orientation, make more of the language look declarative and so on. You end up with something that looks new but isn't particularly so. A programmer learning the language just has to discover how you have mangled the things they already know into new syntax. This doesn't mean that new languages aren't better than old because they can find ways of expressing the old that makes it easier to write a program. What is very, very rare is to find a programming language that makes you stop and think "well I never thought of expressing it like that".

This is because there are so few approaches possible if your task is to capture the dynamic, the system in the static, the code - that is what programming is currently all about. 

If you have a favourite approach that has been left out, or want to request an article about an approach or any aspect of programming theory, then leave a comment.



Related Articles

Functional And Dysfunctional Programming

Guide to F#

Strong Typing

Weakly Typed Languages

Late Binding - Myths and Reality

The Goto, Spaghetti and the Velociraptor

Type Systems Demystified

Towards Objects and Functions - Computer Languages In The 1980s  

Fuzzy logic and thinking        

Expert Systems and Prolog       

Database the Prolog way        

Programming - A Life Long Challenge 

A Programmer's Guide to Scratch 2 



To be informed about new articles on I Programmer, sign up for our weekly newsletter, subscribe to the RSS feed and follow us on Twitter, Facebook or Linkedin.


C book



or email your comment to:









Last Updated ( Thursday, 25 May 2017 )