A Fantastical Future of Software Development

Let me jump right into it at the expense of sounding crazy — I think it’s not only possible but likely that in the future software systems will be able to compose themselves. In fact, I am very surprised that this hasn’t already happened. But given the (sorry) state of the industry, it isn’t that surprising.

So firstly, how would software systems write themselves?

Imagine the following:

  1. A Component Repository where developers checkin generic modular components.
  2. A formal language that describes the interfaces of the software component as well as it’s test cases
  3. A semi-formal or informal index in which the developer or the team can describe what the component does.
  4. An NLP system trained to understand the description mentioned in (3)
  5. A high level language where you can describe what you want the end system to do
  6. An agent or bot (or interpreter?) that takes (5) and scans the component repository using (4) to discover components that can be used to compose the system
  7. Another agent that deploys the system in the cloud according to the scaling specs provided in (5)

So why has this not happened yet? In fact, after all the promises of the research on COTS (Components off the shelf) in the late 90s, the best we have for a component repository is GitHub (and the likes) — no offense to GitHub.

After description languages such as IDL and systems to discover web services that IBM was actively working on 20 years ago (think pervasive computing using UDDI, WSDL etc.) — none of them took off.

I think the two mains reasons are:

  1. The lack of collaboration in the software industry — There really is a each one for self culture in the industry. There is collaboration in small things, for namesake, but as software companies (and as humans) — we find it very hard to agree on standards! Hence no common standard has emerged in anything for discoverability yet. (Think browser wars, Office/Open-office, OS wars, JavaScript standards, Web services standards — need I go on?)
  2. The pace of change — has been extreme. Innovation is disruptive but that also means that it lacks proper insight. New tools and frameworks appearing (think front end tech) before the old ones have been perfected, and then being replaced by newer ones within 6 months.

Finally, why would a way for software to compose itself be beneficial?

  1. Increased innovation and efficiencies — Such as system would greatly increase the pace of development and developers would be very willing to post components here as other teams would be able to buy them.
  2. Increased Reusability — If there’s one thing I absolutely abhor, it is repetition of software. It bothers me immensely if the same piece of software has to be written again. Having a component registry like this would mean that a software component once written can be used by many (all). Yes I know that’s what open source is, but standardization of describing component interfaces would take reusability and interoperability to a new level.
  3. Better software — Inevitably such as system would be more robust since it will be composed of well thought of components since once would have to describe the interfaces in detail.

I am positive that something similar will emerge in the next decade. Whether it be something that the industry leaders come up with or it be a grassroots effort, that remains to be seen. My money is on the latter.