Successful Evolution of Software Systems
Real-world software needs to evolve continually in order to cope with ever-changing software requirements. Manny Lehman identified this characteristic in his so-called first law of software evolution, which addresses continuing change: a program that is used must be continually adapted else it becomes progressively less satisfactory. This need for software to evolve continuously poses important challenges for software engineers. Advanced automated software engineering techniques and tools are needed to improve software evolution support. Two important techniques that will be investigated are software restructuring and aspect-oriented software development.
Software Restructuring Software restructuring should be an essential activity in software engineering, according to Lehman's second law of software evolution, which addresses increasing complexity: as a program evolves its complexity increases unless work is done to maintain or reduce it. In program transformation research, two different restructuring approaches can be distinguished.
The term rephrasing is used to refer to techniques that improve the structure of the software without changing the implementation language. A typical example is software refactoring, which tries to improve the internal structure of a program without changing its external behaviour.
The term 'translation' refers to techniques that restructure the software across programming languages. Aspect-Oriented Software Development. An essential problem with software development is the tyranny of the dominant decomposition.
No matter how carefully a software system is decomposed into modular units, there will always be concerns typically non-functional ones that cut across the chosen decomposition. This is true both for infrastructure-based capabilities that have ample bandwidth to permit the use of centralized computing centers, and for deployed capabilities where bandwidth limitations often dictate a deployed version of a virtualized computing, storage, and network utility infrastructure.
Virtual platforms are of particular value in a deployed environment, where the resulting efficiencies can lower the lift capacity required to deploy a combat unit, as well as lower the space, weight, power, and cooling required in a ship or an aircraft installation. Virtual platforms also have the potential to lower sustainment costs otherwise inherent in program-specific approaches to logistics support.
Finally, virtual platforms enable SDCI IT programs to focus exclusively on deployment decisions involving only their own specific systems as machine images, and at the. Chapters 1 and 2 of this report highlighted the difficulty of applying a governance and oversight regimen based on hardware and weapons system development to IT programs. Advocates of the current governance and oversight structure sometimes assert that this structure permits tailoring and provides all the flexibility needed for an MDA or a PM to adjust the way that the process is applied to specific programs.
Even if these advocates are right, given the central importance of the rapid and effective acquisition of IT systems, there should be no reason that each MDA and each PM be required to define de novo a development and oversight process attuned to an IT program. There are fundamentally different classes of issues involved in each of these cases. This examination focuses on the two categories of IT programs identified in the introductory chapter of this report:.
SDCI programs —those focused on the development of new software to provide new functionality or focused on the development of software to integrate COTS components, and.
The resulting advance of networking, computing, and storage capacity in COTS hardware led the DOD to begin abandoning purpose-built military hardware and to embrace COTS hardware for IT programs beginning in the s, even for tactical systems. For example, in the Navy, the Desktop Tactical Com-. This change took place against the backdrop of commercial technology migrating from a data-center-based computing environment to a highly networked, client-server environment with substantial computational power available at every desk.
The trend toward COTS was further reinforced in when Secretary of Defense William Perry issued a memorandum prohibiting the use of most military standards without waivers and encouraging in their place the use of performance specifications and industry standards. In contrast to the hardware components, the software components of IT programs are most heavily influenced by the fast pace of technology change in the Internet environment and by the fundamental difficulty in defining requirements 23 for many classes of software systems, especially but not limited to human-interactive software systems.
In the commercial Internet environment that defines the experience base of most young men and women entering the military today, new software capabilities are introduced on a regular and routine basis, often with significant end-user involvement and feedback through early alpha and beta release programs. Fundamentally different classes of issues are involved when dealing with hardware versus software components of IT programs.
Therefore, different strategies are appropriate when addressing the different components. In both cases, rapid change is a fundamental factor that must be addressed, and IID acquisition strategies are indeed appropriate.
However, the nature of the capability increments should differ for hardware and software components owing to the different issues driving them. This has been particularly true for IT programs defined to provide deployable capability such as command, control, communications, computers, intelligence, surveillance, and reconnaissance C4ISR or combat support programs for deployed land, air, and maritime force elements. During the early days of COTS hardware adoption by the DOD, the capacity of available hardware and the nature of the software environment dictated that many systems be single-purpose.
Several key factors have changed significantly since those early days, however. At the same time, operations and sustainment costs have grown along with the complexity of IT systems.
- What is release management?!
- Agile development methodology;
- Systems engineering!
- Download the SEG.
- The Battleships;
- What is release management?.
- Looking for other ways to read this??
In addition, virtualization technology has matured. This has created a compelling business case for virtualized computing, storage, and network infrastructure utility models in many enterprise environments. The existence of such infrastructure can decouple the time cycles of SDCI capability increments from the need to deploy or refresh hardware, allowing SDCI IT programs or portfolios of programs to deploy capability to end users with significantly increased speed and agility. This is particularly true for server applications. With regard to client-side components, the use of a standardized technology platform on top of a virtualized computing, storage, and network infrastructure can further increase speed and agility.
Absent a compelling case to the contrary, the CHSS components of IT systems and SDCI software elements of IT systems should be acquired through independent IID acquisition programs with the nature of the capability increments structured to address the different issues associated with hardware and software components. Moreover, platform-based virtualized computing, storage, and networking utility models should be favored wherever possible. They also further define the use of a platform-and virtualization-based approach and show how this approach can be visualized and managed as a combination of these two categories of programs.
IT programs that are focusing on SDCI efforts are most heavily influenced by elevated end-user expectations that are based on the pace of technological change experienced by most users every day in the Internet environment, and by the fundamental difficulty in defining requirements for many classes of software systems, especially human-interactive software systems. SDCI IT programs must therefore focus not only on the functional and nonfunctional capabilities that they are chartered to provide, but also on employing IID practices for software development and program management practices that represent the best practices in software engineering.
As discussed earlier in this chapter, the roots of IID software development methods can be traced back many years. Nevertheless, the influence of the waterfall model persists to this day in the current DOD governance and oversight process. This type of effort places increasing focus on the acquisition process at the expense of focus on the product. To break this hammerlock on software-intensive IT programs, several aspects of the program structure and the governance and oversight regimen would need to be changed through the adoption of the following core principles:.
Time-boxed incremental deliveries of usable capabilities also known as capability increments. Early focus on nonfunctional requirements and an architecture suited for the intended operating environment. Streamlined processes for requirements definition, budgeting, operational testing, and oversight. Curtis, H. Krasner, V. Shen, and N. Performance of integrated testing and evaluation commensurate with risk and benefit. In particular, the voice of the user as a prominent factor throughout each iteration within each capability increment. An acquisition governance process that empowers end users in the acquisition oversight decision processes.
The decomposition of larger programs into smaller projects or increments that are delivered to the user in an evolutionary manner. Incremental build-out of the architecture in scope and scale sufficient to meet the needs of the functional requirements of each capability increment. To fully internalize these core principles, SDCI programs should be structured as IID programs with time-boxed capability increments of not longer than 12 to 18 months to deliver meaningful capability to end users. Key to IID software methods is the acknowledgment of the difficulty of document-centric attempts to fully specify requirements in advance and the necessity of replacing such an approach with an iterative, incremental learning and communications process taking place between developers and end users.
Each iteration will include analysis, design, development, integration, and testing to produce a progressively more defined and capable, fully integrated and tested product.
This process is shown in Figure 3. It is natural that early increments would spend more time in the front-end processes of architecture and design, while later increments would spend more time in the back-end processes. The two steps in the iteration of integration and testing are essential elements, because they serve to force direct understanding of the progress or lack of progress actually being made at frequent, well-defined checkpoints. From one perspective this approach can be regarded as a traditional application of systems engineering processes, but there are several important differences.
Many regard some forms of IID as a test-driven process, since testing is addressed and tests are defined even before design and implementation. Further, when testing is actually conducted, the voice of the end user is integrated directly into the process, with direct effects on the further refinement of requirements and on the planning, and potentially the reprioritization, of subsequent iterations. This sequence of events reflects both a learning cycle and a communications cycle in each iteration. Other stakeholders should also be involved in the process, including developmental and operational test stakeholders, security certification and accreditation stakeholders, and interoperability stakeholders.
For such an approach to succeed and materially change the dynamics of the current time-consuming and unsatisfying process, all of the stakeholders that warrant a voice in the ultimate fielding decision should be integrated into this voice-of-the-end-user learning and communications cycle. A case can certainly be made that the operational end user is the most significant among the various entities that have an interest in the outcome and that the voice of end users should therefore be louder than that of the others.
Chapter 4 presents more detail on testing and acceptance and on the formulation of an acceptance team that can serve as and also channel the voice of the end user. The content of early iterations should be focused on a combination of the most technically challenging elements of the capability increment and on functional capabilities with the greatest business or warfighting value.
Aspect-Oriented Software Evolution
The voice of the end user should provide feedback on each iteration for the refining and prioritizing of requirements in order to institutionalize the learning and communications process vital to IID. Since this voice of. This implies a profound change to the Joint Capabilities Integration Development System process, for example, which is currently biased toward the document-centric, up-front detailed specification of functional requirements. Nonfunctional requirements for software-intensive IT systems such as security and information assurance, operational availability, scalability, and performance are fundamental attributes of systems architecture, especially in distributed systems, and they need to be communicated clearly by the appropriate stakeholders.
Similarly, the operational environment in which such a system must function can profoundly affect the system architecture. For SDCI programs of any significant scope and scale, system architecture is likely to represent one of the most significant risks, and it should be addressed early in the program, even during the concept development phase in advance of entering the development of capability increments. Here again, however, caution and pragmatism must be exercised to prevent susceptibility to the demand that all requirements must be fully documented up front.
Although these nonfunctional and environmental requirements will have a profound effect on the system architecture, building out the system architecture is itself a learning and communications process that is best accomplished in an IID fashion. Similarly, although one can perhaps understand the top-level nonfunctional requirements very well up front, their refinement into lower-level requirements that drive design and implementation is also best addressed in an IID fashion.
At the same time, this should not be construed to suggest that big-R requirements will not change. Feedback on those is also important and should be accommodated. Any SDCI program must have a clear vision of an end-state target architecture appropriate to support both the full scope of the intended capability and the full scale of the intended deployment from the outset.
Reconstruction of successful software evolution using clone detection - IEEE Conference Publication
It is at a minimum impractical and in most cases impossible to implement or even to fully prove the full scope and scale of the architecture either in the early pre-Milestone B concept development phase or in early capabil-. The architecture, like the other aspects of the software in an IID approach, should be built up in scope to support the planned functionality of each capability increment, and should be built up in scale to support the planned deployment scope of each capability increment.
Since the voice of the end user can adapt priorities across iterations within each capability increment, the learning that takes place through this process can affect the ability to achieve all of the objectives originally targeted for the increment.