Java and C# have become the predominant mainstream languages for software development. Both are derived from C and are classified as Object Oriented (OO) languages. OO was meant to help cross the user-technician divide by organising software based on real-world concepts (or objects). However, I think the hardest aspect of learning something new is to let go of what you knew before. For myself, it took some time to not treat an Object Model as simply a Data Model; in part because they looked similar, and because I had found data modelling to be so useful in my work. Therefore many users and analysts have never really transitioned from flowcharts and procedural thinking.

OO still proved useful in development because it facilitated writing less redundant code - organising code as a relational database organises data to avoid repetition.

Now that there is interest in alternative languages such as Ruby and Groovy, and alternative architectural styles such as from SOAP to REST, Server side web applications back to rich user interfaces utilising the client machine, etc. I find myself wondering about what comes after OO?

I believe a new generation of software may have the following characteristics (with the caveat that history tells us we typically underestimate the impact of what is under our noses at the time and our visions of the future are never complete).

Goal driven

The prediction of Agent Oriented systems is not new. These are components that in addition to having behaviour and state also have purpose. Goals are declared, and the component actively reconfigures its relationships and behaviour in an attempt to fulfill its goal in a darwinian manner. The Genetic Algorithm is an example of a present day implementation of code with goal driven behaviour.

Foreign

If we are able to create programs that can act autonomously, we may need to let go of understanding how they arrived at a specific outcome. We might know the mechanism that causes a program to adapt but not the precise sequence of steps that enabled a program to reach an outcome.

We are used to spelling out every specific instruction that tells a program how to move. We have developed layers to enable a higher level instruction to save time, but fundamentally a program is like a train set; we must first lay the tracks before the engine can get anywhere. A program shows no initiative or imagination. Yet we are sometimes left with the impression of a “ghost in the machine” since even though all the tracks have been laid by a human, the tracks can become so interconnected that it is impossible to predict the precise path that a program will take. Hence why a good majority of programming is finding and fixing bugs.

For a new generation of software the tracks may be laid and changed by the program itself. Alan Turing envisioned that a human able to listen in on a conversation between programs would not be able to translate what is said. Computers would become an unknowable mind, visible only by its outputs and actions.

Declarative

If we must let go of understanding the inner workings of a program, programmers must be able to declare what they want instead of specifying in excruciating detail how they would derive an outcome for the machine to emulate.

Jaron Lanier uses the term phenotropic computing to describe a model of software which replaces “protocol adherence” with “pattern recognition” as a way of connecting components of software systems.

A new set of problems

The type of problems handled by a computer are likely to be different. The name “computer” derived from the human computers used to decipher enemy code (enciphered messages) during the second world war. Computers were later applied to the world of business to perform mundane tasks and in particular were applied to problems that required precise answers such as general ledger accounting. It was perceived that the strength of automated computers was in their precision therefore they were set tasks that required precision.

Perhaps the new generation of software wont be realised until the widespread need to pose a new set of problems: pattern recognition, autonomous decision making, virtual environments, etc.

Teaching computers to think appears to be the only long term solution to the mountains of brittle computer code that exists today. Today we struggle with getting companies to communicate electronically over mundane transactions such as purchase orders and authentication requests. How would today’s software technology and methods cope with machines that must act autonomously on other planets with human lives in their care.

Big questions for a new generation of programmers.