The Next Step in Software Engineering

An “interesting article”: can be found at MSDN today. It’s a research paper about software factories. To get the full picture about these software factories, I recommend you read the “full article”:, I’ll quote some parts that I found particularily intersting.

Why we need software factories:

Total global demand for software is projected to increase by an order of magnitude over the next decade—driven by new forces in the global economy—like the emergence of China and the growing role of software in social infrastructure, by new application types like business integration and medical informatics, and by new platform technologies like Web services, mobile devices, and smart appliances.

Without comparable increases in capacity, it seems inevitable that total software development capacity is destined to fall far short of total demand by the end of the decade. Of course, if market forces have free play, this will not actually happen, since the enlightened self interest of software suppliers will provide the capacity required to satisfy the demand.

About programmer competence:

* We know from experience that there will never be more than a few extreme programmers. The best developers are up to a thousand times more productive than the worst, but the worst outnumber the best by a similar margin [Boe81].
* As noted by Brooks [Bro95], adding people to a project eventually yields diminishing marginal returns. The amount of capacity gained by recruiting and training developers will fall off asymptotically.

And then about what I consider to be the most powerful and important concept in computer science:

The history of programming is an exercise in hierarchical abstraction. In each generation, language designers produce constructs for lessons learned in the previous generation, and then architects use them to build more complex and powerful abstractions.

About patterns in platform/programming language improvement:

Database management systems, for example, automate data access using SQL, providing benefits like data integration and independence that make data driven applications easier to build and maintain. Similarly, widget frameworks and WYSIWYG editors make it easier to build and maintain graphical user interfaces, providing benefits like device independence and visual assembly. Looking closely at how this was done, we can see a recurring pattern.

* After developing a number of systems in a given problem domain, we identify a set of reusable abstractions for that domain, and then we document a set of patterns for using those abstractions.
* We then develop a runtime, such as a framework or server, to codify the abstractions and patterns. This lets us build systems in the domain by instantiating, adapting, configuring, and assembling components defined by the runtime.
* We then define a language and build tools that support the language, such as editors, compilers, and debuggers, to automate the assembly process. This helps us respond faster to changing requirements, since part of the implementation is generated, and can be easily changed.

The question is, what’s the next big step? How can the software development process be made more efficient and effective? From the “ website”:

Scaling up to much higher levels of productivity will require the ability to rapidly configure, adapt and assemble independently developed, self describing, location independent components to produce families of similar but distinct systems. It will require a transition from craftsmanship to manufacturing like the ones we have seen in other industries, and will eventually produce more advanced earmarks of industrialization, such as supply chains, value chain integration and mass customization.

To accomplish this, the industry must capitalize on some key innovations in software development. We must synthesize ideas such as domain specific languages, software product lines, component specification and assembly, patterns, framework completion, domain analysis and feature variability analysis into a cohesive approach to software development that can learn from the best patterns of industrialized manufacturing.

Read the “full MSDN article”: