Blueprinting Tackles Multicore Software Development Challenges

Multicore is with us and the software development challenges that it poses are significant; CPU core counts are set to increase exponentially, applications will need to be developed with explicit concurrency to fully exploit these CPUs, the majority of software engineers are not trained in concurrent programming and writing concurrent programs is widely regarded as very difficult. As single threaded applications utilize an ever-decreasing fraction of the available processing power, it is inevitable that those companies who provide concurrent software capable of fully exploiting the latest devices will have an edge on the competition.

Desktop applications such as Microsoft Word are offloading ever more tasks from the GUI thread in order to provide a responsive user interface. This behavior demands complex synchronization logic and without the right tools and methods this exposes the whole development team to the full software development challenges of concurrent programming.

The Infrastructure-Oriented Approach

Mature industries have developed formal blueprinting processes to manage project complexity. The architect is responsible for performing all the inspirational thought necessary to solve any problems and producing a blueprint that captures this prescriptively before a builder hits a nail. As this blueprint is prescriptive, it requires no interpretation by the builder, which has three distinct advantages:

• It provides the builders with enough information to realize an implementation that is exactly in line with the architect's original intentions
• As the builder is not performing the work of an architect, it isn't necessary to pay architect money
• The builder is less-skilled than an architect and therefore it is much easier to recruit someone with the necessary skills.

Software Blueprinting

Software blueprinting can provide the same advantages to the software industry and help to meet the software development challenges posed by the concurrency revolution. This approach means that the hard, concurrent application aspects are dealt with by concurrency specialists (the software architects) up front. These specialists capture all the necessary detail in a software blueprint, in the same way that the building architect solved the complex building problems up front.

The majority of engineers continue to operate with familiar tools and methods (preserving existing investment). They are the builders of the software world and are not exposed to the complex (concurrent) nature of the project. However, because they now have a prescriptive blueprint, they know precisely what they are doing and their output will conform to the architect's plan.

In addition to managing the impending rise in software complexity due to the concurrency revolution, this model provides a solid framework for outsourcing to foreign countries to further reduce software development costs.