scispace - formally typeset
Proceedings ArticleDOI

Exceptions and aspects: the devil is in the details

Reads0
Chats0
TLDR
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.

read more

Content maybe subject to copyright    Report

Citations
More filters
Proceedings ArticleDOI

Evolving software product lines with aspects: an empirical study on design stability

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.
Journal ArticleDOI

Do Crosscutting Concerns Cause Defects

TL;DR: A theory is formulated that explains why increased scattering might lead to increased defects in programs and how this affects code quality.
Proceedings ArticleDOI

On the impact of aspectual decompositions on design stability: an empirical study

TL;DR: A quantitative case study that evolves a real-life application to assess various facets of design stability of OO and AO implementations and includes an analysis of the application in terms of modularity, change propagation, concern interaction, identification of ripple-effects and adherence to well-known design principles.
Proceedings ArticleDOI

A theory of aspects as latent topics

TL;DR: This work provides not only a concrete approach for identifying aspects at several scales in an unsupervised manner but, more importantly, a formulation of AOP grounded in information theory.
Proceedings ArticleDOI

Quantifying the Effects of Aspect-Oriented Programming: A Maintenance Study

TL;DR: It is found that the aspect-oriented design has exhibited superior stability and reusability through the changes, as it has resulted in fewer lines of code, improved separation of concerns, weaker coupling, and lower intra-component complexity.
References
More filters
Book

A metrics suite for object oriented design

TL;DR: This research addresses the needs for software measures in object-orientation design through the development and implementation of a new suite of metrics for OO design, and suggests ways in which managers may use these metrics for process improvement.
Journal ArticleDOI

Aspect-oriented programming

TL;DR: This work proposes to use aspect-orientation to automate the calculation of statistics for database optimization and shows how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries.
Book ChapterDOI

Aspect-Oriented Programming

TL;DR: An analysis of why certain design decisions have been so difficult to clearly capture in actual code is presented, and the basis for a new programming technique, called aspect-oriented programming, that makes it possible to clearly express programs involving such aspects.
Book

Fault tolerance, principles and practice

TL;DR: Methodology and Framework for Fault Tolerance.- Idealised Fault Tolerant Components.- Failure Exceptions.- Critical Components.- The Future.
Proceedings ArticleDOI

Design pattern implementation in Java and aspectJ

TL;DR: AspectJ implementations of the GoF design patterns show modularity improvements in 17 of 23 cases, manifested in terms of better code locality, reusability, composability, and (un)pluggability.
Related Papers (5)