• Documents
  • Authors
  • Tables

CiteSeerX logo

Advanced Search Include Citations
Advanced Search Include Citations

Combining the robustness of checked exceptions with the flexibility of unchecked exceptions using anchored exception declarations. (2005)

by M van Dooren, E Steegmans
Venue:In Proceedings of OOPSLA’05,
Add To MetaCart

Tools

Sorted by:
Results 1 - 10 of 13
Next 10 →

Exceptions and aspects: the devil is in the details.

by Fernando Castor Filho , Nelio Cacho , Eduardo Figueiredo , Raquel Maranhão , Alessandro Garcia , Cecília Mary , F Rubira - In SIGSOFT ’06/FSE-14: Proceedings of the 14th ACM SIGSOFT international symposium on Foundations of software engineering, , 2006
"... ABSTRACT It is usually assumed that the implementation of exception handling can be better modularized by the use of aspectoriented 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 A ..."
Abstract - Cited by 30 (4 self) - Add to MetaCart
ABSTRACT It is usually assumed that the implementation of exception handling can be better modularized by the use of aspectoriented 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 systemsthree 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.
(Show Context)

Citation Context

...re concise, reusable, evolvable, and Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. SIGSOFT’06/FSE-14, November 5–11, 2006, Portland, Oregon, USA. Copyright 2006 ACM 1-59593-468-5/06/0011 ...$5.00. reliable [6, 13]. Several researchers [8, 20, 23] have explored new programming techniques in order to reap the promised benefits of existing exception handling mechanisms. In spite of this, achieving modular implementations of error handling code is still difficult for software engineers. The main problem is that realistic software systems exhibit very intricate relationships involving the normal-processing code and error recovery concerns. Moreover, exception handling is known to be a global design issue [10] that affects almost all the system modules [20], mostly in an application-specific fashion [1]. Also, a large part of the system cod...

Error propagation analysis for file systems

by Cindy Rubio-gonzález, Haryadi S. Gunawi, Ben Liblit, Remzi H. Arpaci-dusseau, Andrea C. Arpaci-dusseau - In Proceedings of the ACM SIGPLAN 2009 Conference on Programming Language Design and Implementation , 2009
"... Unchecked errors are especially pernicious in operating system file management code. Transient or permanent hardware failures are inevitable, and error-management bugs at the file system layer can cause silent, unrecoverable data corruption. We propose an interprocedural static analysis that tracks ..."
Abstract - Cited by 23 (8 self) - Add to MetaCart
Unchecked errors are especially pernicious in operating system file management code. Transient or permanent hardware failures are inevitable, and error-management bugs at the file system layer can cause silent, unrecoverable data corruption. We propose an interprocedural static analysis that tracks errors as they propagate through file system code. Our implementation detects overwritten, out-ofscope, and unsaved unchecked errors. Analysis of four widely-used Linux file system implementations (CIFS, ext3, IBM JFS and ReiserFS), a relatively new file system implementation (ext4), and shared virtual file system (VFS) code uncovers 312 error propagation bugs. Our flow- and context-sensitive approach produces more precise results than related techniques while providing better diagnostic information, including possible execution paths that demonstrate each bug found.
(Show Context)

Citation Context

...exception throwing declarations are explicitly checked at run time only, not at compile time. Java’s insistence that most exceptions be either caught or explicitly declared as thrown is controversial =-=[29, 30]-=-. Frustrated Java programmers are known to pacify the compiler by adding blanket catch clauses that catch and discard all possible exceptions. C# imposes no static validation; Sacramento et al. [26] f...

Ejflow: Taming exceptional control flows in aspect-oriented programming

by Nelio Cacho, O Castor Filho, Ro Garcia, Eduardo Figueiredo - in: Proc. of 7th ACM Conference on Aspect-Oriented Software Development , 2008
"... 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 c ..."
Abstract - Cited by 7 (2 self) - Add to MetaCart
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.
(Show Context)

Citation Context

...ate the list of unhandled exceptions thatseach method signals to its clients, otherwise, the compiler willsreport an error. The main problem with this approach is that itshinders software maintenance =-=[14]-=-. If a new exception is added tosthe exception interface of a method at the bottom of the methodscall chain, the exception interfaces of all methods through whichsthe new exception will be propagated ...

Software---Practice And Experience

by Softw Pract Exper, Roman Pichler, Mira Mezini - Software – Practice and Experience , 2003
"... Aspects To apply authorization checks to Order and Product in Fig. 9, we don't change RoleBasedAuthorization but implement the pointcut of OrderProductAuthorization instead. The pointcut now also denotes those points in the execution of the program when instances of the Product class receive m ..."
Abstract - Cited by 4 (0 self) - Add to MetaCart
Aspects To apply authorization checks to Order and Product in Fig. 9, we don't change RoleBasedAuthorization but implement the pointcut of OrderProductAuthorization instead. The pointcut now also denotes those points in the execution of the program when instances of the Product class receive messages in addition to the points when instances of Order receive messages. OrderProductAuthorization thus fulfills a similar role as a binding in [12, 13].
(Show Context)

Citation Context

...nisms to associate exception handlers with exception flows in a Java program, providing developers with local control over global exceptions. In addition, it leverages anchored exception declarations =-=[5]-=- as a workaround to some of the maintenance problems inherent to Java-based exception handling. The authors have shown that the use of EJFlow yields programs with better quality attributes, when compa...

On Exceptions, Events and Observer Chains

by Mehdi Bagherzadeh, Hridesh Rajan, Ali Darvish
"... Modular understanding of behaviors and flows of exceptions may help in their better use and handling. Such reasoning tasks about exceptions face unique challenges in event-based implicit invocation (II) languages that allow subjects to implicitly invoke observers, and run the observers in a chain. I ..."
Abstract - Cited by 4 (2 self) - Add to MetaCart
Modular understanding of behaviors and flows of exceptions may help in their better use and handling. Such reasoning tasks about exceptions face unique challenges in event-based implicit invocation (II) languages that allow subjects to implicitly invoke observers, and run the observers in a chain. In this work, we illustrate these challenge in Ptolemy and propose Ptolemyχ that enables modular reasoning about behaviors and flows of exceptions for event announcement and handling. Ptolemyχ’s exception-aware specification expressions and boundary exceptions limit the set of (un)checked exceptions of subjects and observers of an event. Exceptional postconditions specify the behaviors of these exceptions. Greybox specifications specify the flows of these exceptions among the observers in the chain. Ptolemyχ’s type system and refinement rules enforce these specifications and thus enable its modular reasoning. We evaluate the utility of Ptolemyχ’s exception flow reasoning by applying it to understand a set of aspect-oriented (AO) bug patterns. We also present Ptolemyχ’s semantics including its sound static semantics.
(Show Context)

Citation Context

...ceptions, especially their behaviors and flows may help with their better use and handling [28, 35]. Previous work, such as JML [25], ESC/Java [12], the work of Jacobs et al. [16] anchored exceptions =-=[39]-=-, Jex [33] and EJFlow [5] enable reasoning about behaviors or flows of exceptions. However, they are tailored for systems in which invocation relations among the modules are explicit and known, i.e. e...

A higher abstraction level using first-class inheritance relations

by Marko Van Dooren, Eric Steegmans - IN ECOOP , 2007
"... Although classes are a fundamental concept in object-oriented programming, a class itself cannot be built using general purpose classes as building blocks in a practical manner. High-level concepts like associations, bounded values, graph structures, and infrastructure for event mechanisms which for ..."
Abstract - Cited by 3 (3 self) - Add to MetaCart
Although classes are a fundamental concept in object-oriented programming, a class itself cannot be built using general purpose classes as building blocks in a practical manner. High-level concepts like associations, bounded values, graph structures, and infrastructure for event mechanisms which form the foundation of a class cannot be reused conveniently as components for classes. As a result, they are implemented over and over again. We raise the abstraction level of the language with a code inheritance relation for reusing general purpose classes as components for other classes. Features like mass renaming, first-class relations, high-level dependencies, component parameters, and indirect inheritance ensure that maximal reuse can be achieved with minimal effort. A case study shows a reduction of the code between 21 % and 36%, while the closest competitor only reduces the size between 3 % and 12%.
(Show Context)

Citation Context

...dings. In this paper, we built an application using components without using nested classes. So while nested classes provide certain benefits, they are not a requirement for component composition. In =-=[44]-=-, we introduced anchored exception declarations to remove hard references from the exceptional specification of a component. They allow the exceptional specification of a method to be declared relativ...

Influence of type systems on dynamic software evolution

by Yves Vandewoude, Peter Ebraert, Yolande Berbers, Theo D'Hondt , 2005
"... ..."
Abstract - Cited by 3 (2 self) - Add to MetaCart
Abstract not found

Abstractions for Improving, Creating, and Reusing Object-Oriented Programming Languages

by Marko Van Dooren , 2007
"... ..."
Abstract - Cited by 2 (2 self) - Add to MetaCart
Abstract not found

Abstract Data Type Components

by Marko van Dooren, Eric Steegmans , 2006
"... Although abstract data types are the foundation of object-oriented programming, the use of application independent ADTs as components for other ADTs is surprisingly difficult. No existing language allows the ADTs of high-level elements like associations, bounded values, graphs,... to be reused conve ..."
Abstract - Cited by 2 (2 self) - Add to MetaCart
Although abstract data types are the foundation of object-oriented programming, the use of application independent ADTs as components for other ADTs is surprisingly difficult. No existing language allows the ADTs of high-level elements like associations, bounded values, graphs,... to be reused conveniently as components. As a result, their instance variables and methods are implemented over and over again. To allow such elements to be reused, we raise the abstraction level of the language by introducing a new multiple inheritance mechanism with two relations: is-a and has-a. The is-a relation is for subtyping and code inheritance, and is tailored for classification. The has-a relation is for code inheritance only, and is tailored for composition of ADTs. Using this inheritance mechanism, the implementation of the foundation of a program becomes a trivial task. A case study shows a 22 % decrease in the size of the code, while the second best inherit ance mechanism gets no further than 5%. In addition, the mechanism reduces the dependenc y between the implementation of a class and its hierarchy. We present a formal model of the inheritance mechanism, along with a proof of type soundness.

Assessing Intra-Application Exception Handling Reuse with Aspects

by Júlio César Taveira, Cristiane Queiroz, Rômulo Lima, Juliana Saraiva, Sérgio Soares, Hítalo Oliveira, Nathalia Temudo, Amanda Araújo, Jefferson Amorim, Fernando Castor, Emanoel Barreiros - XXIII BRAZILIAN SYMPOSIUM ON SOFTWARE ENGINEERING , 2009
"... Recent studies have attempted to evaluate the benefits and drawbacks of using aspect-oriented programming to modularize exception handling code. In spite of their many interesting findings, these studies have not reached a consensus when it comes to the impact of aspectization on exception handler ..."
Abstract - Cited by 1 (0 self) - Add to MetaCart
Recent studies have attempted to evaluate the benefits and drawbacks of using aspect-oriented programming to modularize exception handling code. In spite of their many interesting findings, these studies have not reached a consensus when it comes to the impact of aspectization on exception handler reuse. In fact, their results are sometimes in direct contradiction.In this paper we describe a study aiming to answer the question of whether AOP really promotes the implementation of reusable exception handling. We analyze reuse in a specific context: in terms of the number of duplicated or very similar error handlers that can be removed from a program when extracting error handling code to aspects. Our study targets three industrial-strength, medium-size software systems from different domains and employs a comprehensive set of concern-specific metrics.
Powered by: Apache Solr
  • About CiteSeerX
  • Submit and Index Documents
  • Privacy Policy
  • Help
  • Data
  • Source
  • Contact Us

Developed at and hosted by The College of Information Sciences and Technology

© 2007-2019 The Pennsylvania State University