At last year's GPCE conference in Eindhoven I met Klaus Ostermann and Sebastian Erdweg who turned out to be working with Stratego/XT on the exciting SugarJ project. SugarJ turns MetaBorg into a homogeneous language extension mechanism, enabling the definition of language extensions in libraries that are invoked on import.

The meeting led to a demo, more talk on the walk to the banquet, a visit by Sebastian to TU Delft, collaboration with Lennart Kats on the integration of SugarJ and Spoofax to provide editor support for language extensions, and now a paper at GPCE 2011:

Sebastian Erdweg, Lennart C. L. Kats, Tillmann Rendel, Christian Kastner,  Klaus Ostermann, Eelco Visser. Growing a Language Environment with Editor Libraries. In Ewen Denney, Ulrik Pagh Schultz, editors, Generative Programming and Component Engineering, 7th International Conference, GPCE 2011, Portland, OR, USA, October 22-23, 2011, Proceedings. ACM, 2011.

Abstract Large software projects consist of code written in a multitude of different (possibly domain-specific) languages, which are often deeply interspersed even in single files. While many proposals exist on how to integrate languages semantically and syntactically, the question of how to support this scenario in integrated development environments (IDEs) remains open: How can standard IDE services, such as syntax highlighting, outlining, or reference resolving, be provided in an extensible and compositional way, such that an open mix of languages is supported in a single file? Based on our library-based syntactic extension language for Java, SugarJ, we propose to make IDEs extensible by organizing editor services in editor libraries. Editor libraries are libraries written in the object language, SugarJ, and hence activated and composed through regular import statements on a file-by-file basis. We have implemented an IDE for editor libraries on top of SugarJ and the Eclipse-based Spoofax language workbench. We have validated editor libraries by evolving this IDE into a fully-fledged and schema-aware XML editor as well as an extensible LATEX editor, which we used for writing this paper.

Last year, TU Delft Master's student Ricky Lindeman started working on a debugger for Stratego in Eclipse/Spoofax. Later he generalized the framework so that Spoofax can provide support for building debuggers for domain-specific languages. Today we learned that the paper we submitted to GPCE 2011 has been accepted.

Ricky T. Lindeman, Lennart C. L. Kats, Eelco Visser. Declaratively Defining Domain-Specific Language Debuggers. In Ewen Denney, Ulrik Pagh Schultz, editors, Generative Programming and Component Engineering, 7th International Conference, GPCE 2011, Portland, OR, USA, October 22-23, 2011, Proceedings. ACM, 2011.

Abstract Tool support is vital to the effectiveness of domain-specific languages. With language workbenches, domain-specific languages and their tool support can be generated from a combined, high-level specification. This paper shows how such a specification can be extended to describe a debugger for a language. To realize this, we introduce a meta-language for coordinating the debugger that abstracts over the complexity of writing a debugger by hand. We describe the implementation of a language-parametric infrastructure for debuggers that can be instantiated based on this specification. The approach is implemented in the Spoofax language workbench and validated through realistic case studies with the Stratego transformation language and the WebDSL web programming language.

Last year at SPLASH 2010 in Reno a group of programming language designers from academia and industry came together to discuss the creation of group to provide a forum for discussing language design at a much earlier stage than our conferences allow. Earlier this month we held our inaugural meeting hosted by Google in Mountain View with a great collection of language designers.

Today Jonathan Edwards and I (as secretary and chair, respectively, of the group) presented to the IFIP TC2 committee meeting at ETH in Zurich the proposal for the formation of a Working Group on Programming Language Design to join the existing TC2 working groups.

We are happy to report that the committee approved the formation of the working group

Quoting from the proposal:

Aim: To explore and evaluate new ideas in programming language design. Our stance is that programming languages are foremost a medium for expressing the structure and intention of software, and communicating these to other programmers. As such human factors must weigh heavily in language design decisions, requiring a well-judged balance between conflicting goals that are qualitative in nature.

Scope:

• exploring programming paradigms and major language features, both established and novel;
• co-designing programming environments with such language features;
• articulating more clearly the problems of programming that language features are designed to address;
• identifying key design decisions that balance conflicting goals such as usability, expressivity, and the ability to provide tool support
• combining experiences and perspectives from the full spectrum of language paradigms and communities;
• conversing at a conceptual level that practicing language designers find useful, not restricted to mathematical formalisms or empirical hypotheses;
• meta-discussion of techniques for evaluating language design decisions;
• promulgating the appreciation of design considerations among researchers, practitioners, students, and teachers.

Yesterday I extended the modest collection of lenses for my DSLR. I'm still sporting an almost five year old Canon EOS 30D, but getting better lenses has had higher priority than upgrading the body. Lenses tend to be a better investment and add more to the quality of a photo. My first lens was the 17-85mm zoom lens that came with the 30D. With its maximal aperture of 4 it turned out to be suboptimal for the natural light photography that I tend to practice. I replaced the lens with a prime 50mm (F1.4) and a prime 28mm (F1.8). Both very sharp and fast lenses, ideal for portraits and landscapes. I like the large apertures not just for their speed but also for its small depth of field. For the purpose of photographing conferences I extended the collection with a 70-200mm (F2.8) telelens. I have been using this collection for the past three years with occasional good results. But the combination is quite heavy and changing lenses annoying. In particular, for the upcoming mountain vacation, the weight and backpack space occupied was determined too much; only one lens was to be part of the gear.

After some deliberation I chose to purchase the 24-70mm F2.8 zoom lens. It approximates the aperture of the prime lenses and is very sharp for a zoom lens according to reports. Today I took the lens for a test run and I am not disappointed.

This paper presents the mobl language for programming client-side applications that run in a HTML5 capable browser in a smartphone.

Zef Hemel, Eelco Visser. Declaratively Programming the Mobile Web with Mobl. In Proceedings of the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2011. ACM, Portland, Oregon, USA, 2011.

Abstract A new generation of mobile touch devices, such as the iPhone, Android and iPad, are equipped with powerful, modern browsers. However, regular websites are not optimized for the specific features and constraints of these devices, such as limited screen estate, unreliable Internet access, touch-based interaction patterns, and features such as GPS. While recent advances in web technology enable web developers to build web applications that take advantage of the unique properties of mobile devices, developing such applications exposes a number of problems, specifically: developers are required to use many loosely coupled languages with limited tool support and application code is often verbose and imperative. We introduce mobl, a new language designed to declaratively construct mobile web applications. Mobl integrates languages for user interface design, styling, data modeling, querying and application logic into a single, unified language that is flexible, expressive, enables early detection of errors, and has good IDE support.