Marko van Dooren

University of Leuven, Louvain, Flanders, Belgium

Are you Marko van Dooren?

Claim your profile

Publications (21)0.57 Total impact

  • Marko van Dooren, Bart Jacobs, Wouter Joosen
    [Show abstract] [Hide abstract]
    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.
    Science of Computer Programming 01/2014; 87:44–61. · 0.57 Impact Factor
  • [Show abstract] [Hide abstract]
    ABSTRACT: 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.
    Transactions on Aspect-Oriented Software Development X; 01/2013
  • Marko van Dooren, Dave Clarke
    [Show abstract] [Hide abstract]
    ABSTRACT: 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.
    Proceedings of the 14th international conference on Coordination Models and Languages; 06/2012
  • [Show abstract] [Hide abstract]
    ABSTRACT: 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.
    01/2012;
  • Source
    Marko van Dooren, Eric Steegmans, Wouter Joosen
    [Show abstract] [Hide abstract]
    ABSTRACT: 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.
    01/2012;
  • Source
    S. De Labey, M. van Dooren, E. Steegmans
    [Show abstract] [Hide abstract]
    ABSTRACT: Object-oriented programming languages are losing pace with the rapidly evolving Web Services paradigm. They are unable to deal with the distributed, volatile nature of web services, and they lack expressive language constructs for complex web service interactions. In this paper, we present ServiceJ, a Java extension with integrated support for web service programming. By extending the type system with type qualifiers, ServiceJ realizes important objectives from both paradigms. On one hand, ServiceJ resembles Java by promoting reuse and abstraction, and by supporting type- safe web service invocations. On the other hand, ServiceJ supports late web service binding, Quality of Service negotiation, and transparent web service failover. We provide an in-depth discussion of our type system extension, formally prove its type soundness, and compare our language extension with related object-oriented and service-oriented programming languages.
    Web Services, 2007. ICWS 2007. IEEE International Conference on; 08/2007
  • Source
    Koen Vanderkimpen, Marko van Dooren, Eric Steegmans
    [Show abstract] [Hide abstract]
    ABSTRACT: Many object-oriented programming languages use fields to represent object state. This representation however, cannot be altered sufficiently when subclassing. Moreover, in languages such as Java and C#, proper encapsulation of fields necessitates a lot of boilerplate code. In this paper, we introduce our concept of properties, which are far more flexible for use with inheritance and greatly reduce boilerplate code compared to C# properties. Using our properties makes it easier for programmers to model programs in a more consistent manner. Furthermore, our Properties allow redefining an object's attributes in ways that equal the possibilities for redefinition of virtual methods in many programming languages, which makes them better suited to deal with unanticipated reuse. Specifically, using our construct, it becomes possible to join several superclass attributes into only one at the subclass level, conjointly decreasing memory consumption.
    Comput. Sci. Inf. Syst. 01/2007; 4:27-46.
  • Source
    Marko van Dooren, Eric Steegmans
    [Show abstract] [Hide abstract]
    ABSTRACT: Although classes are a fundamental concept in object-oriented pro- gramming, a class itself cannot be built using general purpose classes as building blocks in a practical manner. High-level concepts like associations, bou nded val- ues, 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, comp onent param- eters, 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%.
    ECOOP 2007 - Object-Oriented Programming, 21st European Conference, Berlin, Germany, July 30 - August 3, 2007, Proceedings; 01/2007
  • Source
    Sven De Labey, Marko van Dooren, Eric Steegmans
    [Show abstract] [Hide abstract]
    ABSTRACT: While object-oriented programming languages such as Java and C# deliver the main mechanism for implementing enterprise sys- tems, these languages have not kept pace with the rapidly evolving tech- nology of Service-Oriented Computing. The main reason is their insu- cient support for dealing with service volatility and service distribution. In this paper, we present ServiceJ, an extension of Java with built-in support for Service-Oriented Computing. ServiceJ bridges the gap be- tween Service-Oriented Computing and Object-Oriented Programming Languages in two ways. First, it captures the volatile nature of services by supporting dynamic service selection and binding. Second, it adequately deals with distribution problems by oering a transparent failover mech- anism that can be congured using declarative language constructs. We present a formal service language, Featherweight ServiceJ, in which the soundness of ServiceJ and its future extensions can easily be proven. Still, SOAs impose a number of challenges on the developers of service ap- plications. These challenges originate from the inherent volatility and the dis- tributed nature of remote services. Being volatile, service applications must cope with newly joining services, service migration, incompatible service updates and the removal of old services. Being distributed, applications must deal with avail- ability problems resulting from network errors or server outages. Based on object-oriented programming languages, platforms such as Java En- terprise Edition 5.0 (2) and .Net 3.0 (3), deliver the main platforms for implement- ing enterprise systems. But their current programming models are not suited for the implementation of SOA applications as they fail to provide language support for handling the distribution and volatility issues mentioned above. In this paper, we present ServiceJ, an extension of Java with built-in sup- port for Service-Oriented Computing. ServiceJ improves other object-oriented
    01/2006;
  • Source
    Marko van Dooren, Eric Steegmans
    [Show abstract] [Hide abstract]
    ABSTRACT: 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.
    Companion to the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2005, October 16-20, 2005, San Diego, CA, USA; 01/2005
  • Source
    Marko van Dooren, Eric Steegmans
    [Show abstract] [Hide abstract]
    ABSTRACT: 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.
    Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2005, October 16-20, 2005, San Diego, CA, USA; 01/2005
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Since the mid 1970s, software testing has been dominated by two major paradigms, known as black box testing and white box testing. Strategies for black box testing are based on the specification of the software component under test. Test suites developed using the black box paradigm reveal errors against the functional requirements of software components. Strategies for white box testing are based on the internals of software components. White box test suites are derived from the source code of the software component under test. Because programs can be represented in terms of graphs, solid coverage criteria can be defined for white box testing strategies. In this pa- per, we start with a brief overview of the principles underlying black box testing and white box testing. Hereafter, we propose a process for testing software components in which both paradigms are used at appropriate points in the software life cycle. We also touch upon the applicability of both paradigms in testing object-oriented programs.
    01/2004;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Object-oriented programming languages deliver the main technology for im-plementing enterprise systems, but they are losing pace with the rapidly evolv-ing paradigm of Service-Oriented Computing. This is mainly due to inade-quate support for dealing with service volatility and distribution issues. In this paper, we focus on the growing distance between Java and Service Ori-ented Computing. First, we discuss the disadvantages of the current Java programming model in the context of developing SOA applications. Then, we provide a basis for bridging the gap between both programming paradigms.
  • Source
    Jan Dockx, Marko van Dooren, Eric Steegmans
    [Show abstract] [Hide abstract]
    ABSTRACT: One of the main goals of structured programming is to make it possible for programmers to reason about and prove the correctness of programs. The assertions that describe the algorithm make explicit the complexity of the code. Encapsulation and inheritance remove an important part of that complexity in object-oriented programming. This paper shows that the reduction in com- plexity we get by replacing iteration structures by internal iterators is so big that it brings us very close to zero-defect software becoming viable.
  • Source
    Marko van Dooren, Wouter Joosen
    [Show abstract] [Hide abstract]
    ABSTRACT: First-class composition inheritance is a significant improvement over other inheritance techniques with respect to reuse. It allows a class to be used as a component to build other classes, enabling a new kind of reuse. Frequently used characteristics and collaborations, such as bounded values and associations, can be encapsulated in classes and reused conveniently to build other classes. In this paper, we present the O2 calculus, which supports first- class composition inheritance. It models multiple subclassing inher- itance, first-class composition inheritance, renaming and merging, direct and indirect inheritance, subobject references, and compo- nent parameters. Our approach diers from existing calculi in that O2 is parametric in its inheritance mechanism. We define a signature for the inheritance mechanism that captures its required functions and axioms. The type soundness proof must not be reverified if the inheritance mechanism is modified or replaced, as long as it imple- ments the inheritance signature.
  • Source
    Marko van Dooren, Wouter Joosen
    [Show abstract] [Hide abstract]
    ABSTRACT: Checked exceptions improve the robustness of software, but de- crease its adaptability because they must be propagated explicitly, and because they must often be handled even if they cannot be sig- nalled. Anchored exception declarations solve these problems by allowing a method to declare its exceptional behavior in terms of other methods. The original type checking algorithms for anchored exception declarations, however, are not modular. In this paper, we present algorithms that allow complete, modular, and decidable veri?cation of exception safety in a language without parametric polymorphism. In addition, we show that both complete exception ?ow analysis and complete exception safety analysis based on type information are undecidable in a language with subtyping and parametric polymor- phism.
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Many object-oriented programming languages use fields to represent object state. But subclasses cannot alter the representation of an object sufficiently. Because of that, a number of subclassing prob-lems are difficult or impossible to deal with if the superclasses were not designed to anticipate them, especially under multiple inheritance. More-over, in languages such as Java and C#, encapsulation necessitates a lot of boilerplate code. In this paper, we improve the C# concept of properties, making them more flexible for use with inheritance and reducing their boilerplate code. Using our properties makes it easier for programmers to model programs in a more consistent manner. Furthermore, our Properties allow redefin-ing an object's attributes in ways that equal the possibilities for redefi-nition of virtual methods in many programming languages, which makes them better suited to deal with unanticipated reuse. Specifically, using our construct, it becomes possible to join several superclass attributes into only one at the subclass level, conjointly decreasing memory con-sumption.
  • Marko van Dooren
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: JML, which stands for "Java Modeling Language", is a behavi- oral interface specication language designed to specify Java classes and interfaces. JML uses syntactic sugar to make specications easier to read and write. In this paper, we reveal that the current JML desugaring of signals clauses has a somewhat counterintuit- ive meaning. A new semantics is proposed that is more intuitive. Special attention is given to the desugaring of signals clauses that are spread over dieren t behavior blocks connected by the keywords also or and. The described desugaring ensures behavioral subtyp- ing. The consequences of the new semantics are worked out.
  • Source
    Jan Dockx, Marko van Dooren, Eric Steegmans
    [Show abstract] [Hide abstract]
    ABSTRACT: In this technical report, we prove the correctness of difierent implementations of a given speciflcation. This way, we show that using internal iterators dramatically shortens the length of a proof of correctness, and thus the complexity of the code. A remarkable outcome is that introducing a helper method no longer shortens the proof when internal iterators are used, but makes it longer.