The Changing Needs of Developers

Evolution of Software Development Productivity

By John Alpine, VP R&D

It is often difficult to know that one is the midst of a major technological shift when it’s unfolding. It’s much easier to look back with hindsight and discern major trends and changes. For example, in the evolution of software productivity it’s easy for us today to see that the shift from assembly languages to high level languages like Fortran and COBOL represented huge gains in productivity, as with the move from procedural to object oriented languages with the accompanying evolution of development tools such as source code debuggers, central version control, and integrated smart code editors.

The closer we get to the present, the harder it is to understand shifts in progress and predict their effect. However it is become increasingly evident that we are the midst of two new major shifts in software productivity. The first is the trend to managed code languages with integrated high level user interface toolkits (for example, Java + Swing + Ruby or C# + .NET) that radically reduce the time to create applications as well as effort required to maintain them. The second, often not as well recognized, but arguably even more impactful on software productivity, is the re-use of software via packaged software components.

It has been long known that software reuse, especially the use of well tested and robust code achieve some of the greatest gains in overall software productivity. After all, this is code that your development team does not need to write, and often, with commercial software components, testing is minimized as well. The main force behind this shift comes from the acceptance and adoption of commercial software components. By the far the most well known of these commercial software components has been the relational database. In the engineering domain, especially around product design, the key software component has been the solid modeling kernel. Both of these components, in their domain, serve as the infrastructure to thousands of applications.

The last 10 years has seen a proliferation of reusable components, each getting more robust and encompassing each year. There are very few business applications that require a relational database that don't use a componentized data base engine leveraged from either open source or more likely, a commercial vendor such as Microsoft, IBM or Oracle. In the engineering domain, solid modeling kernels, constraint management systems and visualization toolkits are available from a number of commercial sources. Fewer open source options exist largely due to the extensive costs related to supporting and integrating software at this level of complexity and size.

However the same complexity of implementation and use that limits the adoption or creation of open source solutions for engineering components is also the driver behind where the future source of software productivity will come from.

Fully supported "application stacks" represent the next level of productivity gain because they maximize efficiency, yet retain a high degree of flexibility. More than a collection of components these are complete application "skeletons" or platforms, very often well supported through a platform development environment such as Java or .NET. Such platforms integrate one or more software components with the application framework to create a very simple, but often quite extensive application.

Next generation of productivity will not come from simple availability or evolution of these components but from their integration into an application "stack". Having skeletal frameworks that pre integrate multiple components and provide easily modified source code are here today. A few years from now, it will be clear that the evolution of these stacks were as significant a technology shift as was the move from procedural to object oriented programming languages.