Paul G. Sorenson

Hooking into object-oriented application frameworks

An object-oriented application framework provides a generic design within a given domain and a reusable implementation of that design. Frameworks have great potential for reuse, but that potential can only be achieved if the framework can be understood and used effectively by application developers. The complexity of the design and implementation of a framework can make understanding the framework difficult, and so good documentation and guidance to the framework user is needed. Several methods exist for documenting the design of the framework, but less work has been done on documenting the purpose of the framework and how it is intended to be used. In this paper, we introduce the concept of hooks as a means of documenting and providing guidance on the intended use of a framework. Each hook provides a concise solution to a focused requirement or problem within the context of the framework. Solutions for more complex requirements can be provided by combining several hooks. A discussion and means of describing hooks is given, with a focus on the method of adaption used to fulfill the requirement and the level of support provided for the solution within the framework.

The Metaview system for many specification environments

The use of metasystems, which can automatically generate the major parts of a software-development environment, for computer-aided software (CASE) engineering is discussed. One such system, called Metaview, is considered. Environment definition and tool development using Metaview are examined.<<ETX>>

User Interface Reverse Engineering in Support of Interface Migration to the Web

Legacy systems constitute valuable assets to the organizations that own them, and today, there is an increased demand to make them accessible through the World Wide Web to support e-commerce activities. As a result, the problem of legacy-interface migration is becoming very important. In the context of the CELLEST project, we have developed a new process for migrating legacy user interfaces to web-accessible platforms. Instead of analyzing the application code to extract a model of its structure, the CELLEST process analyzes traces of the system-user interaction to model the behavior of the applications user interface. The produced state-transition model specifies the unique legacy-interface screens (as states) and the possible commands leading from one screen to another (as transitions between the states). The interface screens are identified as clusters of similar-in-appearance snapshots in the recorded trace. Next, the syntax of each transition command is extracted as the pattern shared by all the transition instances found in the trace. This user-interface model is used as the basis for constructing models of the tasks performed by the legacy-application users; these task models are subsequently used to develop new web-accessible interface front ends for executing these tasks. In this paper, we discuss the CELLEST method for reverse engineering a state-transition model of the legacy interface, we illustrate it with examples, we discuss the results of our experimentation with it, and we discuss how this model can be used to support the development of new interface front ends.

Recovering software requirements from system-user interaction traces

As software systems age, the requirements that motivated their original development get lost. Requirements documentation is unavailable or obsolete. Recapturing these requirements is critical for software reengineering activities. In our CelLEST process we adopt a data-mining approach to this problem and attempt to discover patterns of frequent similar episodes in the sequential run-time traces of the legacy user-interface behavior. These patterns constitute operational models of the applications functional requirements, from the end-user perspective. We have developed an algorithm, IPM, for interaction-pattern discovery. This algorithm discovers patterns that meet a user-specified criterion and is robust to insertion errors, caused by user mistakes or by the availability of alternative scenarios for the same user task. In this paper, we discuss IPM and we evaluate it with a case study.

Resolving the query inference problem using Steiner trees

The query inference problem is to translate a sentence of a query language into an unambiguous representation of a query. A query is represented as an expression over a set of query trees. A metric is introduced for measuring the complexity of a query and also a proposal that a sentence be translated into the least complex query which “satisfies” the sentence. This method of query inference can be used to resolve ambiguous sentences and leads to easier formulation of sentences.

A Real-Time System Design Methodology*

AbstractA methodology is described which facilitates the design and implementation of software for real-time system (RTS) applcation. The methodology is proposed as a constructive solution to three criticisms of the “state of the art” in real-time system design. Central to the design methodology is n RTS writing e . The components and uses of the syst m are described and two of the major dynamic models in the system (processor allocation and shared data set control) are discussed in some detail. The user of the system writes real-time algorithms appropriate to a particular application in a high level language called RUDIL. Certain constructs in RUDIL invoke operating system type routines that are collectively called the NUCLEUS system. This NUCLEUS, along with the RUDIL compiler, provides the link between machineindependent RUDIL programs and the computer configuration in the real-time system.

Modeling the system-user dialog using interaction traces

It is generally the case that some user interface (UI) reverse engineering is needed for every non-trivial reengineering project. Typically, this is done through code analysis, which can be very difficult and/or expensive. When code analysis is not a must, as for wrapping purposes, system-user interaction can be an alternative input for the reverse engineering process. In the CelLEST project, we have developed a prototype, called LeNDI (Legacy Navigation Domain Identifier), to test this idea. LeNDI records traces of the legacy screen snapshots and user actions, while the user interacts with the legacy system. Then, it extracts a set of features for every snapshot and employs artificial intelligence methods to build a model of the legacy UI, called the state-transition graph. LeNDI uses two clustering methods to group similar snapshots together as one system screen modeled by one node on the graph. LeNDI uses the user actions recorded in traces to model the behavior of the legacy screens as the graph arcs. Evaluation results of this process are encouraging. The state-transition graph is used to classify each individual snapshot forwarded by the legacy system to the user while he interacts with it and is a main input to the forward engineering phase of the project.

Mining system-user interaction traces for use case models

While code understanding is the primary program comprehension activity, it is quite challenging to recognize the application requirements from code, since they have usually been occluded by a set of layers of later implementation decisions. An alternative source of evidence, especially valuable for understanding the purposes for which the application was built, can be the dynamic behavior of the system, and more specifically the system-user interaction. We have developed a method for modeling the application behavior from the users perspective in the form of use case models, using recorded traces of system-user interaction. We use data mining and pattern matching methods to mine these traces for frequently occurring user tasks. When interesting patterns are discovered, they are augmented with semantic information and they are used to build use case models. We demonstrate a successful application of this method to recover use case models from interaction traces with legacy 3270 systems to serve user interface reengineering activities.

Explaining ambiguity in a formal query language

The problem of generating reasonable natural language-like responses to queries formulated in nonnavigational query languages with logical data independence is addressed. An extended ER model, the Entity-Relationship-Involvement model, is defined which assists in providing a greater degree of logical data independence and the generation of natural language explanations of a query processors interpretation of a query. These are accomplished with the addition of the concept of an involvement to the model. Based on involvement definitions in a formally defined data definition language, DDL, an innovative strategy for generating explanations is outlined and exemplified. In the conclusion, possible extensions to the approach are given.

Reusing class-based test cases for testing object-oriented framework interface classes

An application framework provides a reusable design and implementation for a family of software systems. Frameworks are introduced to reduce the cost of a product line (i.e., family of products that share the common features) and to increase the maintainability of software products through the deployment of reliable large-scale reusable components. A key challenge with frameworks is the development, evolution and maintenance of test cases to ensure the framework operates appropriately in a given application or product. Reusable test cases increase the maintainability of the software products because an entirely new set of test cases does not have to be generated each time the framework is deployed. At the framework deployment stage, the application developers (i.e., framework users) may need the flexibility to ignore or modify part of the specification used to generate the reusable class-based test cases. This paper addresses how to deal effectively with the different modification forms such that the use of the test cases becomes easy and straightforward in testing the framework interface classes (FICs) developed at the application development stage. Finally, the paper discusses the fault coverage and experimentally examines the specification coverage of the reusable test cases. Copyright