Abstract As the software industry shifts towards a service‐oriented model of development and delivery, complex forms of interaction, such as negotiation, will become dominant. The design of a negotiation system in the context of an open service‐oriented model is a complex task and involves many interrelated issues. This paper presents a negotiation description language; the purpose of which is to provide a high‐level description of a negotiation situation in such a way that facilitates human reasoning about negotiation‐related aspects in a service‐oriented context. Copyright © 2004 John Wiley & Sons, Ltd.

Software comprehension is one of the largest costs in the software lifecycle. In an attempt to control the cost of comprehension, various complexity metrics have been proposed to characterize the difficulty of understanding a program and, thus, allow accurate estimation of the cost of a change. Such metrics are not always evaluated. This paper evaluates a group of metrics recently proposed to assess the "spatial complexity" of a program (spatial complexity is informally defined as the distance a maintainer must move within source code to build a mental model of that code). The evaluation takes the form of a large-scale empirical study of evolving source code drawn from a commercial organization. The results of this investigation show that most of the spatial complexity metrics evaluated offer no substantially better information about program complexity than the number of lines of code. However, one metric shows more promise and is thus deemed to be a candidate for further use and investigation.

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.

This paper has briefly presented an approach to identifying the comprehensibility of a program and initial results from its application. The results obtained so far, indicate that this approach is useful in modelling the comprehensibility of a program as it evolves. However further work is required to calibrate this approach to more accurately reflect comprehensibility and to identify at what point corrective action should be undertaken to maintain the quality of the program.

We address the problem of large-scale data integration, where the data sources are unknown at design time, are from autonomous organisations, and may evolve. Experiments are described involving a demonstrator system in the field of health services data integration within the UK. Current Web services technology has been used extensively and largely successfully in these distributed prototype systems. The work shows that Web services provide a good infrastructure layer, but integration demands a higher level "broker" architectural layer; the paper identifies eight specific requirements for such an architecture that have emerged from the experiments, derived from an analysis of shortcomings which are collectively due to the static nature of the initial prototype. The way in which these are being met in the current version in order to achieve a more dynamic integration is described.

Effective use of heterogeneous, distributed information in a coherent, integrated fashion has long been a "holy grail". The UK Health and Social care domain is an example where a global view is needed to facilitate decision making, whilst having ethical and legal concerns. The IBHIS project aims to provide an integrated broker that enables coherent use of a set of distributed, heterogeneous data sources, whilst ensuring trustworthiness and audit. This paper presents a service-oriented federated architecture for the IBHIS broker.

Software as a service (SAAS) is a long-term research project aimed at developing technologies and methods for the rapid production and evolution of software systems by providing software as a service rather than as a product. Recently, there has been a growing interest in bringing intelligent solutions to Internet based computing. Automated negotiation has been at the center of such interest. This paper is concerned with the implications of negotiating software services under the software as a service model.

Software maintenance, just like any other software engineering activity, is being conducted in an increasingly distributed manner by teams which are often virtual. This paper critically reviews existing models for virtual organisations, investigates issues affecting distributed software maintenance teams (DSMT) and proposes a model for selecting the appropriate computer supported cooperative work (CSCW) and groupware tools and technologies in order to facilitate communication and resource allocation for DSMT. This model builds on current theories, classifications and major concepts in the area of CSCW and advances the way DSMT are perceived. This theoretical model is yet to be empirically evaluated and enriched so that it includes workflow management systems.

Program and system comprehension are vital parts of the software maintenance process. We discuss the need for both perspectives and describe two methods that may be integrated to provide a smooth transition in understanding from the system level to the program level. Results from a qualitative survey of expert industrial software maintainers, their information needs and requirements when comprehending software are initially presented. We then review existing software tools which facilitate system level and program comprehension. Two successful methods from the fields of data mining and concept assignment are discussed, each addressing some of these requirements. We also describe how these methods can be coupled to produce a broader software comprehension method which partly satisfies all the requirements. Future directions including the closer integration of the techniques are also identified.

Accelerating the learning curve of software maintainers working on systems with which they have little familiarity motivated this study. A working hypothesis was that automated methods are needed to provide a fast, rough grasp of a system, to enable practitioners not familiar with it, to commence maintenance with a level of confidence as if they had this familiarity. Expert maintainers were interviewed regarding their strategies and information needs to test this hypothesis. The overriding message is their need for a "starting point" when analysing code. They also need standardised, reliable and communicable information about a system as an equivalent to knowledge available only to developers or experienced maintainers. These needs are addressed by the proposed "roughcut" approach to program comprehension. Work underway assesses the suitability of using data mining techniques on data derived from source code to provide high level models of a system and module interrelationships.

The urgent need to change software easily to meet evolving business requirements requires a radical shift 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. We describe a service architecture and its rationale, in which components may be bound instantly, just at the time they are needed and then the binding may, be disengaged. This allows highly flexible software services to be evolved in "internet time". The paper focuses on early results: some of the aims have been demonstrated and amplified through an experimental implementation based on e-Speak, an existing and available technology. It is concluded that technology such as e-Speak provides a useful infrastructure that rapidly enabled us to demonstrate the basic operation and viability of our approach.

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.

In the early 1980s there was much reference to the "software crisis": the inability to deliver to software-based systems which met user requirements and were delivered on time and within budget. There is no doubt that since this time, the ability to deliver complex software systems has developed very significantly, but in doing so has created new expectations and pressures which has led to a "software evolution crisis". Whilst there may be many reasons for this crisis, one significant factor has been the appearance of a new type of emergent, organisational structure, in which a business is constantly reorganising, changing its boundaries and reconfiguring its activities. Such "emergent organisations" place new demands on the software development process, in particular on the need for extreme flexibility in software. However, the focus of much software-related research has been on systems with relatively stable boundaries and hence an apparent deterioration in the ability of software to change to new circumstances and need. In recognition of this problem, a project has been running in the UK for a number of years, The key concept emerging from this work is that of software as a service, rather than a product.

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.

Software engineering is no longer the preserve of individuals but is essentially a team-based activity involving a wide variety of stakeholders and thus making the need for communication and co-operation an inherent characteristic. Changes in support technology, economic factors and globalisation of the software process is resulting in the geographical separation of personnel. Where such distribution of personnel occurs, it is clear that the quality of the project will be dependent upon the degree of effective communication and co-operation. This paper presents the results from a study of communication and co-operation practices on a range of distributed software projects from an industrial and educational context. It analyses the advantages and disadvantages of distributed software engineering teams and presents the lessons learned from these studies, including team structure, project management, communication and procedures.

Distributed group working amongst teams of software engineers is increasingly evident in the 'real world'. Tools to support such working are at present limited to general-purpose groupware involving video, audio, chat, shared whiteboards and shared workspaces. Within software engineering education, group tasks have an established role in the curriculum. However in general, groups are local to a particular university or institution and are composed of students who have a significant shared history (in terms of technical background and social interaction) and who are able to meet face-to-face on a regular basis. This paper reports on work undertaken by three UK Universities to provide computer science students with the opportunity to experience group working across universities using low-cost tools to support distributed cooperative working.

An empirical study is presented that explores how dangerous errors can be introduced into software by the simplest of maintenance tasks. Six different maintenance problems were given to eight intermediate level programmers. Each maintenance problem was coded using the C++ language and were selected from a domain that was deemed to be familiar to all subjects. An alarming level of error was discovered. Analysis of the maintained software showed that one third of all the resulting programs contained an error of some form. Reasons why the error rates were so high are considered and two broad approaches to the reduction of maintenance error are described.

Abstract With the growing awareness of the importance of software maintenance has come a re‐evaluation of software maintenance tools. Such tools range from source code analysers to semi‐intelligent tools which seek to reconstruct system designs and specification documents from source code. However, it is clear that relying solely upon source code as a basis for reverse‐engineering has many problems. These problems include poor abstraction, which leads to over‐detailed specification models and the inability to link other parts of a software system, such as documentation and user expertise, to the underlying code. This paper describes the work of the Esprit DOCKET project which has developed a prototype environment to support the development of a system model linking user‐oriented, business aspects of a system, to operational code using a variety of knowledge source inputs: code, documents and user expertise. The aim is to provide a coherent model to form the basis for system understanding and to support the software change and evolution process.

Abstract This paper presents the results of a survey conducted on the perceptions and practices in software maintenance in five major companies in the United Kingdom. It is clear from the study that software maintenance is undergoing a significant transformation, in particular, in terms of its image, its relationship with users and in the nature of software maintenance tools required. The image of the software maintenance task appears to be changing from one which is dull, passive and isolated to one which is reactive, responsive and vital to the business. Maintenance departments are becoming more accountable to user departments and are developing a market orientation. The study found little use of existing software maintenance tools and identified a need for support technology which will facilitate communication between users, developers and maintenance staff. The paper presents the background to the investigation, the procedures followed and a summary of current practice. An analysis of the material highlights the main problems and trends identified within software maintenance practice and its implications upon organizational structure.

Abstract The Esprit DOCKET project seeks to reduce the problems associated with software maintenance through enhancing traditional, reverse engineering tools with other sources of knowledge, enabling mainters to produce more accurate system models. To produce accurate system models, knowledge about an information system, obtained from different sources, must be interpreted and integrated into a single model (known as the global system model in DOCKET). The definition and implementation of such a model involves the resolution of many issues. These include multiple views of a system at different levels of abstraction, handling inconsistency, incompleteness and system description evolution. This paper reports on the implementation of the Global System Model using the language SML. SML enabled design and implementation problems to be surmounted at a high level of abstraction and facilitated the rapid implementation and testing of the global system model, greatly reducing the effort required to implement it compared to more conventional facilities.

The authors present the results of a survey conducted on the perceptions and practices in software maintenance in five major companies in the United Kingdom. It is clear from the study that software maintenance is undergoing a significant transformation, in particular, in terms of its image, its relationship with users, and the nature of software maintenance tools required. The image of the software maintenance task appears to be changing from one which is dull, passive, and isolated to one which is reactive, responsive, and vital to the business. Maintenance departments are becoming more accountable to user departments and are developing a market orientation. The study found little use of existing software maintenance tools and identified a need for support technology which will facilitate communication among users, developers, and maintenance staff. The authors present the background to the investigation, the procedures followed, a summary of current practice, and an analysis of the problems and trends identified.>

The Jackson structured program (JSP) methodology as widely practiced does not directly address problems of software maintenance, but rather implies restrictions on modifications of finished program designs. An investigation is made which defines limits of permissible changes to data structures and process structures, and these changes are incorporated into rules that will govern and therefore control change. The investigation into these permissible changes centers on structural changes, as nonstructural changes do not have the same potentially severe effects. The rules lend themselves to both computerized and manually produced program specifications based on the Jackson method.>

The authors demonstrate an approach to software development known as RUBRIC, which recognizes that a particular class of system, namely, business information systems, contain a large element of information processing which is dictated by business needs and that these needs will inevitably change. Consequently, RUBRIC separates data from procedure and business policy from operational procedure, and presents explicit models for all of these. This approach thereby maintains the visibility of those parts of a system which are most volatile and subject to change and thereby reduces system maintenance costs.>

The evolutionary nature of computer programming has necessitated the continual development and enhancement of programming languages. In an effort to make programming languages more responsive to such changes, a number of language extensibility schemes have been designed. This paper examines the history of macro processors as a tool for programming language extensibility.

A working party of the British Computer Society has designed a facility which allows users to configure their COBOL compilers to accept different dialects of COBOL. The facility, known as the COBOL Language Enhancement Facility (CLEF), was produced in response to users' requirements to enhance their versions of COBOL. This paper reviews the development of CLEF: looking at the users' requirements, identifying design criteria and outlining the design, implementation and evaluation of CLEF.

Abstract Most syntax analysis phases of COBOL compilers are written as sequences of procedural code instructions each of which validates a particular part of the syntax of a COBOL program. This paper examines the structure of a syntax driven COBOL compiler and a practical implementation is described. The problems encountered with this type of compiler construction are explained, and its advantages are examined. Finally, some other potential applications of syntax driven technology are suggested.