Selecting the optimal service from a set of functionally equivalent services is non-trivial. Previous research has addressed this issue making use of Quality of Service (QoS) attributes of the candidate services. In doing this, researchers have however assumed that the customers' preference of the various QoS attributes varies linearly with the actual attribute values. In this work, we put forward a technique that overcomes this restriction and compares functionally equivalent services on the basis of the customers' perception of the QoS attributes rather than the actual attribute values. We utilize the 'mid-level splitting' method to track the customer's preference vis-a-vis the actual attribute values. Further, we utilize the 'Hypothetical Equivalents and In equivalents Method' to assign weights, reflecting the importance, to the attributes on the basis of the customer preference. The whole procedure is demonstrated using a simple running example.

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 © 2005 John Wiley & Sons, Ltd.

In the context of the CelLEST project, we have been investigating the problem of reengineering and reusing the services provided by legacy applications, running on mainframe hosts. This work has resulted in a suite of methods, based on understanding and modeling the users' interaction with the legacy-application interface. These methods aim at (a) modeling the behavior of the legacy user interface as a state-transition diagram, (b) recovering specifications for the application's functions by discovering the users' tasks as frequently occurring interaction patterns, and (c) constructing new user-interface front-ends to make the recovered legacy functions accessible through the Web. We describe the overall process for legacy migration to the World Wide Web, using the CelLEST methods, and we illustrate it with an example case study.

An application framework provides a reusable design and implementation for a family of software systems. If the framework contains defects, the defects will be passed on to the applications developed from the framework. Framework defects are hard to discover at the time the framework is instantiated. Therefore, it is important to remove all defects before instantiating the framework. The problem addressed in this paper is developing an automated state-based test suite generator technique that uses hook technology to produce test suites to test frameworks at the system level. A case study is reported and its results show that the proposed technique is reasonably effective at detecting faults. A supporting tool that automatically produces framework test cases, executes them, and evaluates the results is presented.

A key challenge facing IT organizations today is their evolution towards adopting e-business practices that gives rise to the need for reengineering their underlying systems. Any reengineering effort has to be aware of the functional requirements of the subject system, in order not to violate the integrity of its intended uses. However, as systems get regularly maintained throughout their lifecycle, the documentation of their requirements often become obsolete or get lost. To address this problem of software requirements loss, we have developed an interaction-pattern mining method for the recovery of functional requirements as usage scenarios. Our method analyzes traces of the run-time system-user interaction to discover frequently recurring patterns; these patterns correspond to the functionality currently exercised by the system users, represented as usage scenarios. The discovered scenarios provide the basis for reengineering the system into web-accessible components, each one supporting one of the discovered scenarios. In this paper, we describe IPM2, our interaction-pattern discovery algorithm, we illustrate it with a case study from a real application and we give an overview of the reengineering process in the context of which it is employed.

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 application's 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.

Object-oriented application frameworks are becoming an increasingly popular part of software development but there has been little work on studying how they are actually used. An object-oriented application framework comprises a design and an object-oriented implementation of that design meant to apply to a broad range of applications, or subsystems within a single domain, such as graphical user interfaces. FrameScan is an ongoing study with the goal of understanding how developers can effectively and efficiently understand and deploy framework technology to construct and evolve their applications. In order to study how frameworks are used, 34 students of a senior year software engineering course were divided up into six teams of five or six students each. Each team had three months to design and implement a small client-server application of their choosing with the requirement that a framework for client-server computing called CSF (Client-Server Framework) be used as part of the project. The conclusions of the study are presented.

No abstract available.

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.

Because software specifications often serve as a formal contract between the developer and the customer, systems have been proposed that help the software client better understand specifications by automatically paraphrasing them in natural language. The REVIEW system applies natural language generation within Metaview, a metasystem that facilitates the construction of CASE environments to support software specification tasks. This paper summarizes a technical report that presents REVIEW through a case study involving the Object Model of Rumbaugh's OMT specification methodology (1991).

Partial-match search queries form an important class of queries posed to a database system. Several storage structures have been proposed to answer these queries efficiently. The BD tree is an example of such a storage structure. A partial-match search algorithm, called AORIG, is given in Ref. 5. This paper presents three algorithms – ALOCAL, ACOMP and AGLOBAL – that represent three levels of improvement to AORIG. Each one yields successively more benefit at the cost of more complexity. All the improvements centre on avoiding the exploration of unnecessary OUT branches. It is shown that AGLOBAL is the best partial-match search algorithm in the sense that no other algorithm searches fewer internal and external nodes. The worst-case complexity of performing a partial-match search in BD trees using AGLOBAL is shown to be the same as that for the k-d trees.

The authors formulate the criteria for drawing dataflow diagrams and describe the placement and routing algorithms used in a system called MONDRIAN. A generalized approach to the question of software diagrams is proposed based on the authors' experience with MONDRIAN and a metasystem approach to the creation of CASE (computer-aided software engineering) environments. A formal approach to the definition of software objects and their graphical representation is given. The use of location constraints as a basis for generalized layout algorithms is discussed.>

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 processor's 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.

Abstract Database systems are becoming increasingly popular for answering queries. Partial‐match search queries are an important class of queries in such a system. Several storage structures have been proposed to answer these queries efficiently. The BD tree is an example of such a storage structure. A previous study indicated that the k‐d tree performance is better than that of the BD tree for partial‐match search queries. A recent paper reported some improved algorithms. However, it is unclear whether the improved algorithms show the BD tree in a favourable light for partial‐match search queries. This paper explores the performance of these algorithms and compares their performance to that of the k‐d tree. Since the BD tree construction process uses some heuristics to make it a better balanced tree, this paper also evaluates the effect of these heuristics on the partial‐match search algorithms. The major conclusions of this study are that the BD tree performance for partial‐match search is better than that of the k‐d tree when an improved algorithm is used for partial‐match search, and only the DZ expression rearrangement heuristic has substantial effect on partial‐match search performance.

Abstract Database applications often require a sophisticated class of storage structures in order to answer different types of queries efficiently. This often dictates that the file should be organized on multiple keys. Several storage structures have been proposed to satisfy these needs. Most are generalizations of the storage structures used for managing one‐dimensional data. Recently, a new storage structure, called the BD tree, was proposed to manage multidimensional data. This structure has good dynamic characteristics. This paper presents algorithms for the BD tree to perform insertion, deletion, and to answer exact match, partial match and range queries. In addition, some experimental evidence is presented that suggests that BD trees have good dynamic characteristics.

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 characterization of an end user and a discussion of an end-user facility are presented. A language for aiding the data-base administrator in designing forms for user's of an end-user facility is described in a tutorial manner. The paper concludes with an outline of work related to the form's approach and other types of user-oriented query language facilities.

In this paper procedures are studied for storing, accessing, updating, and reorganizing data in large files whose organization is direct, an organization used when a fast response time is required. Distribution-dependent hashing functions and the division method are compared as methods of indirect addressing.Distribution-dependent hashing functions are characterized. These hashing functions generate addresses from a set of keys by using knowledge of the distribution of that key set within the key space or range of keys. A study of the performance measures obtained during tests of these functions on several key sets indicates that in certain cases, distribution-dependent methods perform better than the division method. This result is extended by a demonstration that distribution-dependent hashing functions can accommodate a change in the distribution of keys without being redefined. A number of insertions to and deletions from the key set can be made before a distribution-dependent hashing function gives poorer performance than the division method under identical circumstances.If many additions are made to a set of keys, it becomes necessary to reorganize, in a larger storage area, the direct file of records identified by that key set. Although processor time must be sacrificed in order to redefine a distribution-dependent hashing function, the division method requires substantially greater access time in a reorganizational situation.

A variety of solutions have been proposed for ensuring data integrity in nonreal-time systems (i.e. batch or on-line systems). A brief review is made of some of the techniques employed in these solutions. It is indicated why the data integrity problem is different in a real-time system than in a nonreal-time system. Two models of interprocess communication are presented and it is demonstrated that the models are sufficient to preserve data integrity in a real-time system.