Suppose regression testing reported many defects, and now we need decide about the order in which to correct them. In addition to commonly used defect prioritization based on their business importance, we propose to take into account also dependencies among defects, and to correct defects in an order that reduces the overall debugging effort. A goal here is to start by fixing root causes of failures, i.e., defects that may be causing many other program failures. A related goal is to avoid prematurely fixing defects that depend on other, yet to be fixed defects, as this is likely to incur wastage of time. Our proposed method requires that test cases have been mapped to relevant software requirements. We defined heuristics to infer defect dependencies, and a suitable defect debugging order from these mappings. The process is semi-automatic, supported by a tool called TRAcker. TRAcker accepts test results, performs heuristics-based computations, and recommends a time-efficient defect debugging order from the perspective of defect dependencies. TRAcker’s filtering and visualization features allow a user to participate in the process, so that tool recommendations as well as other factors can be taken into account. We show that defect prioritization on technical and business grounds together contribute to effective debugging.

Software evolution relies on storing component versions along with delta-changes in a repository of a version control tool such a centralized CVS in old days, or decentralized Git today. Code implementing various software features (e.g., requirements) often spreads over multiple software components, and across multiple versions of those components. Not having a clear picture of feature implementation and evolution may hinder software reuse which most often is concerned with feature reuse across system releases, and components are just means to that end. Much research on feature location shows how important and difficult is to find feature-related code buried in program components post mortem. We propose to avoid creating the problem in the first place, by explicating feature-related code in component versions at the time of their implementation. To do that, we complement traditional version control approach with generative mechanisms. We describe salient features of such an approach realized in ART (Adaptive Reuse Technology, http://art-processor.org), and explain its role in easing comprehending software evolution and feature reuse. Advanced commercial version control tools make a step towards easing the evolution problems addressed in this paper. Our approach is an alternative way of addressing the same problem on quite a different ground.

Similar documents arise in software and business domains.Examples are user guides for different versions of a software product, contracts between vendors and clients, or legal documents.The usual practice is to capture common document formats and contents in templates that must be manually customized to a new contextoften a slow, tedious, and errorprone process.We propose a method based on a proven approach developed for software reuse that simplifies and automates routine tasks involved in creating and updating families of similar documents.Our Document Management Environment (DME) provides functions to create templates capable of higher levels of document contents reuse than templates supported by word processors such as MS Word.DME allows users to designate any arbitrary document part as a template's variation point that can be customized to produce a specific document.DME automates document production by syncing inter-dependent customizations occurring at different variation points.The paper describes two "proof of concept" implementations of DME as Word add-in: The first one uses Content Control mechanism and is specific to MS Word.The second one is based on ART (Adaptive Reuse Technique), a general text manipulation method and tool, and can be used to manage similar documents in any editor that provides an access to the internal representation of documents.

Successful software is often enhanced and adapted to the needs of new users.During evolution, a software system grows in size, becomes more complex, and costly to maintain.In this paper, we point to big clones-large granular duplicated program structures such as files or directories-as one of many reasons why this happens.Using the Linux kernel as an example, we show that big clones arise in the Linux kernel despite careful architecture design and a systematic approach for managing variability.We propose a solution to avoid these big clones by representing them as generalized templates in ART (Adaptive Reuse Technique).ART templates are constructed on top of the Linux code, without conflicts with the state-of-art techniques and tools used to manage the Linux kernel.Benefits include simplification of the Linux kernel due to non-redundancy, easier comprehension, and traceability of the change impact during evolution.The proposed technique is general and the Linux example discussed in this paper also illustrates general phenomena.

In this paper we present a survey based approach towards the design of a mobile application meant to function as an electronic version of a child health book for use in Sri Lanka. Through the use of persuasive technology the application aims to inculcate positive behavioural changes in Sri Lankan parents in order to facilitate the well being of their children. We report on a survey conducted with parents living in urban areas in Colombo which led to the formulation of design guidelines for the application. The application was then evaluated with a set of parents. Results from both the survey and application show that parents held great importance to the privacy and security of their child's data. Some aspects of the paper based health book were deemed to be at times unclear; such as the developmental checks. In general parents were positive about the prospects of an electronic health book. We conclude our paper with future directions of the digital health book.

Skillful design remains one of the critical success factors in long-lived software projects. Design fundamentals have been established and are pretty stable. How do we teach design in-the-large to equip our graduates with design skills relevant to a plethora of changing software technologies and emerging new application domains? Today programs are built on top of functionalities provided by software platforms. Most often, developers extend existing systems rather than develop from scratch. Programming with application program interfaces (API) that allow newly written code to call middleware or existing application software has become a norm in software industries. While the details of API mechanisms heavily depend on a specific platform or application, the principles behind API design are universal, and can be taught in project courses designed for that purpose. Working knowledge of API design principles helps students faster adapt to new and changing technologies. In the paper, we describe a teaching methodology and 10 years of experiences teaching advanced design in a team-based software engineering project course. Our course builds around fundamental concepts in API design and use.

Many software maintenance tasks require locating code units that implement a certain feature (termed as feature location). Feature location has been an active research area for more than two decades. However, there is lack of publicly available, large scale benchmarks for e valuating and comparing feature location approaches. In this paper, we present a LinuxKernel based benchmark for feature location research. This benchmark is large scale and extensible. By providing rich feature and program information and accurate ground-truth links between features and code units, it supports the e valuation of a wide range of feature location approaches. It allows researchers to gain deeper insights into existing approaches and how they can be improved. It also enables communication and collaboration among different researchers. (video: http://www.youtube.com/watch?v=3D_HihwRNeK3I).

Software systems contain many implicit application-specific business and programming rules. These rules represent high-level logical structures and processes for application-specific business and programming concerns. They are crucial for program understanding, consistent evolution, and systematic reuse. However, existing pattern mining and analysis approaches cannot effectively mine such application-specific rules. In this paper, we present an approach for mining logical clones in software that reveal high-level business and programming rules. Our approach extracts a program model from source code, and enriches the program model with code clone information, functional clusters (i.e., a set of methods dealing with similar topics or concerns), and abstract entity classes (representing sibling entity classes). It then analyzes the enriched program model for mining recurring logical structures as logical clones. We have implemented our approach in a tool called MiLoCo (Mining Logical Clone) and conducted a case study with an open-source ERP and CRM software. Our results show that MiLoCo can identify meaningful and useful logical clones for program understanding, evolution and reuse.

In previous work, we described a technique for detecting design-level similar program structures (structural clones) formed from recurring configurations of similar code fragments (simple clones). In this paper, we analyze in detail how frequently these structural clones occur in software systems and how structural clone analysis extends the benefits of analysis based on simple clones only. Our case study of 11 open source systems revealed that over 50% of simple clones are captured by structural clones that often correspond to meaningful design or application domain concepts. Because of their larger size, it is easier for programmers to perceive the similarity situation in a system from structural clone perspective rather than from simple clone perspective only. We also discuss the contribution of structural clone detection towards program understanding, design recovery, maintenance, and refactoring using examples from the case study systems.

Software clones are identical or similar pieces of code, design or other artifacts. Clones are known to be closely related to various issues in software engineering, such as software quality, complexity, architecture, refactoring, evolution, licensing, plagiarism, and so on. Various characteristics of software systems can be uncovered through clone analysis, and system restructuring can be performed by merging clones.

Developers tend to use models and generators during initial development, but often abandon them later in software evolution and reuse. One reason for that is that code generated from models (e.g., UML) is often manually modified, and changes cannot be easily propagated back to models. Once models become out of sync with code, any future re-generation of code overrides manual modifications. We propose a flexible generator solution that alleviates the above problem. The idea is to let developers weave arbitrary manual modifications into the generation process, rather than modify already generated code. A flexible generator stores specifications of manual modifications in executable form, so that weaving can be automatically re-done any time code is regenerated from modified models. In that way, models and manual modification can evolve independently but in sync with each other, and the generated code never gets directly changed. As a proof of concept, we have already built a flexible generator prototype by a merger of conventional generation system and variability technique to handle manual modifications. We believe a flexible generator approach alleviates an important problem that hinders wide spread adoption of MDD in software practice.

Clone detection provides a scalable and efficient way to detect similar code fragments. But it offers limited explanation of differences of functions performed by clones and variations of control and data flows of clones. We refer to such differences as semantic differences of clones. Understanding these semantic differences is essential to correctly interpret cloning information and perform maintenance tasks on clones. Manual analysis of semantic differences of clones is complicated and error-prone. In the paper, we present our clone analysis tool, called Clone-Differentiator. Our tool automatically characterizes clones returned by a clone detector by differentiating Program Dependence Graphs (PDGs) of clones. CloneDifferentiator is able to provide a precise characterization of semantic differences of clones. It can provide an effective means of analyzing clones in a task oriented manner.

Software clones are identical or similar pieces of code. They are often the result of copy--and--paste activities as ad-hoc code reuse by programmers. Software clones research is of high relevance for the industry. Many researchers have reported high rates of code cloning in both industrial and open-source systems.

Preprocessors (e.g., cpp) provide simple means to manage software product variants by including/excluding required feature code to/from base program. Feature-related customizations occur at variation points in base program marked with preprocessing directives. Problems emerge when the number of inter-dependent features grows, and each feature maps to many variation points in many base program components. Component-based and architecture-centric techniques promoted by a Software Product Line approach to reuse help us contain the impact of some features in small number of base components. Still, accommodating other features into product variants requires fine granular code changes in many components, at many variation points. Fine granular code level changes are often handled by preprocessors, which becomes a source of well-known complications during component customization for reuse. In this paper, we show how some of the common preprocessing problems can be alleviated with a query-based environment that assists programmers in analysis of features handled with preprocessor's directives. We describe problems of preprocessing that can be aided by tool like ours, and problems that we believe are inherent in approaches that attempt to manage features in the base code.

Abstract Server pages (also called dynamic pages) render a generic web page into many similar ones. The technique is commonly used for implementing web application user interfaces (UIs). Yet our previous study found a high rate of repetitions (also called ‘clones’) in web applications, particularly in UIs. The finding raised the question as to why such repetitions had not been averted with the use of server pages. For an answer, we conducted an experiment using PHP server pages to explore how far server pages can be pushed to achieve generic web applications. Our initial findings suggested that generic representation obtained using server pages sometimes compromises certain important system qualities such as run‐time performance. It may also complicate the use of WYSIWYG editors. We have analysed the nature of these trade‐offs, and now propose amixed‐strategyapproach to obtain optimum generic representation of web applications without unnecessary compromise to critical system qualities and user experience. The mixed‐strategy approach applies the generative technique of XVCL to achieve genericity at the meta‐level representation of a web application, leaving repetitions to the actual web application. Our experiments show that the mixed‐strategy approach can achieve a good level of genericity without conflicting with other system qualities. Our findings should open the way for others to better‐informed decisions regarding generic design solutions, which should in turn lead to simpler, more maintainable and more reusable web applications. Copyright © 2008 John Wiley & Sons, Ltd.

Code clones are similar program structures recurring in variant forms in software system(s). Several techniques have been proposed to detect similar code fragments in software, so-called simple clones. Identification and subsequent unification of simple clones is beneficial in software maintenance. Even further gains can be obtained by elevating the level of code clone analysis. We observed that recurring patterns of simple clones often indicate the presence of interesting higher-level similarities that we call structural clones. Structural clones show a bigger picture of similarity situation than simple clones alone. Being logical groups of simple clones, structural clones alleviate the problem of huge number of clones typically reported by simple clone detection tools, a problem that is often dealt with postdetection visualization techniques. Detection of structural clones can help in understanding the design of the system for better maintenance and in reengineering for reuse, among other uses. In this paper, we propose a technique to detect some useful types of structural clones. The novelty of our approach includes the formulation of the structural clone concept and the application of data mining techniques to detect these higher-level similarities. We describe a tool called clone miner that implements our proposed technique. We assess the usefulness and scalability of the proposed techniques via several case studies. We discuss various usage scenarios to demonstrate in what ways the knowledge of structural clones adds value to the analysis based on simple clones alone.

Code clones are similar program structures recurring in software systems. Clone detectors produce much information and a challenge is to identify useful clones depending on the goals of clone analysis. To do so, further abstraction, filtering and visualization of cloning information, with the involvement of a human expert, is required. In this paper, we describe a technique for filtering and visualization of cloning information generated by Clone Miner, a clone detection tool presented in our earlier work. Unique benefit and contribution of our approach is that a human expert can define a wide range of filters to extract abstract views of the cloning data using a clone-query system to suit specific needs of clone analysis. We then produce standardized graphical presentations of those views for various types of clone queries. We implemented the technique into an Eclipse plug-in called Clone Visualizer. Clone Visualizer works closely with Clone Miner which not only finds similar code fragments (simple clones) but also finds higher-level abstractions of the cloning information. Our method is the first attempt to address filtering and visualization of those higher level cloning abstractions. We illustrate application of our technique with examples from a clone analysis project with Clone Miner and Clone Visualizer.

Server page technique is commonly used for implementing Web application user interfaces. Server pages can represent many similar Web pages in a generic form. Yet our previous study revealed high rates of repetitions in Web applications, particularly in the user interfaces. Code duplication, commonly known as 'cloning', signals untapped opportunities to achieve simpler, smaller, more generic, and more maintainable Web applications. Using PHP server page technique, we conducted a case study to explore how far server page technique can be pushed to achieve clone-free Web applications. Our study suggests that clone unification using server pages affects system qualities (e.g., runtime performance) to an extent that may not be acceptable in many project situations. Our paper discusses the trade-offs we observed when applying server pages to unify clones in Web applications. We expect our findings to help in developing and validating complementary techniques that can unify clones without incurring such trade-offs.

In controlled lab experiments and industrial projects, we observed 50%-90% rates of repetitions that deliberately recurred in newly developed, well- designed programs. Most often, recurring program structures represented an important concept from software requirements or design spaces. Repetitions increased conceptual complexity and physical size of programs, and also signified unexploited reuse opportunities. Despite potential benefits, avoiding or explicating repetitions with conventional programming techniques was either impossible or would require developers to compromise other important design goals. We believe these problems are common in many program situations. We hypothesize that they have their roots in much similarity that is inherent in software, and not strong enough generic design mechanisms to represent repetitions in a unified, generic way. We discuss mixed-strategy approach that strengthens generic design capabilities of conventional programming techniques with help of a generative meta-programming technique.

Component-based reuse in mission critical Command and Control system domain was a starting point for a long lasting research collaboration between National University of Singapore (NUS) and ST Electronics Pte. Ltd. (STEE). STEE industrial projects as well as NUS lab studies revealed limitations of conventional architecture-centric, component-based reuse in the area of generic design to unify similarity patterns (e.g., similar classes, components or architectural patterns) commonly found in software. Further research showed that meta-level extensions to conventional techniques could strengthen their generic design capabilities, considerably improving effectiveness of reuse solutions, and increasing productivity gains due to reuse. These experiences led to development of "mixed strategy" approach based on synergistic application of meta-level generative programming technique of XVCL, together with conventional programming techniques. In the paper, we describe university-industry collaboration that proved beneficial for both parties: STEE advanced reuse practice via application of XVCL in several software product line projects. Early inputs from STEE helped NUS team validate and refine XVCL reuse methods, and expand into new research directions. We describe a sequence of projects that led to successful application of XVCL in industrial projects. We describe experiences from those projects and their significance for both industrial practice and understanding principles of flexible software, i.e., software that can be easily changed and adapted to various reuse contexts.

Web Applications (WA) are developed and maintained under tight schedules. Much similarity across WAs creates opportunities for cutting development cost and easing evolution via reuse. This tutorial shows a practical way to exploit similarity patterns - at architecture and code levels - to simplify the design of WAs, helping to meet the unique challenges of Web engineering.

There is a lack of published studies on software development in Southeast Asia, which is fast becoming an IT outsourcing haven. This paper presents exploratory survey and case study results on software practices of some software firms in five ASEAN countries (Malaysia, Philippines, Singapore, Thailand and Vietnam), and provides directions for further research on software practices in the ASEAN/Southeast Asian region.

Meta-programs are generic, incomplete, adaptable programs that are instantiated at construction time to meet specific requirements. Templates and generative techniques are examples of meta-programming techniques. Understanding of meta-programs is more difficult than understanding of concrete, executable programs. Static and dynamic analysis methods have been applied to ease understanding of programs — can similar methods be used for meta-programs? In our projects, we build meta-programs with a meta-programming technique called XVCL. Meta-programs in XVCL are organized into a hierarchy of meta-components from which the XVCL processor generates concrete, executable programs that meet specific requirements. We developed an automated system that analyzes XVCL meta-programs, and presents developers with information that helps them work with meta-programs more effectively. Our system conducts both static and dynamic analysis of a meta-program. An integral part of our solution is a query language, FQL in which we formulate questions about meta-program properties. An FQL query processor automatically answers a class of queries. The analysis method described in the paper is specific to XVCL. However, the principle of our approach can be applied to other meta-programming systems. We believe readers interested in meta-programming in general will find some of the lessons from our experiment interesting and useful.

Abstract Software clones—similar program structures repeated in variant forms—increase the risk of update anomalies, blow up the program size and complexity, possibly contributing to high maintenance costs. Yet, programs are often polluted by clones. In this paper, we present a case study of cloning in the Java Buffer library, JDK 1.5. We found that at least 68% of the code in the Buffer library was contained in cloned classes or class methods. Close analysis of program situations that led to cloning revealed difficulties in eliminating clones with conventional program design techniques. As a possible solution, we applied a generative technique of XVCL (XML‐based Variant Configuration Language) to represent similar classes and methods in generic, adaptable form. Concrete buffer classes could be automatically produced from the generic structures. We argue, on analytical and empirical grounds, that unifying clones reduced conceptual complexity and enhanced the changeability of the Buffer library at rates proportional to code size reduction (68%). We evaluated our solution in qualitative and quantitative ways, and conducted a controlled experiment to support this claim. The approach presented in the paper can be used to enhance genericity and changeability of any program, independently of an application domain or programming language. As the solution is not without pitfalls, we discuss trade‐offs involved in its project application. Copyright © 2006 John Wiley & Sons, Ltd.

Students learn about design principles and "best practices" in many courses. However, small scale assignments do not give enough opportunity for students to appreciate the value of software design principles or even to learn how to apply principles in practice. To fill the gap between theoretical and experiential knowledge, we introduced a team-based project course focused on design and implementation phases of the software development lifecycle. We teach design principles and team work in problem-based way, through architectural concepts and iterative development process. The product students build must meet stated quality requirements in terms of reliability, reusability and documentation. We trust this kind of the course is essential in curricula as it allows students better absorb knowledge learned in other software engineering courses. Such course also plays a role in better preparing students for industrial work. We describe a teaching method, course infrastructure and lessons learned over three years of teaching of our course. Based on experiences, we postulate and motivate the need for teaching at least two project courses in undergraduate curricula, one dealing with design and process issues, and the other focused on unstable requirements

Templates (or generics) help us write compact, generic code, which aids both reuse and maintenance. The STL is a powerful example of how templates help achieve these goals. Still, our study of the STL revealed substantial, and in our opinion, counter-productive repetitions (so-called clones) across groups of similar class or function templates. Clones occurred, as variations across these similar program structures were irregular and could not be unified by suitable template parameters in a natural way. We encountered similar problems in other class libraries as well as in application programs, written in a range of programming languages. In the paper, we present quantitative and qualitative results from our study. We argue that the difficulties we encountered affect programs in general. We present a solution that can treat such template-unfriendly cases of redundancies at the meta-level, complementing and extending the power of language features, such as templates, in areas of generic programming.

As Web technologies change and multiply fast, their comprehension, assessment, selection and adoption are likely to be increasingly difficult, accidental and sub-optimal. Most often, needs are both important elements in technology assessment/selection and drivers of technology proliferation and evolution. We believe a need-oriented organization of Web technologies, as presented in this paper, is a useful starting point for comprehending the multitude of existing and emerging Web technologies from an essential and stable perspective. We identify important technological needs in relation to a reference architecture for Web Applications, and show how different technological trends address each need. We hope the paper will be of interest to those who want to get a grasp of the Web technology landscape and understand major trends. These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Cloning in software systems is known to create problems during software maintenance. Several techniques have been proposed to detect the same or similar code fragments in software, so-called simple clones. While the knowledge of simple clones is useful, detecting design-level similarities in software could ease maintenance even further, and also help us identify reuse opportunities. We observed that recurring patterns of simple clones - so-called structural clones - often indicate the presence of interesting design-level similarities. An example would be patterns of collaborating classes or components. Finding structural clones that signify potentially useful design information requires efficient techniques to analyze the bulk of simple clone data and making non-trivial inferences based on the abstracted information. In this paper, we describe a practical solution to the problem of detecting some basic, but useful, types of design-level similarities such as groups of highly similar classes or files. First, we detect simple clones by applying conventional token-based techniques. Then we find the patterns of co-occurring clones in different files using the Frequent Itemset Mining (FIM) technique. Finally, we perform file clustering to detect those clusters of highly similar files that are likely to contribute to a design-level similarity pattern. The novelty of our approach is application of data mining techniques to detect design level similarities. Experiments confirmed that our method finds many useful structural clones and scales up to big programs. The paper describes our method for structural clone detection, a prototype tool called Clone Miner that implements the method and experimental results.

Imprecise, frequently changing requirements and short time-to-market create challenges for application of conventional software methods in Web Portal engineering. To address these challenges, ST Electronics (Info-Software Systems) Pte. Ltd. applied a lightweight, reactive approach to support a Web Portal product line. Unique characteristics of the approach were fast, low-cost migration from a single conventional Web Portal towards a reusable "generic Web Portal" solution, effective handling of large number of functional variants and their dependencies, the ability to rapidly develop new Web Portals from the generic one, and to independently evolve multiple Web Portals without ever losing a connection between them and the "generic Web Portal". The initial Web Portal was built using state-of-the-art conventional methods. The Web Portal was not flexible enough to reap the benefits of new business opportunities that required the company to rapidly develop and further maintain many similar Web Portals. To overcome the limitations of the conventional solution, a reuse technique called XVCL was applied incrementally. Over a period of three weeks, the conventional solution was converted into a Web architecture capable of handling nine Web Portals from a base of code smaller than the original Web Portal. In the paper, we describe the process that led to building the above Web Portal product line. We explain the difficulties in building an effective generic Web solution using conventional techniques. We analyze our reuse-based solution in qualitative and quantitative ways.

In software architecture design, we explore design alternatives and make decisions about adoption or rejection of a design from a web of complex and often uncertain information. Different architectural design decisions may lead to systems that satisfy the same set of functional requirements but differ in certain quality attributes. In this paper, we propose a Bayesian Network based approach to rational architectural design. Our Bayesian Network helps software architects record and make design decisions. We can perform both qualitative and quantitative analysis over the Bayesian Network to understand how the design decisions influence system quality attributes, and to reason about rational design decisions. We use the KWIC (Key Word In Context) example to illustrate the principles of our approach.

We developed XVCL (XML-based variant configuration language), a method and tool for product lines, to facilitate handling variants in reusable software assets (such as architecture, code components or UML models). XVCL is a newer version of Bassett's frames (1997), a technology that has achieved substantial productivity improvements in large data processing product lines written in COBOL. Despite its simplicity, XVCL can effectively manage a wide range of product line variants from a compact base of meta-components, structured for effective reuse. We applied XVCL in two medium-size product line projects and a number of smaller case studies. We communicate XVCL's capabilities to support product lines by means of a simple, but still interesting, example of the KWIC system introduced by Parnas in 1970's. We show how we can handle functional variants, variant design decisions and implementation-level variants in a generic KWIC system.

XVCL (XML-based Variant Configuration Language) is a meta-programming technique and tool that provides effective reuse mechanisms [2]. XVCL is an open source software (http://fxvcl.sourceforge.net) developed at the National University of Singapore. Being a modem and versatile version of Bassett's frames [1], a technology that has achieved substantial gains in industry, the underlying principles of the XVCL have been thoroughly tested in practice. Unlike original frames, XVCL blends with contemporary programming paradigms and complements other design techniques. XVCL uses "composition with adaptation" rules to generate a specific program from generic, reusable meta-components. Program generation rules are 100% transparent to a programmer, who retains full control over fine-tuning the generated code. Despite its simplicity, XVCL can effectively manage a wide range of program variants from a compact base of metacomponents, structured for effective reuse.

Redundant code obstructs program understanding and contributes to high maintenance costs. While most experts agree on that, opinions - on how serious the problem of redundancies really is and how to tackle it - differ. In this paper, we present the study of redundancies in the Java Buffer library, JDK 1.4.1, which was recently released by Sun. We found that at least 68% of code in the Buffer library is redundant in the sense that it recurs in many classes in the same or slightly modified form. We effectively eliminated that 68% of code at the meta-level using a technique based on "composition with adaptation" called XVCL. We argue that such a program solution is easier to maintain than buffer classes with redundant code. In this experiment, we have designed our meta-representation so that we could produce buffer classes in exactly the same form as they appear in the original Buffer library. While we have been tempted to re-design the buffer classes, we chose not to do so, in order to allow for the seamless integration of the XVCL solution into contemporary programming methodologies and systems. This decision has not affected the essential results reported in this paper.

10.1145/568760.568821

A domain model describes common and variant requirements for a system family. UML notations used in requirements analysis and software modeling can be extended with variation points to cater for variant requirements. However, UML models for a large single system are already complicated enough. With variants UML domain models soon become too complicated to be useful. The main reasons are the explosion of possible variant combinations, complex dependencies among variants and inability to trace variants from a domain model down to the requirements for a specific system, member of a family. We believe that the above mentioned problems cannot be solved at the domain model description level alone. We propose a novel solution based on a tool that interprets and manipulates domain models to provide analysts with customized, simple domain views. We describe a variant configuration language that allows us to instrument domain models with variation points and record variant dependencies. An interpreter of this language produces customized views of a domain model, helping analysts understand and reuse software models. We describe the concept of our approach and its simple implementation based on XML and XMI technologies.

A reuse framework consists of an asset repository and repository tools. A repository stores assets, while tools help to manage repository and search for assets. Companies set up reuse frameworks to enforce standards and to enable sharing assets across company departments, project teams and individuals. Any reuse framework, independently of its size and purpose, must employ a mechanism to enforce company's security policies such as access control to various assets, rights to create or modify certain assets, etc. In the paper we describe a generic access control system that can be employed in a wide class of reuse frameworks.

or PKB Refronte source programs Fig. 5. Components of a reverse engineering tool . Refronte (Reverse Engineering FRONTEnd) The Refronte extracts low level program design information from sources and puts them into the Program Knowledge Base (PKB). . Design Abstractor 20 The design abstractor evaluates reverse engineering heuristics. The design abstractor understands conceptual program design models and heuristics written in extended PQL. Mappings of conceptual models of PKB and DKBs to physical schema allow the design abstractor to evaluate heuristics. Recovered design models are stored in Design Knowledge Bases (DKBs). . User interface A user interface allows a human expert to interact with the reverse engineering process. Through the user interface, a human expert can extend/modify built-in reverse engineering heuristics and examine intermediate program designs. . Export-Import Facility The final program design abstractions can be transferred from the DKB into other prese...

Static program analyzers (SPA) are interactive tools that enhance program understanding during maintenance by answering queries about programs. Depending on the maintenance task in hand, SPAs must process different source programs and answer different types of program queries. Flexibility is, therefore, a desirable property of SPAs. The author describes a program query language, called PQL, that facilitates the design of flexible SPAs. PQL is a conceptual level, source language-independent notation to specify program queries and program views. In PQL, one can query global program design as well as search for detail code patterns. PQL queries are answered automatically by a query evaluation mechanism built into an SPA. Program design models and POL form the core of an SPA conceptual model. He based the SPA's architecture on this conceptual model. By separating the conceptual model from the implementation decisions, one can design SPAs that are customizable to the needs of the maintenance project at hand. Depending on criteria such as efficiency of query evaluation or simplicity of the SPA design, one can implement the same functional specifications of an SPA on a variety of program representations to meet the required criteria. Apart from its role in the design of SPAs, the conceptual model also allows one to rigorously study SPA functionality in the context of the underlying maintenance process and programmer behavior models, in isolation from tool implementation details.

Static program analyzers (SPA) are interactive tools that enhance program understanding by answering queries about programs. An SPA extracts relevant information from input programs and stores it in a program knowledge base (PKB). In this paper, we present a hybrid PKB design model that integrates a relational database with attributed syntax trees. In the hybrid PKB, global properties of programs are stored in a relational database and detailed program structures are stored as attributed syntax trees. The hybrid PKB approach simplifies the structure of the PKB and provides a flexible mechanism for analysis of complex structured objects such as syntax trees and control/data flow graphs. The model reduces the size of the database, and hence program queries can be answered efficiently.>

Static program analyzers (SPA) are interactive tools that enhance program understanding by answering queries about programs. An SPA parses source programs and builds a so-called program knowledge base (PKB) that enables automatic processing of program queries. An SPA design method described in this paper consists of steps during which we (1) identify, a class of program queries we wish to answer, (2) model program information that is required to resolve queries, (3) define physical representation for programs, based on the concept of a hybrid PKB, and (4) implement other SPA components such as a front-end and user interface. Generally, queries related to global properties of programs are best handled if we store program information in a relational database. On the other hand, detailed queries are best supported if we represent programs as attributed syntax trees. A hybrid PKB described in this paper integrates these two program representations. Our notation for specifying a hybrid PKB forms a basis for a generation system that automates some of the routine, but time consuming, tasks involved in implementation of programming tools.>

Abstract Software systems must be constantly upgraded to be in tune with an evolving business environment. Owing to the inefficiency of current maintenance methods, many of the old programs do not meet companies' strategic needs. Can we re‐engineer those programs or must they be rewritten from scratch? Common goals for re‐engineering software have been to improve maintainability of programs and to convert programs into a newer computer, database or language. In this paper, we describe a framework for strategic re‐engineering in which programs are substantially redesigned in order to meet companies' strategic goals. Strategic re‐engineering is much like redevelopment, accelerated by reuse of information that is extracted from existing, still viable from the business point of view, progams. We discuss the impact of companies' strategic plans on software re‐engineering and describe life‐cycle phases of strategic re‐engineering with CASE.

Programs are often reengineered for better maintainability or in order to migrate programs into newer computer/software platforms. However, many of the aging business systems must be also upgraded in order to meet strategic goals of an organization. To meet such ambitious objectives, we must fundamentally redesign programs, rather than merely restructure them for improved maintainability. When much program re-design is involved, the reengineering option becomes challenging at the technical level, expensive and risky. To increase the value of the reengineering solution, we address reusability issues in the context of reengineering. In this paper, we discuss lifecycle phases and outline a possible technical scenario for reengineering for reusability.>