[Jot-newsletter] JOT Volume 11, no 1 is now online

Journal of Object Technology editor at jot.fm
Thu Apr 26 10:43:09 CEST 2012

Subject: [JOT] JOT Subscriber Newsletter Volume 11, no. 1 (April 2012)


For Volume 11, no. 1 (April 2012)


The JOT Format.
By Oscar Nierstrasz

With this issue, JOT is reverting to a format with multiple issues throughout the year, however we will continue to publish new material as soon as possible.



Keyword- and Default- Parameters in JAVA.
By Joseph (Yossi) Gil, Keren Lenza

Overloading is a highly controversial programming language mechanism by which different methods of
the same class are allowed to bear the same name. Despite the criticism, Java programmers make
extensive use of this mechanism---not just because it is available, but also because the language
does not provide an alternative for defining multiple constructors, and because it is useful for
expressing similarity of services provided by a class. In a previous paper we argued that more
than 60% of the overloading cases are "justifiable" and that in 35% of the cases overloading
is used for emulating a default arguments mechanism. Based on these results, this paper argues
that most "justifiable" uses of overloading are better done with a combination of keyword
parameters and default parameters parameter definition mechanisms, and describes our extension of
the Java compiler which adds these two features to the language.



European Research Project Symposium at ECOOP 2011.
By Steffen Zschaler

The European Conference on Object Oriented Programming (ECOOP) was held in Lancaster, 25-29 July. This year, the conference featured the novelty of a Research Project Symposium, providing an opportunity for the dissemination of integrated project visions as well as discussions aiming to seed new collaborations and future research projects. With half-day sessions from three current European research projects, the symposium provided an interesting overview of European ICT research ranging from applications to the design of large-scale machine-translation systems and marine information systems to foundational research in the specification and verification of adaptable systems.



TOOLS Europe 2011 Special Section.
By Antonio Vallecillo, Judith Bishop

Now that object technology is mainstream, it can be studied in
combination with other technologies devoted to achieving high quality
software. This Special Section presents aspects of object
technology and related fields, in particular model-based development,
component-based development, language implementation and patterns, in
a holistic way. The papers have a strong practical bias, without
losing sight of the importance of correctness and performance. The
Section presents seven selected and extended papers from the
49th International Conference on Objects, Models, Components
and Patterns (TOOLS Europe 2011 http://toolseurope2011.lcc.uma.es/)
held on June 28--30, 2011 at the Swiss Federal Institute of Technology
(ETH) in Zurich, Switzerland, organized by the Chair of Software



Lifted Java: A Minimal Calculus for Translation Polymorphism.
By Matthias Diehn Ingesman, Erik Ernst

To support roles and similar notions involving multiple views on an
object, languages like Object Teams and CaesarJ include mechanisms
known as lifting and lowering.  These mechanisms connect pairs of
objects of otherwise unrelated types, and enable programmers to
consider such a pair almost as a single object which has both types.
In the terminology of Object Teams this is called translation
polymorphism.  In both Object Teams and CaesarJ the type system of
the Java programming language has been extended to support this
through the use of advanced language features.  The type soundness
of translation polymorphism has so far only been proven in a simple
special case.
This paper presents a simple model that extends Featherweight Java
with a general semantics that captures the core operations of
translation polymorphism, providing an entire language design
space for languages with translation polymorphism.  Type soundness
is proven for every language in this language design space, and
mechanization of the proof in Coq shows that the proof is accurate
and complete.


Seuss: Decoupling responsibilities from static methods for fine-grained configurability.
By Niko Schwarz, Mircea Lungu, Oscar Nierstrasz

Unit testing is often made more difficult by the heavy use of classes as namespaces and the proliferation of static methods to encapsulate configuration code.
We have analyzed the use of 120 static methods from 96 projects
by categorizing them according to their responsibilities.
We find that most static methods support a hodgepodge of mixed responsibilities, held together only by their common need to be globally visible. Tight coupling between instances and their classes breaks encapsulation, and, together with the global visibility of static methods, complicates testing. 
By making dependency injection a feature of the programming language, we can get rid of static methods altogether. We employ the following semantic changes: (1) Replace every occurrence of a global with an access to an instance variable; (2) Let that instance variable be automatically injected into the object when it is instantiated. We present Seuss, a prototype that implements this change of semantics in Smalltalk.
We show how Seuss
eliminates the need to use class  methods for non-reflective purposes,
reduces the need for creational design patterns such as Abstract Factory
simplifies configuration code, particularly for unit tests.
We present benchmarks showing that Seuss introduces a 34% additional memory cost, and runs at 53% speed, without any optimizations.


Efficient Retrieval and Ranking of Undesired Package Cycles in Large Software Systems.
By Jannik Laval, Jean-Rémy Falleri, Philippe Vismara, Stéphane Ducasse

Many design guidelines state that a software system architecture should avoid cycles between its packages. Yet such cycles appear again and again in many programs. We believe that the existing approaches for cycle detection are too coarse to assist  developers to remove cycles from their programs. In this paper, we describe an efficient algorithm that performs a fine-grained analysis of cycles among application packages. In addition, we define multiple metrics to rank cycles by their level of undesirability, prioritizing cycles that are the more undesired by developers. 
We compare these multiple ranking metrics on four large and mature software systems in Java and Smalltalk.


Modeling Domain-Specific Profilers.
By Jorge Ressia, Alexandre Bergel, Oscar Nierstrasz, Lukas Renggli

Domain-specific languages and models are increasingly used within general-purpose host languages. While traditional profiling tools perform well on host language code itself, they often fail to provide meaningful results if the developers start to build and use abstractions on top of the host language. In this paper we motivate the need for dedicated profiling tools with three different case studies. Furthermore, we present an infrastructure that enables developers to quickly prototype new profilers for their domain-specific languages and models.


JSConTest: Contract-Driven Testing and Path Effect Inference for JavaScript.
By Phillip Heidegger, Peter Thiemann

Program understanding is a major obstacle during program
maintenance. In an object-oriented
language, understanding an operation requires understanding its type
and its effect on the object network. The effect is particularly important
for scripting languages where there is neither class structure that 
restricts the shape of an object nor any other kind of access control. 
We have designed and implemented JSConTest, a tool that provides
a facility to annotate JavaScript programs with 
type and effect contracts and to create random tests out of the
contracts. Run-time monitoring for contracts is 
implemented with a program transformation.
The effect of an operation is described by access permissions, which
abstract sets of access paths along which the operation reads or writes object
properties. Type contracts can also be used to drive guided random
testing of the program.
JSConTest contains an algorithm for computing access permissions from
a set of access paths obtained by running the program.
The main ingredient of the algorithm is a novel heuristic that
produces precise and concise results without user interaction.
It has been applied to a range of examples with encouraging results.


An In-Depth Look at ALIA4J.
By Christoph Bockisch, Andreas Sewe, Haihan Yin, Mira Mezini, Mehmet Aksit

New programming languages supporting advanced modularization mechanisms are often implemented as transformations to the imperative intermediate representation of an already established language.
But while their core constructs largely overlap in semantics, re-using the corresponding transformations requires re-using their syntax as well; this is limiting.
In the ALIA4J approach, we identified dispatching as fundamental to most modularization mechanisms and provide a meta-model of dispatching as a rich, extensible intermediate language.
Based on this meta-model, one can modularly implement the semantics of dispatching-related constructs.
From said constructs a single execution model can then be derived which facilitates interpretation, bytecode generation, and even optimized machine-code generation.
We show the suitability of our approach by mapping five popular languages to this meta-model and find that most of their constructs are shared across multiple languages.
We furthermore present implementations of the three different execution strategies together with a generic visual debugger available to any ALIA4J-based language implementation.
Intertwined with this paper is a tutorial-style running example that illustrates our approach.


EMF Profiles: A Lightweight Extension Approach for EMF Models.
By Philip Langer, Konrad Wieland, Manuel Wimmer, Jordi Cabot

Domain-Specific Modeling Languages (DSMLs) are getting more and more attention as a key element of Model Driven Engineering. As any other software artifact, DSMLs should continuously evolve to adapt to the changing needs of the domain they represent. Unfortunately, right now evolution of DSMLs is a costly process that requires changing the DSML metamodel and re-creating the complete modeling environment.
In this paper we advocate for the use of EMF Profiles, an adaptation of the UML Profile concept to DSMLs. Profiles have been a key enabler for the success of UML by providing a lightweight language-inherent extension mechanism which is expressive enough to cover an important subset of extension scenarios. We believe a similar concept for DSMLs would provide a valuable extension mechanism which has been so far neglected by current metamodeling tools. Apart from direct metamodel profiles, we also propose reusable profile definition mechanisms whereby profiles are defined independently of any DSML and, later on, coupled with all DSMLs that can benefit from these profiles. Our approach has been implemented in a prototype integrated in the EMF environment.


About JOT

The Journal of Object Technology (JOT) is a peer-reviewed, open-access journal dedicated to the timely publication of previously unpublished research articles, surveys, tutorials, and technical notes on all aspects of object technology.

JOT is available online at http://www.jot.fm and is free to both readers and authors, with no registration required.

The JOT newsletter is sent with the publication of selected JOT issues and is available by subscription to the JOT reader and author community. The subscription form may be found on the JOT Web site. Subscribing requires no personal information or fee, only your email address. We use such addresses for the sole purpose of distributing the JOT newsletter and do not communicate them to third parties.
You are receiving this newsletter because you have subscribed to
	jot-newsletter at jot.fm
To unsubscribe, please use the mailman interface:

More information about the jot-newsletter mailing list