The discipline of writing computer software has existed for about 50 years now, give or take. Over the years we’ve learned a lot, produced a lot of good software and immense amounts of bad software. The current discipline is maturing slowly, but it’s a far cry from other fields of engineering which have been around since, say, the Roman empire, for instance.

An immense amount of computer languages have been developed; but by now, with a few exceptions, practically all of them include some basic concepts such as for/while loops, conditional branching etc. It seems that we have locked in some of the basic foundational syntactic elements of how computer software should be written. One could argue that more modern methodologies, like object-oriented programming with classes, inheritance, properties and components, are also quickly becoming a de facto standard – with individual variations of course.

What will happen ahead? As usual, impossible to say, but since we’re in the New Year mood still (some of us), let me venture a few predictions for the next 50 years (now there’s a risky concept)… or at least my dreams:

• More and more research will go into the development of object-oriented frameworks and components; but the focus will be on interoperability: how to get the darn things as separate as possible and yet fundamentally stay together. Web services or SOA is just a hyped-up buzzword. We need real interoperability; to look beyond “services” and start using components directly.
• As systems are getting more and more complicated, and frameworks get bigger and bigger, increasingly powerful forms of abstracting logic from the components will be required. There will be a lot of research about functional and/or descriptive languages, where the systems will be described instead of programmed. The systems might then be programmed or even evolved themselves, naturally solving the descriptive statements and developing itself. This might be seen as the next generation of reflection.
• As we get more and more processors into our computers, instead of faster and faster processors, expect processors to become more specialized. Why should I have 256 generic processors in my computer, all identical, when some processors can instead be tailored towards very specific work? We already have graphics processors that are as advanced as the CPU (at least in terms of energy and cooling requirements).
• Programs will also fundamentally change, on some levels, and will be written (or bred, or evolved) to favor a distributed computational model. Problems will be broken down to favor parallel processing. Given the different setup of everyone’s computer, it might be wise to let the main CPU or operating system to distribute the problem over several nodes. Descriptive languages might of course make all of this easier. Might “matrix programming” one day become a future buzzword?
• The big question is: What will happen to databases? Despite all the service-oriented, distributed logic that people talk about today, the actual data is still typically stored in a huge database server (or cluster). And that’s a huge limitation, because “one database – one system”. If objects could be freed from their dependency on storage and persistence, they might be allowed to travel between systems. Nowhere is this more exemplified than when a business unit is using two systems in parallel, and nobody knows in which system a specific data exists. A great example is journals or prescriptions within the medical care. Will object-oriented databases provide the key? And don’t tell me XML is the solution. XML is just a tool, and sometimes, it’s a silly tool. (The thing speaking against the abolition of relational databases is that they have become as ubiquitous as for/while loops. What works tends to stay.)

In fact, I would suggest that the single biggest change within computer systems will be to “Free The Objects”. We must free them from constraining dependencies, such as persistence, assembly dependencies, and allow them to roam free, code and data [seemingly] intertwined. Fly free, objects! Roam free, components! Until the day when objects, components and frameworks can interact and interdepend freely and without restriction, we have not yet arrived.

Am I right? Am I wrong? Fifty-fifty? Who knows. The software industry might take an unexpected turn at any corner. And, as usual, expect a nasty kick in the pants from security.