The impact of software evolution and reuse on software quality

This paper presents a case study of a software project in the maintenance phase. The case study was based on a sample of modules, representing about 1.3 million lines of code, from a very large telecommunications system. Software quality models were developed to predict the number of faults expected from the coding through operations phases. Since modules from the prior release were often reused to develop a new release, one model incorporated reuse data as additional independent variables. We compare this model's performance to a similar model without reuse data.Software quality models often have product metrics as the only input data for predicting quality. There is an implicit assumption that all the modules have had a similar development history, so that product attributes are the primary drivers of different quality levels. Reuse of software as components and software evolution do not fit this assumption very well, and consequently, traditional models for such environments may not have adequate accuracy. Focusing on the software maintenance phase, this study demonstrated that reuse data can significantly improve the predictive accuracy of software quality models.     

Opening up design science: The challenge of designing for reuse and joint development

The purpose of this paper is to advance design science by developing a framework for research on reuse and the relationship between external IT artifacts and their users. A design science approach to IS research needs to grapple with the fact that a number of relevant, economically attractive, external IT artifacts cannot be designed from scratch nor meaningfully evaluated based on the current state of development, and so design science research will struggle with incomplete cycles of design, relevance, and rigor. We suggest a strategic research agenda that integrates the design of the relationship between an external IT artifact and the user by considering the impact artifacts exert on users. Three dimensions derived from adaptive structuration theory inform our framework on three levels of design granularity (middle management, top management, and entrepreneur): agenda considers the dynamic properties of technological objects, adaptability refers to the functional affordance of external artifacts in development, and auspice captures the symbolic expression and scope for interpretation. We derive implications for research design.     

Evolutionary dynamics and the coding structure of sequences: Multiple coding as a consequence of crossover and high mutation rates

In this paper we explore the influence of the dynamics of evolution on coding structures of sequences. We show that, in systems with crossover, high mutation rates cause the most conserved subsequences to be preferentially used as recognition sites for newly evolving sequences. In other words: “multiple coding” evolves in these systems. Multiple coding often does not increase the fitness of the population; nevertheless it is selected. By contrast, in systems without crossover, a low mutation rate causes multiple coding to be avoided, so that only single coding evolves. Again this “choice” is not reflected in the fitness of the population, but is dictated by the evolutionary dynamics. We conclude that the genetic operator crossover turns evolutionary processes in pattern detectors rather than optimizers.     

Ontology-based interoperation model of collaborative product development

The reuse of existing systems is an important objective of High Level Architecture (HLA) based collaborative product development systems. However, in order to reuse an existing system, its interoperation interface has to be modified so as to comply with the objective and interaction representations defined in a corresponding Federation Object Model (FOM). Such modifications imply added time and effort, which diminishes the efficiency of system reuse in collaborative product development. This paper presents a heavy-weighted ontology-based construction method for interoperation models to support the reuse of subsystems in various collaborative contexts. In this method ontologies are used to specify the semantics of object classes and interaction classes in subsystems in a formal and computer readable fashion. In doing so, a Formal Concept Analysis (FCA) like construction method is introduced to establish the original interoperation ontology from scratch. An automatic transforming method from Simulation Object Model (SOM) into interoperation ontology is also described to make existing HLA based systems easy to adopt this approach. Then a consistency verification method is introduced to guarantee the consistency of the interoperation ontologies. A case study is used to demonstrate the feasibility of the proposed method. As a human-friendly modeling method, compared with existing interoperation modeling methods the proposed method is more flexible, efficient and reliable.     

Patterns: from system design to software testing

Design patterns are used extensively in the design of software systems. Patterns codify effective solutions for recurring design problems and allow software engineers to reuse these solutions, tailoring them appropriately to their particular applications, rather than reinventing them from scratch. In this paper, we consider the following question: How can system designers and implementers test whether their systems, as implemented, are faithful to the requirements of the patterns used in their design? A key consideration underlying our work is that the testing approach should enable us, in testing whether a particular pattern P has been correctly implemented in different systems designed using P, to reuse the common parts of this effort rather than having to do it from scratch for each system. Thus in the approach we present, corresponding to each pattern P, there is a set of pattern test case templates (PTCTs). A PTCT codifies a reusable test case structure designed to identify defects associated with applications of P in all systems designed using P. Next we present a process using which, given a system designed using P, the system tester can generate a test suite from the PTCTs for P that can be used to test the particular system for bugs in the implementation of P in that system. This allows the tester to tailor the PTCTs for P to the needs of the particular system by specifying a set of specialization rules that are designed to reflect the scenarios in which the defects codified in this set of PTCTs are likely to manifest themselves in the particular system. We illustrate the approach using the Observer pattern.     

Revisiting the Douglas–Jones method for modelling unsaturated flow in a cultivated soil

Unsaturated flow in cultivated or uncultivated soils can be described by the ψ-based, θ-based or mixed form of the Richards equation. It is well known that the θ-based form is the most accurate one with the smallest mass balance errors. However, this form has the drawback that it is not suitable for saturated–unsaturated or near saturated flows. The ψ-based equation can be applied to any kind of flow but it is generally considered not so accurate as the θ-based equation. It has been shown in the literature that for short time computations, the mixed form of the Richards equation overcomes the mass conservation problems of the ψ-based form, while retaining the advantages of the ψ-based formulation.It is shown in this paper that the ψ-based formulation is more accurate and faster than the mixed form, if the Douglas–Jones predictor–corrector method is used for its solution. This superiority is more obvious in long time simulations, as is the case when the water dynamics of cultivated soils for a whole irrigation period is simulated. The model SWBACROS, which solves the ψ-based form of the Richards equation by the Douglas–Jones and alternatively by the implicit method, is used to prove this point. Also the mixed form of the Richards equation is solved by the implicit method. All the solutions are tested against solutions obtained from the literature. They are also tested against experimental results obtained in a field cultivated with cotton for a period of 5 months.     

Verifying traits: an incremental proof system for fine-grained reuse

Traits have been proposed as a more flexible mechanism than class inheritance for structuring code in object-oriented programming, to achieve fine-grained code reuse. A trait originally developed for one purpose can be adapted and reused in a completely different context. Formalizations of traits have been extensively studied, and implementations of traits have started to appear in programming languages. So far, work on formally establishing properties of trait-based programs has mostly concentrated on type systems. This paper presents the first deductive proof system for a trait-based object-oriented language. If a specification of a trait can be given a priori, covering all actual usage of that trait, our proof system is modular as each trait is analyzed only once. However, imposing such a restriction may in many cases unnecessarily limit traits as a mechanism for flexible code reuse. In order to reflect the flexible reuse potential of traits, our proof system additionally allows new specifications to be added to a trait in an incremental way which does not violate established proofs. We formalize and show the soundness of the proof system.     

Organisational considerations for software reuse

Reuse is widely promoted as one of the most promising methods for increasing productivity and quality within software development. Until recently most research into strategies for systematic reuse has focused on solution of the technical issues. Now as companies (mostly IT focused) implement the strategies developed, they find there are other issues which hold back their success, somewhat unrelated to the technical solutions offered. Reuse processes are not simple technologies and methods slotted into a development, like the transition in design notation from traditional approaches to an object-;orientated method. Whereas technology changes involve retraining developers. Reuse requires the whole organisation and funding of development to be revised. If the magnitude of change involved in transitioning an IT organisation is so encompassing, where does this leave the rest of industry which is increasingly reliant on software to support their business process? This paper looks at organisational and management issues raised by the introduction of software reuse to the development process. We identify inhibitors of reuse adoption, look at causes of these and suggest possible solutions. We aim to concisely present all those non-;technical issues that should be considered when introducing a reuse program. Considered also is how these issues affect companies which have IT in only a business support capacity, making this paper relevant throughout industry.     

Lazy behavioral subtyping

Inheritance combined with late binding allows flexible code reuse but complicates formal reasoning significantly, as a method call’s receiver class is not statically known. This is especially true when programs are incrementally developed by extending class hierarchies. This paper develops a novel method to reason about late bound method calls. In contrast to traditional behavioral subtyping, reverification of method specifications is avoided without restricting method overriding to fully behavior-preserving redefinition. The approach ensures that when analyzing the methods of a class, it suffices to consider that class and its superclasses. Thus, the full class hierarchy is not needed, and incremental reasoning is supported. We formalize this approach as a calculus which lazily imposes context-dependent subtyping constraints on method definitions. The calculus ensures that all method specifications required by late bound calls remain satisfied when new classes extend a class hierarchy. The calculus does not depend on a specific program logic, but the examples in the paper use a Hoare style proof system. We show soundness of the analysis method. The paper finally demonstrates how lazy behavioral subtyping can be combined with interface specifications to produce an incremental and modular reasoning system for object-oriented class hierarchies.     

Aligning the economic modeling of software reuse with reuse practices

In contrast to current practices where software reuse is applied recursively and reusable assets are tailored trough parameterization or specialization, existing reuse economic models assume that (i) the cost of reusing a software asset depends on its size and (ii) reusable assets are developed from scratch. The contribution of this paper is that it provides modeling elements and an economic model that is better aligned with current practices. The functioning of the model is illustrated in an example. The example also shows how the model can support practitioners in deciding whether it is economically feasible to apply software reuse recursively.     

A perspective of generative reuse

This paper presents a perspective of generative reuse technologies as they have evolved over the last 15 years or so and a discussion of how generative reuse addresses some key reuse problems. Over that time period, a number of different reuse strategies have been tried ranging from pure component reuse to pure generation. The record of success is mixed and the evidence is sketchy. Nevertheless, the paper will use some known metric evidence plus anecdotal evidence, personal experience, and suggestive evidence to define some of the boundaries of the success envelope. Fundamentally, the paper will make the argument that the first order term in the success equation of reuse is the amount of domain-;specific content and the second order term is the specific technology chosen in which to express that content. The overall payoff of any reuse system correlates well with the amount of content expressed in the domain specific elements. While not a silver bullet, technology is not without its contribution and the degree of payoff for any specific technology is sensitive to many factors. The paper will make the argument that the generative factors predominate over other technology factors. By looking closely at several successful generation systems that are exemplars for classes of related systems, the paper will examine how those classes have solved problems associated with the more convention reuse of concrete components expressed in conventional programming languages. From this analysis, it will distill the key elements of generative success and provide an opinion of approximately where each class of generative system fits in the overall picture. The result is a guide to the generative reuse technologies that appear to work best today.     

Feature‐based approach to object‐oriented engineering of applications for reuse

Object‐oriented technology is gaining popularity among software engineers with the goal of building reusable and adaptable software. Unfortunately, however, most methods introduced so far are not domain‐oriented and do not address the issue of reuse directly. For these methods, software reuse is not the primary goal; it is only a by‐product. The feature‐oriented reuse method, FORM, is extended in this paper for improving the object‐oriented engineering of applications for reuse. FORM concentrates on analyzing and modeling commonalities and differences in the applications of a given domain in terms of capability, operating environment, domain technology, and implementation technique features. These features are used to systematically derive objects that are tied to the features, and to develop reusable and adaptable domain architectures. We found that FORM facilitates analysis of variability (and commonality) of software before engineering and implementation start, and with this understanding, adaptability and reusability can be built into software. Feature modeling has been found to be an effective method for identifying and modeling reusable objects. Copyright © 2000 John Wiley & Sons, Ltd.     

Towards an ontology-based retrieval of UML Class Diagrams

Context

Software Reuse has always been an important area amongst software companies in order to increase their productivity and the quality of their products, but code reuse is not the only answer for this. Nowadays, reuse techniques proposals include software designs or even software specifications. Therefore, this research focuses on software design, specifically on UML Class Diagrams. A semantic technology has been applied to facilitate the retrieval process for an effective reuse.

Objective

This research proposes an ontology-based retrieval technique by semantic similarity in order to support effective retrieval process for UML Class Diagrams. Since UML Class Diagrams are a de facto standard in the design stages of a Software Development Process, a good technique is needed to reuse them, i.e. reusing during the design stage instead of just the coding stages.

Method

An application ontology modeled using UML specifications was designed to compare UML Class Diagram element types. To measure their similarity, a survey was conducted amongst UML experts. Query expansion was improved by a domain ontology supporting the retrieval phase. The calculus of minimal distances in ontologies was solved using a shortest path algorithm.

Results

The case study shows the domain ontology importance in the UML Class Diagram retrieval process as well as the importance of an element type expansion method, such as an application ontology. A correlation between the query complexity and retrieved elements has been identified, by analyzing results. Finally, a positive Return of Investment (ROI) was estimated using Poulin’s Model.

Conclusion

Because Software Reuse has not to be limited to the coding stage, approaches to reuse design stage must be developed, i.e. UML Class Diagrams reuse. This approach proposes a technique for UML Class Diagrams retrieval, which is one important step towards reuse. Semantic technology combined with information retrieval improves the retrieval results.     

Generating blogs out of product catalogues: An MDE approach

Blogs can be used as a conduit for customer opinions and, in so doing, building communities around products. We attempt to realise this vision by building blogs out of product catalogues. Unfortunately, the immaturity of blog engines makes this endeavour risky. This paper presents a model-driven approach to face this drawback. This implies the introduction of (meta)models: the catalogue model, based on the standard Open Catalog Format, and blog models, that elaborate on the use of blogs as conduits for virtual communities. Blog models end up being realised through blog engines. Specifically, we focus on two types of engines: a hosted blog platform and a standalone blog platform, both in Blojsom. However, the lack of standards in a broad and constantly evolving blog-engine space, hinders both the portability and the maintainability of the solution. Hence, we resort to the notion of “abstract platform” as a way to depart from the peculiarities of specific blog engines. Additionally, the paper measures the reuse gains brought by MDE in comparison with the manual coding of blogs.     

Crypt analysis of two time pads in case of compressed speech

Keystream reuse, also known as the two time pad problem, is a well known weakness in stream ciphers. The implementers of the cryptographic algorithms are still underestimating this threat. The keystream reuse exploitation techniques presented so far assume the underlying plaintext to be textual data and all the heuristics presented previously are based on the language characteristics of the underlying text based data, which fail when compression is applied on the plaintext before encryption. This paper presents exploitation techniques for two time pads in case of stream ciphered digitized and compressed speech signals. In this paper we show that how an adversary can automatically recover the digitized speech signals encrypted under the same keystream provided the language (e.g. English) and digital encoding/compression scheme details of the underlying speech signals are known. Our technique of cryptanalysis is based on the modeling of the speech parameters by exploiting the inter frame correlations between each components of the speech vectors in different frames and then using these models to decode the two speech signals in the keystream reuse scenario. The technique is flexible enough to incorporate all modern speech coding schemes based on parameter or hybrid encoding and compression techniques. The simulation experiments have showed promising results for most of the present day speech digitization and compression techniques.     

A novel incremental conceptual hierarchical text clustering method using CFu-tree

As a data mining method, clustering, which is one of the most important tools in information retrieval, organizes data based on unsupervised learning which means that it does not require any training data. But, some text clustering algorithms cannot update existing clusters incrementally and, instead, have to recompute a new clustering from scratch. In view of above, this paper presents a novel down-top incremental conceptual hierarchical text clustering approach using CFu-tree (ICHTC-CF) representation, which starts with each item as a separate cluster. Term-based feature extraction is used for summarizing a cluster in the process. The Comparison Variation measure criterion is also adopted for judging whether the closest pair of clusters can be merged or a previous cluster can be split. And, our incremental clustering method is not sensitive to the input data order. Experimental results show that the performance of our method outperforms k-means, CLIQUE, single linkage clustering and complete linkage clustering, which indicate our new technique is efficient and feasible.     

Asset market equilibrium: A simulation

This paper examines how an asset price is determined in a market, and how it changes as circumstances in the market change, making use of a standard asset price model. The motivation of the paper is to examine if the model can explain a bubble economy in which individuals are risk averse. It is known that if the relative risk aversion of an investor's utility function does not exceed 1 and is not decreasing, the equilibrium asset price declines when uncertainty increases with respect to the prospect of a dividend receipt. In this paper we examine if there is any utility function which provides the counter example, one in which the asset price rises despite increased uncertainty. Starting from a two period maximization problem with risk aversion, with certain dividends for the two periods, it is shown that if uncertainty is introduced for the second period, the exponential utility function provides this counter example. It is shown that in this particular case that the asset in question has the characteristics of a Giffen good when the asset price is already high. However, when uncertainty is introduced for two periods, the exponential utility function does not provide this counter example. Thus, when uncertainty is not as great, the income effect may raise the asset price despite increased uncertainty. It is also found that a quadratic utility function may explain the collapse of a bubble economy. The standard asset price model is formulated as the pure-exchange economy, without production. Finally, this paper points out that the existence of an asset price may be guaranteed even if production is incorporated into the standard model so long as a certain degree of uniformity is assumed about the distribution of the investors’ initial possession of assets.     

Reuse: what's wrong with this picture?

Something is seriously wrong with reuse. If there is a motherpie-and-applehood topic in software engineering, reuse is it. Everyone believes in it; everyone thinks we should be doing more of it. Reuse does have the potential our industry attributes to it. But the question that keeps recurring is this: why hasn't that potential already been achieved? Most software engineering literature points the finger at management. Don Reifer, for example, has conducted lots of industrial strength studies of businesses that practice reuse (D. Reifer, 1997), and to him the conclusion is clear: the companies that succeed at reuse do so because of managerial commitment, while the ones that fail lack such commitment. Several others say much the same thing. R. Prieto-Diaz turns the problem around and asserts that companies that fail at reuse do so because they treat it as a technical problem. The author disagrees. It seems to him that reuse's fundamental problem is clearly not a lack of managerial commitment. Based on his own experiences, the author thinks reuse hasn't succeeded to the extent we would like because there aren't that many software components that can be reused