Computer Science Department

Aspect-Oriented Software Development (AOSD) is an emerging area with the goal of promoting advanced separation of concerns throughout the software development lifecycle. However, since there are many different approaches to Aspect-Oriented Programming (AOP), it is very difficult to identify the essential concepts and properties for supporting the design of aspect-oriented languages and tools, and effectively promote advances in the field of AOSD. In this context, this paper presents a theory of aspects -a conceptual framework for AOP that provides consistent terminology and basic semantics for thinking about a problem in terms of the core concepts and properties that characterize the aspect-oriented style as an emerging paradigm to software development. This theory has been used for evaluating existing aspect-oriented languages and tools and, in special, it has been used to characterize aSide, an aspect-oriented modeling language.

Aspect-oriented software development promotes improved separation of concerns by introducing a new modular unit, called aspect, for the modularization of crosscutting concerns. As a new kind of modular unit, aspects should have explicit interfaces that describe the way they interact with the rest of the system and how they affect other modules. This interaction can be homogeneous, for example, by providing a logging behavior that affects all procedures in a certain interface; or it can be heterogeneous, for example, by implementing the two sides of a protocol that affects two different classes. In this paper, we present crosscutting interfaces as a conceptual tool for dealing with the complexity of heterogeneous aspects at the design level. Crosscutting interfaces have been incorporated by the aSideML modeling language in order to enhance aspect description at the design level. Moreover, we present a modeling notation for the description of architecture-level aspects that also supports the explicit representation of crosscutting interfaces. Finally, we present a large-scale case study we have performed using this modeling language that supports our arguments in favor of crosscutting interfaces.

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.

Abstract Most of the methods for concern modularity analysis rely on the exploration of crosscutting concerns directly in source code artifacts. However, as both the code size and the number of concerns increase, analyses of concern properties become an even more cumbersome and time-consuming task. In this paper, we propose a visual representation of crosscutting concerns using a software visualization infrastructure called SourceMiner.

ABSTRACT There is now an increasing agreement that aspects are not only an issue at the programming level, but also tend to arise at the requirements analysis and software architecture design. Unfortunately conventional software modeling approaches lack abstractions to support the modular representation of crosscutting concerns in such development stages. Hence, several researchers have proposed modeling techniques that primarily aim for modeling aspects at the early development phases.

Abstract. An architectural aspect is a concern that cuts across architecture modularity units and cannot be effectively modularized using the given abstractions of conventional Architecture Description Languages (ADLs). Dealing with crosscutting concerns is not a trivial task since they affect each other and the base architectural decomposition in multiple heterogeneous ways.

Several concerns in the development of multi-agent systems (MASs) cannot be represented in a modular fashion. In general, they inherently affect several system modules and cannot be explicitly captured based on existing software engineering abstractions. These crosscutting concerns encompass internal agent properties and systemic properties, such as learning, code mobility, error handling, and context-awareness.

Abstract Abstractions to express architectural connection play a central role in architecture design, especially in Architecture Description Languages (ADLs). With the emergence of aspect-oriented software development (AOSD), there is a need to understand the adequacy of ADLs' conventional connection abstractions to capture the crosscutting nature of architectural concerns. This paper reflects on seven issues pertaining to the interplay of crosscutting concerns and architectural connection abstractions.

Abstract. A number of concerns in multi-agent systems (MAS) have a broadly-scoped impact on the system architectural decomposition, which in turn hinder the design of modular MAS architectures. These concerns inherently crosscut the boundaries of several architecture elements, such as components, connectors, and their interfaces. Typical examples of crosscutting concerns in MAS architecture include learning, mobility, coordination, context-awareness, and error handling.

Abstract. With the emergence of Aspect-Oriented Software Development (AOSD), there is a need to understand the adequacy of Architecture Description Languages (ADLs) connection abstractions for capturing the crosscutting nature of some architectural concerns. In this paper, we present the Aspectual Connector (AC), a special kind of architectural connector, as the only necessary enhancement to an ADL in order to support a seamless integration of AOSD and Software Architecture.

Abstract As the demand for web applications grows, so does the demand for tools that support them. As a general rule, such tools extend general purpose programming languages, like Servlets/Jsp [2] does for Java [4], or define their own programming language, like PHP [3]. But there is no established engine for web applications written with C++. This work presents technical challenges that were faced when developing T++, an engine that supports web application development with C++.

Abstract In component-based programming, it is often desirable that applications can be modeled as sets of services executed by components selected at runtime. In order to support this requirement, we present the Generic Connector, a mechanism that searches for components that provide the services required in the application con guration program, activates each service and returns the results to the client. The Generic Connector explores Lua's and LuaOrb's intrinsic characteristics.

Abstract The longevity of evolving software systems largely depends on their resilience to architectural design degradation. It is often assumed that code anomalies are always key indicators of architecture degradation symptoms. The problem is that there is still limited knowledge about the circumstances under which code anomalies represent architectural problems. Without this knowledge, developers are not able to implement architecturally-relevant strategies for code refactoring.

Abstract A significant number of Free Software projects has been widely used and considered successful. However, there is an even larger number of them that cannot overcome the initial step towards building an active community of users and developers. In this study, we investigated whether there are relationships between source code metrics and attractiveness, ie, the ability of a project to attract users and developers. To verify these relationships, we analyzed 6,773 Free Software projects from the SourceForge.