scispace - formally typeset
Search or ask a question
Author

Fernando Castor Filho

Bio: Fernando Castor Filho is an academic researcher from State University of Campinas. The author has contributed to research in topics: Exception handling & Computer science. The author has an hindex of 10, co-authored 20 publications receiving 763 citations. Previous affiliations of Fernando Castor Filho include Universidade de Pernambuco & Federal University of Pernambuco.

Papers
More filters
Proceedings ArticleDOI
10 May 2008
TL;DR: This investigation focused upon a multi-perspective analysis of the evolving product lines in terms of modularity, change propagation, and feature dependency and identified a number of scenarios which positively or negatively affect the architecture stability of aspectual SPLs.
Abstract: Software product lines (SPLs) enable modular, large-scale reuse through a software architecture addressing multiple core and varying features. To reap the benefits of SPLs, their designs need to be stable. Design stability encompasses the sustenance of the product line's modularity properties in the presence of changes to both the core and varying features. It is usually assumed that aspect-oriented programming promotes better modularity and changeability of product lines than conventional variability mechanisms, such as conditional compilation. However, there is no empirical evidence on its efficacy to prolong design stability of SPLs through realistic development scenarios. This paper reports a quantitative study that evolves two SPLs to assess various design stability facets of their aspect-oriented implementations. Our investigation focused upon a multi-perspective analysis of the evolving product lines in terms of modularity, change propagation, and feature dependency. We have identified a number of scenarios which positively or negatively affect the architecture stability of aspectual SPLs.

357 citations

Proceedings ArticleDOI
05 Nov 2006
TL;DR: An in-depth study of the adequacy of the AspectJ language for modularizing exception handling code and performs quantitative assessments of four systems based on four quality attributes, namely separation of concerns, coupling, cohesion, and conciseness.
Abstract: It is usually assumed that the implementation of exception handling can be better modularized by the use of aspect-oriented programming (AOP). However, the trade-offs involved in using AOP with this goal are not well-understood. This paper presents an in-depth study of the adequacy of the AspectJ language for modularizing exception handling code. The study consisted in refactoring existing applications so that the code responsible for implementing heterogeneous error handling strategies was moved to separate aspects. We have performed quantitative assessments of four systems - three object-oriented and one aspect-oriented - based on four quality attributes, namely separation of concerns, coupling, cohesion, and conciseness. Our investigation also included a multi-perspective analysis of the refactored systems, including (i) the reusability of the aspectized error handling code, (ii) the beneficial and harmful aspectization scenarios, and (iii) the scalability of AOP to aspectize exception handling in the presence of other crosscutting concerns.

133 citations

Proceedings ArticleDOI
31 Mar 2008
TL;DR: This paper presents an innovative aspect-oriented model for exception handling implementation that provides abstractions to explicitly describe global views of exceptional control flows and leverages existing pointcut languages to make the association of handlers with normal code more flexible.
Abstract: Many of the problems that stem from the use of exception handling are caused by the local way in which exceptions are handled. It demands that developers understand the source of an exception, the place where it is handled, and everything in between. As a consequence, exceptions easily get "out of control" and, as system development progresses, exceptional control flows become less well-understood, with potentially negative consequences for the program maintainability and reliability. This paper presents an innovative aspect-oriented model for exception handling implementation. In contrast to other exception handling mechanisms, our model provides abstractions to explicitly describe global views of exceptional control flows. As a result, this new model makes it possible to understand exception flows from an end-to-end perspective by looking at a single part of the program. Also, it leverages existing pointcut languages to make the association of handlers with normal code more flexible. The implementation of our proposed model, called EJFlow, extends the AspectJ programming language with the aim of promoting enhanced robustness and program modularization. We evaluate qualitatively and quantitatively the proposed exception handling model through a case study targeting a real mobile application.

61 citations

Proceedings ArticleDOI
TL;DR: This paper reflects on seven issues pertaining to the interplay of crosscutting concerns and architectural connection abstractions and examines the design of existing aspect-oriented and non-AO ADLs with respect to these issues.
Abstract: ions 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. We review and assess the design of existing aspect-oriented (AO) and non-AO ADLs with respect to these issues. A case study is used to illustrate our viewpoints, claims, and proposals.

58 citations

01 Jul 2005
TL;DR: A quantitative study of theacy of aspects for modularizing exception handling code and found that AOP improved separation of concerns between exception Handling code and normal application code.
Abstract: It is usually assumed that the implementation of exception handling can be better modularized by the use of aspect-oriented programming (AOP). However, the trade-offs involved in using AOP with this goal are not yet well- understood. To the best of our knowledge, no work in the literature has attempted to assess whether AOP really promotes an enhancement in well-understood qual- ity attributes other than separation of concerns, when used for modulariz ing non- trivial exception handling code. This paper presents a quantitative study of the ad- equacy of aspects for modularizing exception handling code. The study consisted of refactoring part of a real object-oriented system so that the code re sponsible for handling exceptions was moved to aspects. We employed a suite of metrics to measure quality attributes of the original and refactored systems, includ ing coupling, cohesion, and conciseness. We found that AOP improved separation of concerns between exception handling code and normal application code. How- ever, contradicting the general intuition, the aspect-oriented version of th e system did not present significant gains for any of the four size metrics we emp loyed.

30 citations


Cited by
More filters
Journal Article
TL;DR: This work presents the first experiences in using PROB on several case studies, highlighting that PROB enables users to uncover errors that are not easily discovered by existing tools.
Abstract: We present PROB, an animation and model checking tool for the B method PROB's animation facilities allow users to gain confidence in their specifications, and unlike the animator provided by the B-Toolkit, the user does not have to guess the right values for the operation arguments or choice variables PROB contains a model checker and a constraint-based checker, both of which can be used to detect various errors in B specifications We present our first experiences in using PROB on several case studies, highlighting that PROB enables users to uncover errors that are not easily discovered by existing tools

541 citations

Proceedings ArticleDOI
10 May 2008
TL;DR: This investigation focused upon a multi-perspective analysis of the evolving product lines in terms of modularity, change propagation, and feature dependency and identified a number of scenarios which positively or negatively affect the architecture stability of aspectual SPLs.
Abstract: Software product lines (SPLs) enable modular, large-scale reuse through a software architecture addressing multiple core and varying features. To reap the benefits of SPLs, their designs need to be stable. Design stability encompasses the sustenance of the product line's modularity properties in the presence of changes to both the core and varying features. It is usually assumed that aspect-oriented programming promotes better modularity and changeability of product lines than conventional variability mechanisms, such as conditional compilation. However, there is no empirical evidence on its efficacy to prolong design stability of SPLs through realistic development scenarios. This paper reports a quantitative study that evolves two SPLs to assess various design stability facets of their aspect-oriented implementations. Our investigation focused upon a multi-perspective analysis of the evolving product lines in terms of modularity, change propagation, and feature dependency. We have identified a number of scenarios which positively or negatively affect the architecture stability of aspectual SPLs.

357 citations

Proceedings ArticleDOI
14 Mar 2005
TL;DR: This paper presents a quantitative study that compares aspect-based and OO solutions for the 23 Gang-of-Four patterns and finds that most aspect-oriented solutions improve separation of pattern-related concerns, although only 4 aspect- oriented implementations have exhibited significant reuse.
Abstract: Design patterns offer flexible solutions to common problems in software development. Recent studies have shown that several design patterns involve crosscutting concerns. Unfortunately, object-oriented (OO) abstractions are often not able to modularize those crosscutting concerns, which in turn decrease the system reusability and maintainability. Hence, it is important verifying whether aspect-oriented approaches support improved modularization of crosscutting concerns relative to design patterns. Ideally, quantitative studies should be performed to compare OO and aspect-oriented implementations of classical patterns with respect to important software engineering attributes, such as coupling and cohesion. This paper presents a quantitative study that compares aspect-based and OO solutions for the 23 Gang-of-Four patterns. We have used stringent software engineering attributes as the assessment criteria. We have found that most aspect-oriented solutions improve separation of pattern-related concerns, although only 4 aspect-oriented implementations have exhibited significant reuse.

308 citations