Paulo S. C. Alencar

Taming agents and objects in software engineering

Agent-based software engineering has been proposed in addition to object-oriented software engineering as a means of mastering the complexity associated with the development of large-scale distributed systems. However, there is still a poor understanding of the interplay between the notions of agents and objects from a software engineering perspective. Moreover, the many facets of agent-based software engineering are rarely used in the various phases of the software development lifecycle because of the lack of a comprehensive framework to provide the software designers with a clear understanding of the use of these two key abstractions. In this context, this paper presents TAO, an evolving innovative conceptual framework based on agent and object abstractions, which are the foundations for modeling large-scale software systems. The conceptual framework allows for the characterization of large-scale software systems as organizations of passive components, the objects, and autonomous components, the agents, with each of these elements playing roles to interact with each other and to coordinate their actions in order to fulfill system goals.

A Formal Approach to Architectural Design Patterns

In this paper we introduce a formal approach to architectural design patterns based on an object-oriented model integrated with a process-oriented method for describing the patterns. The object-oriented model is based on the Abstract Data View (ADV) concept, which is a formal model for subjectivity in that it explicitly distinguishes between two kinds of objects, namely application objects and object vieWs. The formalism allows the definition and application of design patterns by considering both the process program for the pattern tasks and the interconnected objects and views resulting from a particular pattern instantiation. The approach can be used to describe design patterns at many different architectural levels, and this is illustrated by presenting patterns for the master-slave, pipes- and-filters, layered systems, adapter, observer, and composite.

Ensuring structure and behavior correctness in design composition

The design of a large component-based software system typically involves the composition of different components. Instead of relying on a free composition of components, we advocate that more rigorous analysis methods to check the correctness of component composition would allow combination problems to be detected early in the development process so that people can save considerable effort offering errors downstream. In this paper we describe a rigorous method for component composition that can be used to solve combination and integration problems at the (architectural) design phase of the software development lifecycle. In addition, we introduce the notion of composition pattern in order to promote the reuse of composition solutions to solve routine component composition problems. Once a composition pattern is proven correct, its instances can be used in a particular application without further proof. In this way, our proposed method involves reusing compositions as well as reusing components. We illustrate the utility of our approach through an example related to the composition of design patterns as design components. Structural and behavioral correctness proofs about the composition of some design patterns are provided.

A pattern-based approach to structural design composition

This paper describes an approach to component-based software engineering based on a formal description of design patterns. The architectural design information, captured by design patterns, is made explicit and represented in a declarative way, being packaged into tangible artifacts as building block design components in the development process. These design component descriptions can be instantiated, adapted, assembled, implemented, and maintained. Furthermore, we can use these representations to reason about properties related to the combination of design components. We illustrate the utility of our approach through a case study involving various design patterns.

BPMNt: A BPMN extension for specifying software process tailoring

Abstract Context Although SPEM 2.0 has great potential for software process modeling, it does not provide concepts or formalisms for precise modeling of process behavior. Indeed, SPEM fails to address process simulation, execution, monitoring and analysis, which are important activities in process management. On the other hand, BPMN 2.0 is a widely used notation to model business processes that has associated tools and techniques to facilitate the aforementioned process management activities. Using BPMN to model software development processes can leverage BPMN’s infrastructure to improve the quality of these processes. However, BPMN lacks an important feature to model software processes: a mechanism to represent process tailoring. Objective This paper proposes BPMNt, a conservative extension to BPMN that aims at creating a tailoring representation mechanism similar to the one found in SPEM 2.0. Method We have used the BPMN 2.0 extensibility mechanism to include the representation of specific tailoring relationships namely suppression, local contribution, and local replacement, which establish links between process elements (such as in the case of SPEM). Moreover, this paper also presents some rules to ensure the consistency of BPMN models when using tailoring relationships. Results In order to evaluate our proposal we have implemented a tool to support the BPMNt approach and have applied it for representing real process adaptations in the context of an academic management system development project. Results of this study showed that the approach and its support tool can successfully be used to adapt BPMN-based software processes in real scenarios. Conclusion We have proposed an approach to enable reuse and adaptation of BPMN-based software process models as well as derivation traceability between models through tailoring relationships. We believe that bringing such capabilities into BPMN will open new perspectives to software process management.

A metamodel for distributed event based systems

A metamodel, suitable for the study of modularization and composition of functionality in distributed event systems, is proposed in this paper. The metamodel describes the structural, control, and runtime aspects of distributed event systems. Central to the metamodel is the use of reactive component interfaces. Reactive component interfaces specify the events components in the system generate and react to, and describe the behaviour expected from the components. Gem, a distributed event system that follows the metamodel is presented. Two composition mechanisms, interface extension and encapsulation, are supported in Gem and serve to illustrate the type of compositions that can be implemented by systems that conform to the metamodel.

Composing pattern-based components and verifying correctness

Abstract Designing large software systems out of reusable components has become increasingly popular. Although liberal composition of reusable components saves time and expense, many experiments indicate that people will pay for this (liberal composition) sooner or later, sometimes paying even a higher price than the savings obtained from reusing components. Thus, we advocate that more rigorous analysis methods to check the correctness of component composition would allow combination problems to be detected early in the development process so that people can save the considerable effort of fixing errors downstream. In this paper we describe a rigorous method for component composition that can be used to solve combination and integration problems at the (architectural) design phase of the software development lifecycle. In addition, we introduce the notion of composition pattern in order to promote the reuse of composition solutions to solve routine component composition problems. Once a composition pattern is proven correct, its instances can be used in a particular application without further proof. In this way, our proposed method involves reusing compositions as well as reusing components. We illustrate our approach through an example related to the composition of design patterns as design components. Structural and behavioral correctness proofs about the composition of design patterns are provided. Case studies are also presented to show the applications of the composition patterns.

Supporting Formal Verification of Crosscutting Concerns

This paper presents an approach to formal verification of the properties of systems composed of multiple crosscutting concerns. The approach models concerns as sets of concurrent processes, and provides a method of composition that mimics the composition operators of existing multiple-concern implementation languages. A case study demonstrates the composition process and shows how formal verification of different composition strategies can detect potential problems. We also discuss the need for a general model of concerns that can be handled by different formal languages.

A behavioral analysis and verification approach to pattern-based design composition

Integrating software components to produce large-scale software systems is an effective way to reuse experience and reduce cost. However, unexpected interactions among components when integrated into software systems are often the cause of failures. Discovering these composition errors early in the development process could lower the cost and effort in fixing them. This paper introduces a rigorous analysis approach to software design composition based on automated verification techniques. We show how to represent, instantiate and integrate design components, and how to find design composition errors using model checking techniques. We illustrate our approach with a Web-based hypermedia case study.

A generative approach for multi-agent system development

The development of Multi-Agent Systems (MASs) involves special concerns, such as interaction, adaptation, autonomy, among others. Many of these concerns are overlapping, crosscut each other and the agent’s basic functionality. Over the last few years, several methodologies and implementation frameworks have been proposed to support agent-oriented software engineering. Although these approaches have brought some benefits to improve the productivity and quality on the MAS development, they present some restrictions. First, agent-oriented methodologies are too high level and do not indicate how to master the complexity of MAS concerns based on the object-oriented abstractions. Second, implementation frameworks provide object-oriented APIs for MAS development without providing guidelines for the modularization of agent concerns. Moreover, neither of the proposed agent oriented-approaches deals with the modeling and implementation of agent crosscutting concerns. This paper presents a generative approach for the development of MASs that addresses these restrictions. The proposed approach explores the MAS domain to enable the code generation of heterogeneous agent architectures. Aspect-oriented techniques are used to allow the modeling of crosscutting agent features. The generative approach brings several benefits to the code generation and modeling of agent crosscutting features since early development stages.