Abstract not found

An infrastructure is a set of interconnected structural elements, such as tools and schemas, that provide a framework for supporting an entire structure. The reverse engineering community has recognized the importance of interoperability, the cooporation of two or more systems to enable the exchange and utilization of data, and has noted that the current lack of interoperability is a contributing factor to the lack of adoption of available infrastructures. To address the problems of interoperability and reproducing previous results, we present an infrastructure that supports interoperability among reverse engineering tools and applications. We present the design of our infrastructure, including the hierarchy of schemas that captures the interactions among graph structures. We also develop and utilize our implementation, which is designed using a GXL-based pipe-filter architecture, to perform a case study that demonstrates the feasibility of our infrastructure. 1

This paper introduces the GraX graph exchange format that can be used by software engineering tools. The data to be transferred are separated into a schema and an instance part which are both exchanged in the same way. The application of GraX as a vehicle for tool interoperability will be exemplified in the context of CASE and software reengineering tools. Keywords: exchange format, XML, CASE tool interoperability, reengineering tool interoperability, graph technology 1 Motivation To enable interoperability between tools supporting various tasks in software engineering a suitable mechanism for interchanging data between those tools is required. Several data exchange formats have been developed to exchange models of software systems and information systems on various levels of abstraction (for CASE 1 tools see e. g. CDIF [7, 8] and XMI [11] and for CARE 1 tools see e. g. ASFIX [12], RSF [16], and TA [9]). Due to the heterogeneity of the subject domain of different tools ther...

Software evolution and maintenance problems might be caused by all kinds of new or changed requirements. However, McCabe [McC98] has identified a number of requirements, which are currently of special importance because they are responsible for significant mass changes in today's business software. Among these central requirements are the Year-2000 problem [Mar97a], the Euro-conversion problem [Gro98], and the ability to compete on a global, electronic market. The primary concern of all these requirements is the issue of how business data should adequately be represented in software systems. The addressed problems range from simple questions, e.g., for the number of digits that are necessary to represent a date (Year-2000 problem), up to complex architectural decisions, e.g., how to federate data maintained by diverse (formerly autonomous) information systems and integrate these systems with the Web to facilitate electronic commerce.

Many tools have been developed for recovering the design of legacy software. Interactively invoked abstraction operations and re-design transformations play a central role in these tools. A limitation of most existing approaches is, however, that they assume a mostly linear transformation process. They provide little support for iteration, recursion and incremental changes during the recovery process. Nevertheless, empirical results suggest that real-world abstraction and reengineering processes are in fact highly iterative. A history mechanism that explicitly maintains dependencies of all performed transformations can overcome this mismatch. Based on our experience with a specialized implementation of such a mechanism, we present a generalized history concept as an add-on to existing tools that support design recovery.

The E-CARES project addresses the reengineering of large and complex telecommunication systems. Within this project, graphbased reengineering tools are being developed which support not only the understanding of the static structure of the software system under study. In addition, they support the analysis and visualization of its dynamic behavior. The E-CARES prototype is based a programmed graph rewriting system from which the underlying application logic is generated.

www.omnicore.com www.vxu.se Many software systems are mixed-language systems today, i.e., they bind together components defined in different programming and specification languages. Analyses and refactorings implemented in current software development tools, e.g., integrated development environments (IDEs), cannot process these mixed-language systems as a whole since they are too closely related to particular programming languages and do not process mixed-language systems across language boundaries. In this paper, we discuss the foundations of cross-language analysis and refactoring. We propose a meta-model for capturing relevant information in a language independent way and an architecture for integrating language specific front-ends, and analysisand refactoring-components. As a proof of concept, we introduce X-DEVELOP, an IDE implementing the ideas discussed for a number of languages, analyses, and refactorings. Based on our contributions, cross-language software development tools are constructible in a straightforward way delivering the same productivity as today’s single language tools.

The domain of web page design is inherently complex. The web designers have to deal with a large variety of user-, business- and application-specific requirements and constraints. In order to manage design complexity and variability in the domain, we propose to systematically apply the multi-language design paradigm for creating web pages. The paradigm demands that each concern from the problem domain should be implemented independently using a separate programming language selected from the solution domain. The explicit separation of concerns is essential.

This paper makes a case for the definition of a family of languages for expressing patterns over both the structure and semantics of source code. Our proposal is unique in that it attempts to provide a unified solution to the problem of searching for patterns in multiple programming languages, and in that it focuses on the semantics of the program rather than on its syntactic structure, all while striving to ensure simplicity and ease-of-use. We present the motivation and the unique difficulties involved in defining such languages, discuss strategies for dealing with these problems, and propose a prototype family of Code Pattern Languages (CPLs).

in partial fufillment of the