Malcolm Munro

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.

Understanding function behaviors through program slicing

We present conditioned slicing as a general slicing framework for program comprehension. A conditioned slice consists of a subset of program statements which preserves the behavior of the original program with respect to a set of program executions. The set of initial states of the program that characterize these executions is specified in terms of a first order logic formula on the input variables of the program. Conditioned slicing allows a better decomposition of the program giving the maintainer the possibility to analyze code fragments with respect to different perspectives. We also show how slices produced with traditional slicing methods can be reduced to conditioned slices. Conditioned slices can be identified by using symbolic execution techniques and dependence graphs.

An early impact analysis technique for software maintenance

The accurate estimation of the resources required to implement a change in software is a difficult task. A method for doing this should include the analysis of the impact of the change on the existing system. A number of techniques for analysing the impact of a change on the source code have been described in the literature. While these techniques provide a good example of how to apply ripple effect analysis to source code, a weakness in these approaches is that they can be difficult to apply in the risk assessment phase of a project. This is because the source code is often not very well understood at this phase, and change proposals are written at a much higher level of abstraction than the code. It is therefore often the case that in practice subjective impact analysis methods are used for risk assessment and project investment appraisal. The underestimated resources for dealing with the ripple effects of a change can result in project schedules becoming so tight that only the minimal quality is achieved. This paper surveys existing ripple analysis techniques and then presents a new technique for the early detection of ripple effects based on a simple graph-theoretic model of documentation and the themes within the documentation. The objective is to investigate the basis of a technique for analysing and measuring the impact of a change on the entire system that includes not only the source code but the specification and design documentation of a system, and an early phase in the maintenance process.

An improved algorithm for identifying objects in code

The identification of abstractions within existing software systems is an important problem to be solved to facilitate program comprehension and the construction of a set of reusable artifacts. In particular, of interest is the identification of object-like features in procedural programs. Existing techniques and algorithms achieve some level of success but do not, in general, always precisely identify a coherent set of objects. The identified objects tend to contain spurious methods that are only tenuously related to the object and require a great deal of human effort and understanding to unravel. This paper presents an improved algorithm that overcomes these drawbacks and enables the precise identification of objects with less human intervention and understanding by exploiting simple statistical techniques. The algorithm is applied to several sample programs and the results are compared with existing algorithms. Finally, the application of the algorithm to a real medium-size system is described and discussed. The algorithm was developed as part of the RE 2 project in which the identification of object-like features in existing systems is the basis for a re-engineering process aimed at populating a repository of reusable assets.

The evolution of Websites

One major attraction of the World-Wide Web is the ease with which a relatively untrained user can create or modify a Web hypertext document. However, this same flexibility often causes problems of low quality similar to those encountered in software developed by programmers before the advent of software engineering. Evolution of software has been the subject of much recent research. It is now well understood that a large proportion of software costs arise during the maintenance phase. This research aims to characterise the evolution of Web sites in terms of new metrics and models. The research draws on the work on: (1) software evolution, and (2) the analysis of hypertext and software by use of metrics and other means. The work is being evaluated by means of case studies.

The future of software

Companies like British Telecommunications whose business is based on the performance of their software systems, should emphasize accessibility, adaptability, transparency, fail-safe operation, and a human face. Software Producing such software is difficult and involves high costs and risks. Adopting the most appropriate methods, technologies, and tools at just the right time is a major problem for the software industry. Recognition of the critical role played by software in so many aspects of society has therefore led us to pursue the following goals: • Forming a vision of software and software development based on the systematic use of expert judgement and peer review; • Establishing the need for a long-term software-development research agenda; and • Outlining a long-term research agenda that helps meet societys future needs for software that is reliable, adaptable, available when needed, and reasonably priced. Predicting the future is a popular pastime in many disciplines. In the field of software development, the February 1997 Communications offered many personal hopes and visions for the future of computer technology [1]. Authors expressed their personal views relating to particular technologies and applications , including databases [2], the Internet [3], and computational humanities [6]. In another personal view of future needs, Stuart Shapiro [5] examined a number of key software technology publications dating from as far back as the 1960s, concluding we need a more pluralistic approach to software engineering, Society is increasingly dependent on large and complex software systems. Indeed, if many of the current predictions about the Y2K computer problem turn out to be accurate, this dependency will be demonstrated dramatically on January 1, 2000. Users need software that meets stringent requirements, supports a range of interaction styles, can be produced quickly, and can be maintained to keep pace with the ever-increasing demand for functional-ity, quality, flexibility, and cost-effectiveness.

Virtual but visible software

The problem of trying to view and comprehend large amounts of data is a well-known one. A specialised version of this problem, that of visualising program code (often known as software visualisation) has suffered from the field refusing to embrace new ideas and technologies. The paper presents an application of virtual reality to this problem and highlights areas of importance from virtual reality that have been used to good effect when creating graphical abstractions of Java source code. A summary of the achievements of this approach and the relationship to the virtual reality features believed to be most beneficial is provided.

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.

Identifying reusable functions using specification driven program slicing: a case study

We present the results of a case study in identifying and isolating reusable functions from C programs. The work exploits and specializes to programs written in C the theoretical framework of specification driven program slicing, a new program slicing process for isolating code fragments implementing functional abstractions. The specification of the function to be isolated, given in terms of a precondition and a postcondition, is used to identify a suitable slicing criterion. The preconditions for the execution of program statements and predicates are abstracted by using symbolic execution and compared with the conditions of the specification. The statements whose preconditions are equivalent to the pre and postconditions of the functional abstraction are candidates for entry and exit points of the slice implementing the abstraction. Once the slicing criterion has been identified, the slice can be isolated using algorithms based on control flow graphs and dependence graphs.

Comprehension with[in] virtual environment visualisations

For many years, basic visualisation based around simple boxes and lines, has been done in an attempt to be able to ease some of the cognitive overload caused by program comprehension. The problems with such visualisations is that they can very easily become incomprehensible by trying to force large amounts of information into a small space, relying solely on two dimensions for the representations. Three-dimensional visualisations are one approach that is being considered to combat these problems, although there are also many different issues that must be considered for these sorts of visualisations. Especially when those visualisations are of intangible software systems. A solution is to use virtual environments as a base for these three-dimensional visualisations, which allows a sense of context to be maintained and also promotes collaboration between the people trying to comprehend the code.