JOOP Archives

Tooling the MDA framework: a new software maintenance and evolution scheme proposal

The Object Management Group is rapidly moving from its previous Object Management Architecture vision (OMA) to the newest Model-Driven Architecture (MDA). At the center of this framework, the so-called four-level meta-modeling architecture provides the foundations for building a variety of automatic and semi-automatic model-transformation and code-generation tools. The most important will be platform targeted code-generation tools but there are plenty of other possibilities that we can expect to become available in the near future. As an example, this paper shows how modern meta-modeling and meta-programming techniques may be combined to implement a new generation of software maintenance tools. The proposal deals with the future maintenance of software written in the C# programming language, supported by the DotNet platform and uses all support available in the MDA framework (UML, MOF, XMI). In addition to this, we take advantage of the introspection properties of C#. A similar approach could also be used with other modern programming languages like Smalltalk or, to a lesser extent, Java.

Gaining New Fields of Application for OOP: the Parallel Evolutionary Algorithm Case

Object-Oriented Programming (OOP) is continuously gaining new domains of application. We'll study several important design and implementation issues in one new domain: parallel evolutionary algorithms (PEAs). These algorithms are heuristics aimed at performing search, optimization, and machine learning tasks. We identify the potential and actual advantages of using OOP in such a field of application, as well as propose a class design for solving complex real-world problems with PEAs. Besides the methodological and practical outcomes, some results showing the efficiency and flexibility of the resulting OOP-PEA systems are offered herein. We conclude that OOP allows quick PEA prototyping, integration of new techniques within the PEA, and easy cooperation with other techniques in parallel, all of this without reducing the efficiency of the resulting PEA.

Algorithm = Iterator + Visitor

The authors demonstrate that an algorithm implementation can be generalized into a composition of iterators and visitors (higher-order function objects). This is known from STL and from research in generic and functional programming, but it has not been demonstrated that the notion of iterators and visitors is sufficient for allowing polytypism in entire categories of algorithms without sacrificing on polymorphism in data structures. This paper emerges from recent experiments in the design of the Extended Function Library (EFLIB), a framework developed by Johan L. Larsson. These experiments show how large groups of algorithms can be classified using a set of visitors and iterators, and how data structures can be decomposed into lists and generators to achieve polytypism in an object-oriented language, thus making a program more open to change.

Integrating Extension and Specialization Inheritance

Extension and specialization inheritance are two viewpoints of inheritance that are usually at odds; i.e., to fully support extension inheritance one should sacrifice specialization inheritance and vice-versa. We present a new approach to integrate the two views of inheritance in an OO language. Our approach to the integration enhances the use of inheritance both as a code reuse tool and as a modeling tool. The integration uses a new abstraction mechanism called the component. We use two separate language constructs to distinguish between the two perspectives of inheritance.

Project Management Using OPEN

Project management (PM) is an integral part of software development. Although some OO processes avoid these important, people-related issues, OPEN addresses these fully in terms of Activities, Tasks, Techniques, and Roles that best exemplify practice in PM.

Role = Interface: A Merger of Concepts

The author advances the idea that roles and interfaces have much in common and, with a few changes in definition, can be merged into one.

Tracking Software Components

Component engineering is gaining substantial interest within the software engineering community. A great deal of research has been devoted to analysis and design methods for component-based software. However, only a few articles have addressed the testing and maintenance problems of component-based software. This article discusses component traceability and maintenance issues and solutions in supporting software components of component-based software. The authors propose a Java framework, as well as a systematic approach to support tracking and monitoring of software components in component-based programs. Application examples and the supporting system are described. In addition, the concept of traceable components, including requirements, design guidelines, and architecture style, is introduced.

Upcoming Events


Sign up for our newsletter.

Terms and Privacy Policy consent

I agree to this site's Privacy Policy.