• Managing Concurrent Software Releases
• Concurrent Development Process
• Software Development How To

In a concurrent development process different releases of a software product overlap. Organizations involved in concurrent software development not only experience the dynamics common to single projects, but also face interactions between different releases of their product: they share resources among different stages of different projects, including customer support, they have a common code base and architecture that carries problems across releases, they use the same capabilities, and their market success in early releases impacts their resources in later ones. Drawing on two case studies we discuss some of the feedback processes central to concurrent software development and build a simple simulation model to analyze the resulting dynamics. This model sheds light on tipping dynamics, the nature of inter‐project feedback loops, and alternative resource allocation policies relevant to management of concurrent software development.

Managing Concurrent Software Releases

Copyright © 2009 John Wiley & Sons, Ltd.

Software requirement analysis 2. Design: Software design is a multistep process that focuses on four distinct attributes of a program: data structure, software architecture, interface representations, and procedural (algorithmic) detail. The design process translates requirements into a representation of the software that can be assessed for quality before coding begins.

Code Generation: The design must be translated into a machine-readable form. The code generation step performs this task. If design is performed in a detailed manner, code generation can be accomplished mechanistically. Testing: Once code has been generated, program testing begins. The testing process focuses on the logical internals of the software, ensuring that all statements have been tested, and on the functional externals; that is, conducting tests to uncover errors and ensure that defined input will produce actual results that agree with required results. Support: Software will undergo change after it is delivered to the customer.

Change will occur because errors have been encountered, because the software must be adopted to accommodate changes in its external environments or because the customer requires functional or performance enhancements. Model assumes the requirement of a system which can be frozen (baseline) before the design begins. This is possible for systems designed to automate an existing manual system. But for a new system, determining the requirements is difficult as the user does not even know the requirements. Hence, having unchanging requirements is unrealistic for such projects. Freezing the requirements usually requires choosing the hardware (because it forms a part of the requirement specifications). A large project might take a few years to complete.

If the hardware is selected early, then due to the speed at which hardware technology is changing, it is likely the final software will use a hardware technology on the verge of becoming obsolete. This is clearly not desirable for such expensive software systems.

Model stipulates that the requirements be completely specified before the rest of the development can proceed. In some situations it might be desirable to first develop a part of the system completely and then later enhance the system in phases. This is often done for software products that are developed not necessarily for a client, but for general marketing, in which case the requirements are likely to be determined largely by the developers themselves. Model is a document driven process that requires formal documents at the end of each phase. This approach tends to make the process documentation-heavy and is not suitable for many applications, particularly interactive application, where developing elaborate documentation of the user interfaces is not feasible. Also, if the development is done using fourth generation language or modern development tools, developing elaborate specifications before implementations is sometimes unnecessary. Business modeling: Here we try to find answers to questions like what information drives the business process.

What information is generated? Who generates it?

Where does the information go? Who processes it? Data modeling: Here the information flow which would have been defined as part of the business modeling phase is refined into a set of data objects that are needed to support the business. Process modeling: The data objects defined in the data modeling phase are transformed to achieve the information flow necessary to implement a business function. Processing descriptions are created for adding, modifying, deleting, or retrieving a data object. Application generation: RAD assumes the use of fourth generation techniques.

Rather than creating software using conventional third generation programming languages the RAD process works to reuse existing program components(when possible) or create reusable components(when necessary). In all cases, automated tools are used to facilitate construction of the software. Testing and turnover: Since the RAD process emphasizes reuse, many of the program components have already been tested. This reduces overall testing time. However, new components must be tested and all interfaces must be fully exercised. For large but scalable projects, RAD requires sufficient human resources to create the right number of RAD teams.

RAD requires developers and customers who are committed to the rapid-fire activities necessary to get a system complete in a much abbreviated time frame. If commitment is lacking from either, RAD projects will fail.

Not all types of applications are appropriate for RAD. If a system cannot be properly modularized, building the components necessary for RAD will be problematic. If high performance is an issue and performance is to be achieved through tuning the interfaces to system components, the RAD approach may not work. RAD is not appropriate when technical risks are high.

This occurs when a new application makes a heavy use of new technology or when the new software requires a high degree of interoperability with existing computer programs. The process is integrated until the project control list is empty, at which time the final implementation of the system will be available. The project control list guides the iteration steps and keeps track of all tasks that must be done. Based on the analysis, one of the tasks in the list can include redesign of defective components or redesign of the entire system. Redesign of the system will occur only in the initial steps.

Concurrent Development Process

(In the later steps, the design would have stabilized and there is less chance of redesign) Each entry in the list is a task that should be performed in one step of the iterative enhancement process and should be completely understood. Selecting tasks in this manner will minimize the chance of error and reduce the redesign work. The design and implementation phases of each step can be performed in a top-down manner or by using some other technique. When an incremental model is used, the first increment is a core product(that is basic requirements are addressed, but many supplementary features remain undelivered).

Software Development How To

The customer uses the core product. As a result of use and/or evaluation, a plan is developed for the next increment. The plan addresses the modification of the core product to better meet the needs of the customer and the delivery of additional features and functionality. This process is repeated following the delivery of each increment, until the complete product is produced. The incremental process model is iterative in nature. The incremental model focuses on the delivery of an operational product with each increment. Customer communication: tasks required to establish effective communication between developer and customer.

Planning: tasks required to define resources, timelines, and other project-related information. Risk analysis: tasks required to assess both technical and management risks. Engineering: tasks required to build one or more representations of the application. Construction and release: tasks required to construct, test, install and provide user support. Documentation and training).

Customer evaluation: tasks required to obtain customer feedback based on evaluation of the software representations created during the engineering stage and implemented during the installation stage. The first circuit around the spiral might result in the development of a product specification; subsequent circuit passes around the spiral might be used to develop a prototype and then progressively more sophisticated versions of the software. Each passes through the planning region resulting in adjustments to the project plan. Cost and schedule are adjusted based on feedback derived from customer evaluation. In addition, the project manager adjusts the planned number of iterations required to complete the software.

All activities exist concurrently but reside in different states. For example, early in a project the customer communication activity has completed its first iteration and exists in the awaiting changes state. The analysis activity (which existed in the none state while initial customer communication was completed) now makes a transition into the under development state. If the customer indicates that changes in requirements must be made, the analysis activity moves from the under development state into the awaiting changes state.