Keith H. Bennett

A staged model for the software life cycle

Software engineers have traditionally considered any work after initial delivery as simply software maintenance. Some researchers have divided this work into various tasks, including making changes to functionality (perfective), changing the environment (adaptive), correcting errors (corrective), and making improvements to avoid future problems (preventive). However, many have considered maintenance basically uniform over time. Because software development has changed considerably since its early days, the authors believe this approach no longer suffices. They describe a new view of the software life cycle in which maintenance is actually a series of distinct stages, each with different activities, tools, and business consequences. While the industry still considers postdelivery work as simply software maintenance, the authors claim that the process actually falls into stages. They think both business and engineering can benefit from understanding these stages and their transitions.

Service-based software: the future for flexible software

For the past 40 years, the techniques, processes and methods of software development have been dominated by supply-side issues, giving rise to a software industry oriented towards developers rather than users. To achieve the levels of functionality, flexibility and time-to-market required by users, a radical shift is required in the development of software, with a more demand-centric view, leading to software which will be delivered as a service within the framework of an open marketplace. Already, there are some signs that this approach is being adopted by industry, but in a very limited way. We summarise research and a research method which has resulted in a long-term strategic view of software engineering innovation. Based on this foundation, we describe more recent work, which has resulted in an innovative demand-side model for the future of software. We propose a service architecture in which components may be bound instantly, just at the time they are needed, and then the binding may be discarded. A major benefit of this approach is that it leads to highly flexible and agile software that should be able to meet rapidly changing business needs.

Approaches to program comprehension

Abstract Software maintenance is recognized as the most expensive phase of the software life cycle. The maintenance programmer is frequently presented with code with little or no supporting documentation, so that the understanding required to modify the program comes mainly from the code. This paper discusses some of the current approaches to theories of program comprehension and the tools for assisting the maintenance programmer with this problem.

Software evolution: past, present and future

Abstract Much of the focus of software engineering has been on the initial development of software. The subsequent fate of the software has not been seen as a major issue. However, for much long-lived commercial and industrial software, the largest part of lifecycle costs is concerned with the evolution of software to meet changing needs. The cost-effective evolution of mission-critical software, for example, is still a major challenge. In this paper we review progress in software evolution in order to provide an overview for the conference. Much progress has been made in meeting industrial needs in recent years, and we can now think in terms of solutions rather than in problems alone. Some excellent case studies are available to demonstrate what is possible. The field is presented as a three-level model. At the top level, the way in which software evolution interacts with organizational needs and goals is addressed. The paper then concentrates on the middle, process layer, and explains the new proposed IEEE standard for maintenance processes. Finally, important technologies (particularly impact analysis) to underpin the process activities are described. This paper reviews the current state-of-the-art, and suggest some future trends for software evolution, along with key research issues.

An Architectural model for service-based software with ultra rapid evolution

There is an urgent industrial need for new approaches to software evolution that will lead to far faster implementation of software changes. For the past 40 years, the techniques, processes and methods of software development have been dominated by supply side issues, and as a result the software industry is oriented towards developers rather than users. Existing software maintenance processes are simply too slow to meet the needs of many businesses. To achieve the levels of functionality, flexibility and time to market of changes and updates required by users, a radical shift is required in the development of software, with a more demand-centric view leading to software which will be delivered as a service, within the framework of an open marketplace. Although there are some signs that this approach is being adopted by industry, it is in a very limited and restricted form. We summarise research that has resulted in a long term strategic view of software engineering innovation. Based on this foundation, we describe more recent work that has resulted in an innovative demand-led model for the future of software. We describe a service architecture in which components may be bound instantly, just at the time they are needed and then the binding may be disengaged. Such ultra late binding requires that many non-functional attributes of the software are capable of automatic negotiation and resolution. Some of these attributes have been demonstrated and amplified through a prototype implementation based on existing and available technology.

A transformation system for maintenance-turning theory into practice

An outline of the principles and design features of the Maintainers Assistant is presented. The main results presented concern the method by which the previously developed theoretical approach has been interpreted to provide the means to address the reverse engineering of real-world programs of medium size, written in IBM 370 Assembler. In particular, the use of appropriate metrices to guide the user during the process of program transformation is described. Results are given to show the success of the tool when it has been applied to real code.<<ETX>>

Using Web service technologies to create an information broker: an experience report

This paper reports on our experiences with using the emerging Web service technologies and tools to create a demonstration information broker system as part of our research into information management in a distributed environment. To provide a realistic context, we chose to study the use of information in the healthcare domain, and this context sets some challenging parameters and constraints for our research and for the demonstration system. In this paper, we both report on the extent to which existing Web service technologies have proved to be mature enough to meet these requirements, and also assess their current limitations.

Decision model for legacy systems

Legacy systems pose major problems for industry-existing software seems so difficult and expensive to change quickly to keep up with the needs of business. The authors firstly summarise the general problems with modifying existing software-termed software maintenance-and then address the problems of legacy systems. They show that one of the major difficulties is trying to decide rationally among very different options, ranging from discarding the old software completely, through reverse engineering, to freezing it, or outsourcing. A novel two-phase model is presented to assist organisations in making decisions about legacy systems. The first phase, often neglected, is to model business strategy from a top-down perspective, involving many stakeholders. This is then used as input to a technical phase, where solutions are evaluated according to their ability to meet the objectives identified in phase one.

Software engineering research: a critical appraisal

It is argued that computer science and software engineering should be regarded as separate disciplines, and that the long term success of academic computer science departments will only be secured by adopting a stronger engineering stance in research, enhanced by closer links with industry. A number of ways are suggested to revitalise the software engineering community and forge stronger links with industry, particularly through a better and more coherent research base.

Formal methods for legacy systems

A method is described for obtaining useful information from legacy code. The approach uses formal proven program transformations, which preserve or refine the semantics of a construct while changing its form. The applicability of a transformation in a particular syntactic context is checked before application. By using an appropriate sequence of transformations, the extracted representation is guaranteed to be equivalent to the code. In this paper, we focus on the results of using this approach in the reverse-engineering of medium-scale, industrial software, written mostly in languages such as assembler and JOVIAL. Results from both benchmark algorithms and heavily modified, geriatric software are summarized. It is concluded that the approach is viable, for self-contained code, and that useful design information may be extracted from legacy systems at economic cost. We conclude that formal methods have an important practical role in the reverse-engineering process.