Marko van Dooren

Combining the robustness of checked exceptions with the flexibility of unchecked exceptions using anchored exception declarations

Ever since their invention 30 years ago, checked exceptions have been a point of much discussion. On the one hand, they increase the robustness of software by preventing the manifestation of unanticipated checked exceptions at run-time. On the other hand, they decrease the adaptability of software because they must be propagated explicitly, and must often be handled even if they cannot be signalled.We show that the problems with checked exceptions are caused by a lack of expressiveness of the exceptional return type of a method, which currently dictates a copy & paste style. We add the required expressiveness by introducing anchored exception declarations, which allow the exceptional behavior of a method to be declared relative to that of others. We present the formal semantics of anchored exception declarations, along with the necessary rules for ensuring compile-time safety, and give a proof of soundness. We show that anchored exception declarations do not violate the principle of information hiding when used properly, and provide a guideline for when to use them.We have implemented anchored exception declarations in Cappuccino, which is an extension to the ClassicJava programming language.

A higher abstraction level using first-class inheritance relations

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%.

Subobject-Oriented Programming

Classes are fundamental elements in object-oriented programming, but they cannot be assembled in a truly flexible manner from other classes. As a result, cross-cutting structural code for implementing associations, graph structures, and so forth must be implemented over and over again. Subobject-oriented programming overcomes this problem by augmenting object-oriented programming with subobjects. Subobjects can be used as buildings blocks to configure and compose classes without suffering from name conflicts. This paper gives an overview of subobject-oriented programming and introduces mechanisms for subobject initialization, navigation of the subobject structure in super calls, and subobject refinement. Subobject-oriented programming has been implemented as a language extension to Java with Eclipse support and as a library in Python.

Language constructs for improving reusability in object-oriented software

The objective of this research project is to improve the reusability of object-oriented software. We have introduced anchored exception declarations to allow checked exceptions to be used conveniently in reusable software elements such as design patterns. We are now investigating an innovative inheritance mechanism based on existing inheritance mechanisms like that of Eiffel and on traits. The resulting mechanism should allow a programmer to construct a class from existing components with little effort.

Multi-view refinement of AO-connectors in distributed software systems

This paper presents MView, a technique that enables the separation of various developer stakeholder views on an architectural connector in distributed software systems. While state-of-the-art AO-ADLs focus on describing compositions using aspect-based connectors, there is no support for describing a connector across multiple architectural views. This is, however, essential for distributed systems, where run-time and distribution characteristics are not represented in a single view. The result is connectors that suffer from monolithic descriptions, where the views of different stakeholders are tangled. MView untangles these stakeholder views by defining them in separate modules and specifying refinement relations between these modules. We have integrated MView in a prototypical ADL, which allows code generation for multiple AO-middleware platforms. We evaluate MView in terms of stakeholder effort in a content distribution system for e-Media. We have created an Eclipse-plugin that supports the ADL, and performs code generation to the JBoss and Spring middleware platforms.

Subobject transactional memory

Concurrent object-oriented programs are hard to write because of the frequent use of state in objects. In a concurrent program, this state must be protected against race-conditions and deadlocks, which costs a lot of effort and is error-prone. Software transactional memory is a mechanism for concurrency control that is similar to mechanisms used in databases. The programmer does not deal with low-level locks, but instead uses transaction demarcation to protect shared memory. We show that in a statically typed subobject-oriented programming language, a transactional program requires less effort than writing a regular object-oriented programming. In addition, we show how transactionality can be added to existing classes without performing code transformations or using a meta-object protocol.

An object-oriented framework for aspect-oriented languages

Aspect-orientation is a mechanism for modularizing cross-cutting concerns that has been added to many existing software engineering languages. The implementations of aspect-oriented language extensions, however, are typically tied to a specific base language. There is little or no code reuse between aspect-oriented extensions for different base languages, which makes these extensions difficult and expensive to build. In addition, existing software engineering tools do not work with the resulting aspect-oriented languages unless new plugins are developed. We present Carpenter, an object-oriented framework for developing aspect-oriented language extensions. An aspect language is developed by reusing classes for generic language constructs from Carpenter, and writing subclasses of the abstractions in Carpenter to define new language constructs. An aspect weaver is created by implementing framework interfaces to weave language-specific constructs. The coordination of the weaving process is done by the Carpenter framework. Aspect languages developed with Carpenter get full IDE support with only a few lines of code. We have used our framework to create aspect weavers for Java, JLo, and AspectU.

Modular type checking of anchored exception declarations

Abstract Checked exceptions improve the robustness of software, but they also decrease its adaptability because they must be propagated explicitly, and because they must often be handled even if they cannot be thrown. Anchored exception declarations solve both problems by allowing a method to declare its exceptional behavior in terms of other methods. The original type checking analyses for anchored exception declarations, however, are not modular. In this paper, we present algorithms for modular verification of soundness in an object-oriented language without parametric polymorphism.

Modularity and variability of distributed software architectures through multi-view refinement of AO-Connectors

This paper presents MView, a technique that enables the separation of various architect views on an architectural connector in distributed software systems. A distributed system faces a lot of variability in the functions that it needs to support, and the deployment environments in which it needs to execute. Modularity of functionality and composition is essential in achieving this variability. While state-of-the-art AO-ADLs focus on describing compositions using aspect-based connectors, there is no support for describing a connector across multiple architecture views. This is, however, essential for distributed systems, where run-time and distribution characteristics are represented in multiple views. This results in connectors that suffer from monolithic descriptions, in which the views of different architects are tangled. MView untangles these architect views by defining them in separate modules and specifying refinement relations between these modules. We have integrated MView in an ADL, called MView ADL, which is supported by an Eclipse-plugin that performs code generation to the JBoss and Spring middleware platforms. We evaluate MView in a content distribution system for e-Media. First is an assessment of the architect effort required for creating variations of that system, followed by an evaluation of the extent to which changes ripple through the architecture.