The Object-Oriented Design Knowledge

In order to establish itself as a branch of engineering, a profession must understand its accumulated knowledge. In this regard, software engineering has advanced greatly in recent years, but it still suffers from the lack of a structured classification of its knowledge. In this sense, in the field of object-oriented micro-architectural design designers have accumulated a large body of knowledge and it is still have not organized or unified. Therefore, items such as design patterns are the most popular example of accumulated knowledge, but other elements of knowledge exist such as principles, heuristics, best practices, bad smells, refactorings, and so on, which are not clearly differentiated; indeed, many are synonymous and others are just vague concepts.

A Catalog of Design Rules for OO Micro-Architecture

This chapter presents a catalog of different rules for help to design object-oriented micro-architectures. These rules form an important part of the object-oriented design knowledge. Rules, like patterns, or accumulated knowledge, are discovered, not invented.

From Bad Smells to Refactoring

This chapter presents a study on the relation of refactoring, bad smells, and metrics. The notions of refactoring and bad smells are revised as well as metrics that can be used as guides in the refactoring process. Connection among those metrics, the usual flaws that could be suggested by them, and the required corrective actions to reduce or erase these flaws are analyzed. The usual flaws can be described in terms of bad smells and the corrective actions, in terms of the refactoring operations suggested by each bad smell. Then, we can go from metrics to bad smells and from this, to refactoring. The chapter also describes solutions for tool support in a language independent manner. In this sense, it describes the tool architecture which can be defined as metamodel-centered. A metamodel representing a family of languages is defined as well as framework based solutions for collecting metrics, as well as for a refactoring engine and repository. These solutions allow reusing the effort on a wide family of object-oriented languages. Thedeveloped frameworks were instantiated to work on instances of our own metamodel. In addition to this, it also describes how to use the approach and its support, with other metamodels. Finally, a case study on the use of metrics in bad smells detection is presented.

A Survey of Object-Oriented Design Quality Improvement

The use of object-oriented (OO) architecture knowledge such as patterns, heuristics, principles, refactorings and bad smells improve the quality of designs, as Garzás and Piattini (2005) state in their study; according to it, the application of those elements impact on the quality of an OO design and can serve as basis to establish some kind of software design improvement (SDI) method. But how can we measure the level of improvement? Is there a set of accepted internal attributes to measure the quality of a design? Furthermore, if such a set exists will it be possible to use a measurement model to guide the SDI in the same way software process improvement models (Humphrey, 1989; Paulk, Curtis, Chrissis, & Weber, 1993) are guided by process metrics (Fenton & Pfleeger, 1998)? Since (Chidamber & Kemerer, 1991) several OO metrics suites have been proposed to measure OO properties, such as encapsulation, cohesion, coupling and abstraction, both in designs and in code, in this chapter we review the literature to find out to which high level quality properties are mapped and if an OO design evaluation model has been formally proposed or even is possible.

Automatic Verification of OOD Pattern Applications

Object-oriented patterns condense experimental knowledge from developers. Their pragmatic benefits may involve a reduction on the effort impact of the maintenance stage. However, some common problems can be distinguished as well. For instance, some design patterns are simply too difficult for the average OO designer to learn. A pattern-based design process could be enhanced by the provision of an automatic support for modeling and verification with a proper formal foundation. In this chapter we show how formal specifications of GoF patterns have been helpful to develop that tool support, where we have adopted the well-known Java language upon its portability facet. Thus, we are changing the object-oriented design process by the inclusion of pattern-based modeling and verification steps. The latter involving checking design correctness and appropriate pattern application through the use of the supporting tool, called DePMoVe (Design and Pattern Modeling and Verification).

Using Linguistic Patterns to Model Interactions

The dynamic behavior of a system is elicited, specified, and analyzed by means of interaction modelling. This activity is important for object-oriented software development because it provides the information that is required to construct the system conceptual model. Several interaction modelling techniques have been proposed. However, this activity continues to be a complex and tedious task for the modellers. These problems arise from the intrinsic difficulties of interaction modelling and the lack of effective techniques and tools to support to the modellers. In this chapter, heuristic-oriented techniques and linguistics-oriented techniques proposed by several authors to model interactions are analyzed. In addition, a framework to facilitate and to improve the interaction modelling is described. This framework was conceived to be integrated into automatic software production environments. It uses linguistic patterns to recognize interactions from use case models. The patterns were validated with expert modellers. The validation process carried out and the main results are also presented.

The Object-Oriented Design Knowledge Ontology

It has been a long time since the object-oriented (OO) paradigm appeared. From that moment, designers have accumulated much knowledge in design and construction of OO systems. Patterns are the most refined OO design knowledge. However, there are many others kinds of knowledge than are not yet classified and formalized. Therefore, we feel it necessary to define ontology in order to structure and unify such knowledge; a good understanding of practical experience is crucial to software engineers. Therefore, this chapter proposes an ontology for object-oriented design knowledge.

A Framework Based on Design Patterns

This chapter proposes a framework based on design patterns to implement UML association, aggregation, and composition relationships. To build the framework, we propose a semantic interpretation of these concepts that avoids the ambiguities introduced by UML. This interpretation is achieved by using a set of properties that allows us to characterize these kinds of relationships. Once the semantics of the relationships have been defined, we propose a framework based on design patterns for the systematic generation of a software representation. The framework is based on the properties that characterize the relationships. It provides a high-quality solution and introduces important benefits with regard to other existing implementation approaches. This work proposes an implementation strategy that defines a set of mappings between the conceptual abstractions and the proposed framework. This strategy enables the automatic instantiation of the framework. Finally, to validate the proposal, we present a C# implementation of a collaboration pattern. Collaboration patterns are analysis patterns constituted by two classes that are related by an association, an aggregation or a composition relationship.

Design Patterns as Laws of Quality

Software quality models link internal attributes of programs with external quality characteristics. They help in understanding relationships among internal attributes and between internal attributes and quality characteristics. Object-oriented software quality models usually use metrics on classes (such as number of methods) or on relationships between classes (for example coupling) to measure internal attributes of programs. However, the quality of object-oriented programs does not depend on classes solely: it depends on the organisation of classes also. We propose an approach to build quality models using patterns to consider program architectures. We justify the use of patterns to build quality models, describe the advantages and limitations of such an approach, and introduce a first case study in building and in applying a quality model using design patterns on the JHotDraw, JUnit, and Lexi programs. We conclude on the advantages of using patterns to build software quality models and on the difficulty of doing so.

Heuristics and Metrics for OO Refactoring

Refactoring, as a software engineering discipline, has emerged over recent years to become an important aspect of maintaining software. Refactoring refers to the restructuring of software according to specific mechanics and principles. While in theory there is no doubt of the benefits of refactoring in terms of reduced complexity and increased comprehensibility of software, there are numerous empirical aspects of refactoring which have yet to be addressed and many research questions which remain unanswered. In this chapter, we look at some of the issues which determine when to refactor (i.e., the heuristics of refactoring) and, from a metrics perspective, open issues with measuring the refactoring process. We thus point to emerging trends in the refactoring arena, some of the problems, controversies, and future challenges the refactoring community faces. We hence investigate future ideas and research potential in this area.