Aspect] is a simple and practical aspect-oriented extension to Java With just a few new constructs, AspectJ provides support for modular implementation of a range of crosscutting concerns. In AspectJ's dynamic join point model, join points are well-defined points in the execution of the program; pointcuts are collections of join points; advice are special method-like constructs that can be attached to pointcuts; and aspects are modular units of crosscutting implementation, comprising pointcuts, advice, and ordinary Java member declarations. AspectJ code is compiled into standard Java bytecode. Simple extensions to existing Java development environments make it possible to browse the crosscutting structure of aspects in the same kind of way as one browses the inheritance structure of classes. Several examples show that AspectJ is powerful, and that programs written using it are easy to understand.

An overview of AspectJ

Requirements for graduate theses and dissertations are determined by the graduate school and the departmental committee headed by a major advisor under whom a student works. Contents require a report on research usually accompanied by a review of the literature on the subject. In form, traditional theses are written as one entity; other theses may include manuscripts for publication. The student is usually required to defend the contents and quality of the thesis in an oral session before his or her committee. To establish a time line and to work on writing the thesis throughout the graduate program will relieve some pressure at the end of the program. The student may be expected to publish at least a part of the thesis, usually as a journal article.

Graduate Theses and Dissertations

The goals of exception handling mechanisms are to make programs more reliable and robust. The integration of exception handling mechanisms with object-oriented languages raises some unique issues. The requirements of exception handling often conflict with some of the goals of object-oriented designs, such as supporting design evolution, functional specialization, and ion for implementation transparency. This paper demonstrates these conflicts, illustrates that the use of exception handling in object-oriented systems poses potential pitfalls, and suggests that their resolution is one of the first steps necessary to make exception handling robust in object-oriented designs and languages.

Issues with exception handling in object-oriented systems

Aspect-oriented programming (AOP) is a popular technique for modularizing crosscutting concerns. In this context, researchers have found that the realization of design by contract (DbC) is crosscutting and fares better when modularized by AOP. However, previous efforts aimed at supporting crosscutting contract modularity might actually compromise the main DbC principles. For example, in AspectJ-style, reasoning about the correctness of a method call may require a whole-program analysis to determine what advice applies and what that advice does relative to DbC implementation and checking. Also, when contracts are separated from classes a programmer may not know about them and may break them inadvertently. In this paper we solve these problems with AspectJML, a new specification language that supports crosscutting contracts for Java code. We also show how AspectJML supports the main DbC principles of modular reasoning and contracts as documentation.

/pdf/aspectjml-modular-specification-and-runtime-checking-for-2af4ltlsbt.pdf

AspectJML: modular specification and runtime checking for crosscutting contracts

• A submitted manuscript is the author's version of the article upon submission and before peer-review. There can be important differences between the submitted version and the official published version of record. People interested in the research are advised to contact the author for the final version of the publication, or visit the DOI to the publisher's website. • The final author version and the galley proof are versions of the publication after peer review. • The final published version features the final layout of the paper including the volume, issue and page numbers.

/pdf/from-concurrent-state-machines-to-reliable-multi-threaded-1xrlxe6rec.pdf

From concurrent state machines to reliable multi-threaded Java code

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-X that enables modular reasoning about behaviors and flows of exceptions for event announcement and handling. Ptolemy-X'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-X's type system and refinement rules enforce these specifications and thus enable its modular reasoning. We evaluate the utility of Ptolemy-X's exception flow reasoning by applying it to understand a set of aspect-oriented (AO) bug patterns. We also present Ptolemy-X's semantics including its sound static semantics.

/pdf/on-exceptions-events-and-observer-chains-4rp1wozdlt.pdf

On exceptions, events and observer chains

Applications with a Graphical User Interface (GUI) front-end are ubiquitous, thus it is of great importance to assure the quality of such systems. Model-based GUI testing provides an effective mechanism for automated testing of applications with a GUI. However, most existing model-based GUI test generation techniques produce many infeasible (i.e., Broken) event sequences which are used as test cases. This happens primarily because they ignore behavioral specifications of the GUI under test. In this paper, we present an automated black box framework that reveals an important set of GUI invariants as state-based event constraints. GUIDiVa, an iterative algorithm at the core of our framework, enumerates all possible constraint violations as potential reasons of a test case failure, on the failed event of the infeasible test case. It further selects and adds the most promising constraints of each iteration to a final set based on our notion of constraint Validity Weight. The results of empirical studies on both seeded and nine non-trivial study subjects show that our framework is capable of capturing important aspects of GUI behavior, while considerably reducing the number of insfeasible test cases. Additionally, a human oracle is used to further validate the accuracy of the discovered constraints.

Ali Darvish

Papers

On exceptions, events and observer chains

GUIDiVa: Automated Discovery and Validation of State-Based GUI Invariants