Calum Grant

The future of programming

What will programming languages look like in 20 years time? 50 years? 100?

One way to look at this is to see what was happening 20 years ago, in 1986. Then, C was in its prime, C++ was in its infancy, and Smalltalk had blazed the path for OO. ADA was big, and all sorts of 4GLs, including COBOL were being proposed as ultra-high level programming. Prolog/Lisp/Scheme were fresh. Pascal was exciting. 50 years ago, in 1956, there was just Fortran. Check out http://www.levenez.com/lang/

So nothing particularly fundamental has happened in the last 20 years. Sure, there are aspects, and generative programming that have happened. Computers have gotten faster, so now we use dynamically-typed languages more, and OO is now accepted as mainstream. Emphasis has shifted.

But I can't help feeling that programming languages have already gotten too complicated. Why add more stuff? The pressure is always to add new features, but of course this dilutes the language, and makes it much harder to use. Particularly, generative programming (or, programming with types as I like to call it), is very sexy, but is fundamentally equivalent to an algorithm written in a more straightforward way. Languages nowadays are striving to clean their syntax, and make things as straightforward as possible. To this end, dynamically-typed languages really help since I believe that type-clutter just gets in the way. This is really a human issue: what do people prefer?

So my predictions.

I think that there won't be any fundamentally new paradigms that will seriously catch on. I think patterns will become more developed, and there will be standardised approaches to solving particular problems. Not the chaos there is now. Tools will be better. Much of what used to be programming will be achievable with software - this is after all the whole point of programming. Programming will become more specialised, there will be fewer programmers. Devices will get smaller and smaller, the emphasis will be on quality and compactness. Programs will be measured by the energy they consume - energy will be the critical resource. There will also be a supercomputing niche, where parallelism is important.

Compilers will be better. They will be able to parallelise better, but importantly, I believe that they will be able to statically type dynamically-typed languages (DTLs). All of the traditional drawbacks with DTLs (such as efficiency, and type safety) will be gone. Static analysis will change the landscape of what is easy and efficent, it will remove the need for generative programming. Compilers will also be able to optimize memory allocation, being able to turn the sloppiest dynamically-typed code into better than the most expertly crafted C++.

All of the old languages will carry on. They will interoperate seamlessly, as different ways of expressing the same, underlying type system. A little like Microsoft's .net, however it will work at the static level, not the runtime.

I also believe that visual programming languages will prevail. Again, the choice of language will be a user preference, but they'll all end up supporting the same features, much like how DTLs are going at the moment. There will be more visualization tools, the experience will be immersive.

Eventually, people will stop bothering to specify types and memory allocation, since the compiler will just do all that. Types will be something that only compilers and computer science students will know about.

Programming will be a more integrated experience, integrating models, code, debugging, documentation, requirements, project schedule, use-cases, change requests, source control, activity planners, unit tests as well as visualization tools. The "program" will not be just the code, it will be the entire process. Everything will be cross-referenced, there will be an audit trail between features.

The development process will be standardised, almost wizard-driven. Your hand will be held for you as you implement a new feature. The kind of ad-hoc programming that we do at the moment will still be possible, but strongly discouraged by employers.

Development will be behaviour-driven. People will ask "what is the behaviour of X when Y". Programming will be reformulated into human-language, with components that are not shrouded in mystery to non-programmers. Programming will be less technical, since most of the structures, components and behaviours can be defined and implemented by non-programmers. Behaviours, or rules, will be expressed in human language, or in high-level specification, which for the most part will be the program. There will be a niche for algorithms, but less so in business scenarios.

Visual parts will be designed visually. Programming will be template-based, where solutions to problems that have been solved before can be adapted easily to a new scenario. Something more than object-orientation is needed here.

Now the wild predictions.

Programming will eventually turn open-source, and eventually even Microsoft will become open-source, forced by the quality of open-source offerings. It will be so easy to create software that the value of the software market will collapse by the relentless creativity of the hobbyists. Hardware on the other hand will continue to be cheap and plentiful. The emphasis on hardware and software will be ever increasing efficiency, which will slowly start to plateau as people realise that the features they require don't actually need any more computing power.

Human interfaces will change. Computing will be mobile and networked. Your desktop will follow you. You don't even need to go to work. Programmers will become information workers. You might even wear a head-up display, until retina implants become popular. Computing is everywhere and nowhere. Any surface can become a keybord and display. You will point with your fingers, not a mouse.

The distinction between a software interface, and user interface, will become blurred. All internet services will be in this form, driven by behaviours and rules. Your own software agents will interact with others' software agents. Most things won't require human intervention.

Eventually, programming as we know it will disappear. The old languages will be remembered fondly, still taught in colleges in history of computing classes. People will still learn C, but it will be a bit like learning Latin. People will dress in 20th century clothing, and go to conventions with old computers, or emulators, and run the old software and hold interest groups in how to touch-type or program Java. These will be the equivalent to historical reenactment societies, or old basket weavers or coopers who are determined not to let the tradition die.

posted by Calum Grant @ 9:48 PM