Use of multi-touch interfaces for collaborative software design has become increasingly important. Such surfaces can accommodate more than one user concurrently, which is particularly useful for collaboration. In this paper, the quality of collaborative software design using Unified Modeling Language (UML) was studied. In particular, we looked at if/how the quality of students' design diagrams could be enhanced in a contemporary multi-touch table environment, as opposed to a traditional PC based environment. The results showed that multi-touch environment increased the amount of physical interactions and subjects' engagement with the design activities. In addition, the multi-touch setting encouraged students to be engaged in a discursive conversation using "Creative Conflict" skills.

JavaScript as a Web scripting language has been widely used following the fast growth of Internet. Due to the flexible and dynamic features offered by the JavaScript language, it has become a challenging problem to statically reason about code written in JavaScript. As a first step towards building a mechanised verification system for JavaScript, we present, in this paper, an axiomatic verification system for a core subset of JavaScript based on a variant of separation logic. We have also defined a big-step operational semantics with respect to which we have demonstrated the soundness of our verification system.

The definitive version can be found at : http://onlinelibrary.wiley.com/ Copyright Wiley [Full text of this article is not available in the UHRA]

Robustness of a program is the degree of system correctness of all parts. Measuring robustness is a goal for many researchers. In this paper, program slicing is used to build a robustness hierarchy, where this hierarchy will be used to test, and build a robust program.

The key question with Service Science is to be how to formulate a theoretic foundation for service description, service discovery and service composition in the context of basic service system development and the building of service architecture. However, the current research and development in the field of Service Science assumes that the mapping between the service requesters' requirements and the formal and executable services provided by the service providers (or developers) is straightforward, without a clear view of unbalance or even semantic conflict between a requirement very likely in NL and a service as a programming module. In this paper, we attempt to address this issue by proposing an analytic model of atomic service for service composition based on our initial analysis of service structures and manipulations.

In order to characterize and improve software architecture visualization practice, the paper derives and constructs a qualitative framework, with seven key areas and 31 features, for the assessment of software architecture visualization tools. The framework is derived by the application of the Goal Question Metric paradigm to information obtained from a literature survey and addresses a number of stakeholder issues. The evaluation is performed from multiple stakeholder perspectives and in various architectural contexts. Stakeholders can apply the framework to determine if a particular software architecture visualization tool is appropriate to a given task. The framework is applied in the evaluation of a collection of six software architecture visualization tools. The framework may also be used as a design template for a comprehensive software architecture visualization tool.

Web services applications are built by the integration of many loosely coupled and reusable services using open standards. Testing Web service is important in detecting faults and assessing quality attributes. A difficulty in testing Web services applications is the unavailability of the source code for both the application builder and the broker. This paper propose a solution to this problem by providing a formal, specification-based approach for automatically generating test cases for web services based on the WSDL input messages parts' XML Schema datatypes. Examples of using this approach are then given in order to give evidence of its usefulness. The role of the application builders and the brokers in using this approach to test Web services is also described.

A new optimistic fair exchange protocol between a customer (C) and a merchant (M) is presented in this paper. It makes use of trusted third party (TTP) but its use is kept to minimum when disputes arise. The protocol is for exchanging a payment with a digital product such as software. A new idea, in which if the parties are willing to exchange then they are enforced to be honest, is originated in this protocol. The protocol has the following features: (1) it only comprises three messages to be exchanged between C and M in the exchange phase; (2) it guarantees strong fairness for both C and M; (3) it allows both parties to be sure of the item that they will receive from the other party before they receive it; and (4) it resolves disputes automatically online.

This paper describes our research into the application of fault injection to Simple Object Access Protocol (SOAP) based service oriented-architectures (SOA). We show that our previously devised WS-FIT method, when combined with parameter perturbation, gives comparable performance to code insertion techniques with the benefit that it is less invasive. Finally we demonstrate that this technique can be used to compliment certification testing of a production system by strategic instrumentation of selected servers in a system.

This paper demonstrates our Web Service based N-Version model, WS-FTM (Web Service-Fault Tolerance Mechanism), which applies this well proven technique to the domain of Web Services to increase system dependability. WS-FTM achieves transparent usage of replicated Web Services by use of a modified stub. The stub is created using tools included in WS-FTM. Our initial implementation includes a simple consensus voter that allows generic result comparison. Finally we show, through the use of a non-trivial example, that WS-FTM can be used to increase the reliability of a Web Service system.

Dominance trees have been used as a means for reengineering legacy systems into potential reuse candidates. The dominance relation suggests the reuse candidates which are identified by strongly directly dominated subtrees. We review the approach and illustrate how the dominance tree may fail to show the relationship between the strongly direct dominated procedures and the directly dominated procedures. We introduce a relation of generalized conditional independence which strengthens the argument for the adoption of the potential reuse candidates suggested by the dominance tree and explains their relationship with the directly dominated vertices. This leads to an improved dominance tree, the moral dominance tree, which helps aid program comprehension available from the tree. The generalized conditional independence relation also identifies potential reuse candidates that are missed by the dominance relation.

Side-effects are widely believed to impede program comprehension and have a detrimental effect upon software maintenance. This paper introduces an algorithm for side-effect removal which splits the side-effects into their pure expression meaning and their state-changing meaning. Symbolic execution is used to determine the expression meaning, while transformation is used to place the state-changing part in a suitable location in a transformed version of the program. This creates a program which is semantically equivalent to the original but guaranteed to be free from side-effects. The paper also reports the results of an empirical study which demonstrates that the application of the algorithm causes a significant improvement in program comprehension.

The problem of trying to view and comprehend large amounts of data is a well-known one. A specialised variant of this problem is the visualisation of software code and components for the purposes of understanding, decision-making, reuse and even integration. In particular the visualisation of software components, at a much higher level than source code, has received very little research. Visualisation is a powerful tool in situations such as this. This paper presents the application of real world metaphor based visualisations that address this problem. The application of visualisation to selecting software components is especially novel. It seeks to decrease the effort required by system integrators when locating suitable components in what is an increasingly crowded marketplace. Accurate information and understanding are vital if correct and informed decisions and judgements are to be made.

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.

Abstract This paper describes an impact analysis technique that identifies which parts should be retested after a system written in C++ is modified. We are interested in identifying the impacts of changes at the class member level by using dependency relations between class members. We try to find out which member functions need unit‐level retesting and which interactions between them need integration‐level retesting. To get precise analysis results, we adopt a technique that classifies types of changes and analyze the impact for each type. Primitive changes, changes which are associated with C++ features, are first defined and their ripple effects are computed in order to construct a firewall for each type of change systematically. We have applied our prototype tool to a real system with small size. This case study shows some evidence that our approach gives reasonable efficiency and precision as well as being practical for analyzing change impacts of C++ programs. Copyright © 2001 John Wiley & Sons, Ltd.

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.

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.

Software reuse has recently been considered the best solution to enhance the productivity of a software development team and to reduce maintenance costs. In addition, software configuration management (SCM) is a central part of software maintenance as it is associated with changing existing software, and is a discipline for controlling these changes and improving the maintenance process, thereby enhancing the quality of a software product. Thus, both software reuse and SCM have been proposed for making a significant improvement in productivity, quality and cost. However, so far these two technologies have been investigated separately. In order for software reuse and SCM to produce effects by synergy, both approaches require to be introduced into a maintenance environment together. Since software reuse and SCM, and software reuse and software maintenance have many similarities and relationships in their activities, these disciplines can be integrated within a software maintenance environment. The authors have therefore developed an integrated process model for maintenance with reuse (MwR) that supports SCM for a reuse library which is actively maintained for use in a maintenance environment. In this paper the MwR model and its prototype are described, followed by evaluation using a case study and conclusions.

This paper evaluates the suitability of dominance trees as a means of re-modularising legacy systems. It uses two factors to assess the suitability of the dominance tree approach as a restructuring mechanism. Firstly, it considers if dominance tree analysis identifies suitable reuse candidates and secondly, if the candidates generated represent an improvement to the structure of the code. Applications from two domains and software written in two development languages are used to evaluate the dominance tree's suitability factors. Sequential versions of the software are used to identify specific changes that are made to the software over time, to ensure that the reuse candidates identified are supportive of software change. The results show that overall the dominance trees are useful for software re-modularisation. Furthermore, the results of this study have revealed some interesting observations regarding the general characteristics of software and the process of software change.

The paper evaluates the suitability of reuse candidates identified through the dominance relation approach and their ability to support the process of software evolution. The paper provides an overview of the dominance relation and how it is used to identify the reusable candidates. The reuse candidates that are identified by this approach are then evaluated to see how they stand up to the process of software evolution. A number of case studies, and the results of the object's evolution, are described.

As software applications increase in size, grouping the application into smaller, more manageable components is often proposed as a means of assisting software maintenance activities. This paper investigates the suitability of components generated using data clustering techniques. The suitability of the approach is based on real case studies from a commercial environment. Successive versions of the software application are used to investigate how the software applications change throughout the maintenance process. Within this paper, the change process as a whole is referred to as the process of software evolution. This paper provides an indication of how applications evolve over time and how clustering techniques are affected by the evolution process.

Software Configuration Management and software reuse are now generally considered to be important technologies in software engineering. Both have been proposed for making a significant improvement in productivity and quality. However, these two technologies have been investigated separately. In order to make Software Configuration Management and reuse more effective, both approaches require to be introduced into a development or maintenance environment together. The authors have developed a process model for Maintenance with Reuse (MwR) to support Software Configuration Management for a reuse library within a maintenance environment. As software reuse and Software Configuration Management as well as software reuse and software maintenance have many similarities in their activities, and these areas can therefore be integrated within a software maintenance environment. An integrated approach to the common areas of these different activities will greatly contribute to the productivity and quality of software. This paper will address an integrated approach that can overcome some of the barriers that exist in software maintenance and reuse. A process model of an integrated approach has been created and validated using Process Weaver. In order for the reuse library to allow accesses from many potential reusers, the process model has been implemented on the WWW. The paper describes an integrated process model and its prototype to support change and version control for evolution of software components within both a reuse library and a legacy system.

This paper describes an investigation into the use of code replication within legacy software systems. Two cases of replication are investigated. These are replication with an individual program and replication of an entire or part of a program across a program suite. For each of the cases an example is given from code used within the commercial sector. The instances of replication are then investigated and the implication of their occurrences within the code on the maintenance process are considered. The reasons why code replication is not a form of software reuse are discussed. Finally this paper investigates whether, with reengineering, areas of high usage of code replication are potential candidates for reuse

We discuss how conventional testing criteria such as branch coverage can be applied to the testing of member functions inside a class. To support such testing techniques we employ symbolic execution techniques and finite state machines (FSMs). Symbolic execution is performed on the code of a member function to identify states that are required to fulfil a given criterion. We use FSMs to generate a sequence of member functions leading to the identified states. Our technique is a mixture of code-based and specification-based testing techniques in the sense that it uses information derived from codes using symbolic execution together with information from specifications using FSMs for testing activities.

We describe work performed for the IDENT project which is concerned with the identification and encapsulation of reusable modules. The aim of the project is to look at the integration of two methods for supporting maintenance; RE/sup 2/ and RECAST. We describe a case study where we try to extract reusable modules from a 21,000 line COBOL program. We approach this through the use of some of the basic methods addressed by the RE/sup 2/ reuse reengineering paradigm and some of the stages of the reverse engineering RECAST method. We have found that the identification of modules is very difficult because of high connectivity between data items. In order to deal with this problem we identify a number of strategies for removing particular data items using some of the RECAST stages and steps. These include the logical data model and system processing steps. However, in most cases we have found that such approaches were insufficient and that expert domain knowledge is also required to assist in module identification.

We present a new program slicing process for identifying and extracting code fragments implementing functional abstractions. The process is driven by the specification of the function to be isolated, given in terms of a precondition and a postcondition. Symbolic execution techniques are used to abstract the preconditions for the execution of program statements and predicates. The recovered conditions are then compared with the precondition and the postcondition of the functional abstraction. The statements whose preconditions are equivalent to the pre and postconditions of the specification are candidate to be the entry and exit points of the slice implementing the abstraction. Once the slicing criterion has been identified the slice is isolated using algorithms based on dependence graphs. The process has been specialized for programs written in the C language. Both symbolic execution and program slicing are performed by exploiting the Combined C Graph (CCG), a fine-grained dependence based program representation that can be used for most software maintenance tasks. The work described in this paper is part of RE2, a research project aiming to explore reverse engineering and re-engineering techniques for reusing software components from existing systems.

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 RE2 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.

AMES (Application Management Environments Support), ESPRIT Project no. 8156, is concerned not simply with program comprehension but with application understanding. This paper considers the difficulties of gaining an understanding of the detailed functioning of an application in order to perform maintenance, and describes a method and tool support which have been developed to guide a maintainer through this learning process. Our method uses a theoretical background based on learning theory, with our tools aiming to improve upon the approach of many existing program comprehension toolsets by linking related aspects of the application's documentation to form a united graph. Results of the application of our toolset are described and their implications discussed. Finally, we describe some of the future directions that we will be taking based on the results that we have obtained.

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.

This paper presents the results of research within the RE/sup 2/ project of a refinement of two existing methods for identifying reusable abstract data types. These methods are based on the relationships existing between the user defined types and procedure-like components that use them in their headings and on direct dominance trees and strong direct dominance trees that are refinements of the call directed graph of a program. It shows how these methods can be used to give a more precise set of reusable abstract data types. The method is then applied to a program and the results are compared with the existing method.>

The process of program comprehension is often aided by the use of static analysis tools to provide a maintainer with different views of the code. Each view however often requires a different intermediate program representation, leading to redundancies and repetition of information. A solution is to develop a single intermediate representation which contains sufficient information to construct each program view. This paper describes the Combined C Graph (CCG), a fine-grained intermediate representation for programs written in the C language from which program slices, call graph, flow-sensitive data flow, definition-use and control dependence views can be easily constructed. The CCG allows the representation of embedded side effects and control flows and value returning functions with value parameters. The effects of pointer parameters are also modelled. Construction of the CCG makes use of the PERPLEX C analysis tool which produces a generic Prolog fact base representation of the source code. Existing data flow analysis techniques are extended to allow the computation of flow-sensitive data flow analysis information.>

If better tools are to be developed to support the impact analysis task, greater clarity is needed about the exact nature of that task. This paper presents a definition of impact analysis and distinguishes between impact analysis and program understanding. Impact analysis is a necessarily approximate technique which must focus on the cost-effective minimization of unwanted side-effects. A key to effectiveness would be a way of precisely describing the semantics of each software change. A general model of software impacts is presented that uses flexible declarative propagation rules to describe the way software objects affect each other. Preliminary versions of the model have been implemented in an impact analysis system. A small case study was performed to gain experience in applying the model as part of a software change process. Recommendations are made for impact analysis tool support and for further research directions.>

Abstract Initial research in reuse was in the designing and implementation of reusable software. This research, although fruitful, did not address the area of extracting reusable components from existing software. In this paper the term reuse is used to mean the ‘reuse of existing source code’. A process called ‘reuse re‐engineering’ is defined and this, together with techniques from reverse‐engineering, form a new method for achieving reuse. A reference paradigm is established to implement the reuse re‐engineering process. This process is divided into five sequential phases, each characterized by the objects it produces. These phases are: candidature, election, qualification, classification and storage, and search and display. This paper concentrates on the first three phases because they produce reusable modules from existing systems. In selecting candidates for reuse, different abstractions have to be applied, namely functional abstraction (algorithms) and data abstractions (data structures and data types). This paper presents a formalized approach to each of these abstractions. The approach proposed in this paper aims to promote reuse in industrial software production environments.

Abstract The application of the Software Configuration Management (SCM) discipline during the maintenance process of an existing poorly documented software system is vital to bring it under control. Incremental documentation, the activity of building up the software documentation whilst it is examined during the maintenance process, has a key role in such a process. The COMFORM (COnfiguration Management FORmalization for Maintenance) system provides a framework for aiding the maintenance process through the application of the SCM discipline. In this way reliable documentation of an existing software system is obtained incrementally whilst maintaining it. Our goal in the design of the COMFORM system is to define a method for the maintenance process through the use of forms representing each phase of a software maintenance model. This approach allows traceability among the software representations throughout the software maintenance process. In this paper we describe the foregoing steps of the COMFORM system's method towards its formalization.

Abstract 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.

The results of a case study in identifying and extracting reusable abstract data types from C programs are presented. Reuse re-engineering processes already established in the RE/sup 2/ project are applied. The method for identifying abstract data types uses an interconnection graph called a variable-reference graph, and coincidental and spurious connections within the graph are resolved using a statistical technique. A prototype tool is described which demonstrates the feasibility of the method. The tool is used to analyze a C program, and a number of abstract data types are identified and used in the maintenance of the original program. The validity of the method is assessed by a simple manual analysis of the source code. The resulting reusable components are then specified using the formal notation Z.>

The reverse engineering into CASE technology method (RECAST) takes the source code for an existing COBOL system and derives a no-loss representation of the system documented in a structured systems analysis and design method (SSADM) format. One key element of the method is the abstraction of logical processing that affects the individual entities of the system. For each entity this processing is extracted from the physical implementation of the system using a program slicing technique and is then transformed into a logical representation (as an entity life history) using a set of translation and transformation rules. How the abstraction is achieved is described, and an example derived from an existing operational system that has been used as a case study for the method is given.>

COMFORM (configuration management formalisation for maintenance), a method which provides guidelines and procedures for carrying out a variety of activities performed during the maintenance process, is discussed. The proposed method accommodates a change control framework around which the software configuration management discipline is applied. The aim is to exert control over an existing software system while simultaneously incrementally redocumenting it.>

Inverse software configuration management has been identified as the process of bringing an existing (i.e., operational) software system under configuration control. PISCES (proforma identification scheme for configurations of existing systems), a software tool under development to help in this area, is discussed. PISCES identifies and documents the configurations of an existing systems. It reduces the time taken for a maintainer to understand a system configuration and provides the framework on which subsequent control of the product may be based. In this way it unifies the development and maintenance process.>

Proper management is an important factor in reducing the cost of software maintenance. Until now, well practiced and proven methods of management could not be applied to software maintenance due to the lack of visibility of the tasks and their outcomes. Increased visibility and predictive methods are required if the maintenance of large systems is to be brought under proper control. SCIMM (software change information for maintenance management) is a prototype system under development to help in this area. SCIMM stores information about requests for changes and changes made to software systems, with a view to easy access and retrieval of data and the provision of analysis to aid managers in prediction and planning.>

The Maintainer's Assistant is a code analysis tool aimed at helping the maintenance programmer to understand and modify a given program. Program transformation techniques are employed by the Maintainer's Assistant, both to derive a specification from a section of code and to transform a section of code into a logically equivalent form. The general structure of the tool is described and two examples of the application of program transformations are given.>

An intelligent, knowledge-based maintenance tool is described. The tool is intended to help reduce the amount of time spent on analyzing code. Code analysis is performed when a programmer is familiarizing himself with a piece of code and when the effects of a proposed modification of the code is being assessed. The research project is described, and its theoretical foundation is examined.>

The majority of software maintenance activity is performed on systems that are poorly documented and were built without the benefit of modern design practices. A discussion is presented of the importance of documentation in the maintenance phase, and a tool based on hypertext technology is proposed that can meet a number of the documentation needs of the maintenance programmer. This tool supports the following features: incremental documentation, casual update, quality assurance, team use, configuration management, integrated source code, integrated automatic documentation, and information hiding.>