We are proud to announce our keynote speakers for Modularity'14:
(The University of Tokyo, Japan)
To be destructive or not to be, that is the question on modular extensions
Tuesday, April 22nd
14:00 - 15:00
Inheritance is a classic mechanism for extending an existing module. Since it preserves the original module, programmers can use both the original module and the extended one in the same program. So inheritance is a non-destructive mechanism. On the other hand, there are some extension mechanisms that directly modify an existing module and thus only the extended module is available in a program. These mechanisms such as aspects in AspectJ and revisers in our language GluonJ should be categorized into destructive mechanisms. Both destructive extension mechanisms and non-destructive ones are useful but in different scenarios.
This talk presents that the primary difference between destructive mechanisms and non-destructive ones is the scope of where the extensions are effective and visible in a program. Then this talk shows the third approach in the middle between the two extreme ones, destructive and non-destructive. The third approach allows programmers to control the scope of the extensions in a modular fashion. The talk presents a few language mechanisms of this approach, including our method shells, and also remaining issues in the contexts of feature-oriented programming.
About the Speaker
Shigeru Chiba is Professor at The University of Tokyo. Before starting his current position, he was Assistant, Associate, and later Full Professor at Tokyo Institute of Technology from 2001 to 2012. Before 2001, he was Assistant Professor at University of Tsukuba. He received his PhD in computer science in 1996 from the University of Tokyo. His research interests are in programming language design, in particular, of object-oriented and/or aspect-oriented programming languages. He is also interested in various kinds of system software including operating systems, distributed systems, and web application frameworks. He has been serving as a program committee member or organizer of a number of prestigious conferences and workshops. He is also a primary developer of Javassist, which is a Java bytecode engineering toolkit widely used in industry and academia.
(TU Delft, The Netherlands)
Separation of Concerns in Language Definition
Wednesday, April 23rd
9:00 - 10:00
Effectively applying linguistic abstraction to emerging domains of computation requires the ability to rapidly develop software languages. However, a software language is a complex software system in its own right and can take significant effort to design and implement. We are currently investigating a radical separation of concerns in language definition by designing high-level declarative meta-languages specialized to the various concerns of language definition that can be used as the single source of production quality (incremental) semantic operations and as a model for reasoning about language properties. In this talk I report about our progress in this direction by demonstrating language definition using the Spoofax Language Workbench.
About the Speaker
Eelco Visser is Antoni van Leeuwenhoek Professor of Computer Science at Delft University of Technology. He received a master's and doctorate in computer science from the University of Amsterdam in 1993 and 1997, respectively. Previously, he served as postdoc at the Oregon Graduate Institute, as Assistant Professor at Utrecht University, and as Associate Professor at TU Delft. In 2013 he received the prestigious NWO VICI grant for research into verification of language definitions. His research interests include software language engineering, domain-specific programming languages, model-driven engineering, program transformation, software deployment, and interaction design. With his students he has designed and implemented the Spoofax language workbench, as well as many domain-specific languages, including DSLs for syntax definition (SDF), program transformation (Stratego), software deployment (Nix), web application development (WebDSL), and mobile phone applications (mobl). He is the lead developer of the researchr bibliography management system and the WebLab learning management system.
(Oracle Labs, Austria)
Graal and Truffle: Modularity and Separation of Concerns as Cornerstones for Building a Multipurpose Runtime
Thursday, April 24th
9:00 - 10:00
We present a solution to this problem by providing guest languages with a new way of interfacing with the host runtime. The semantics of the guest language is communicated to the host runtime not via generating bytecodes, but via an interpreter written in the host language. This gives guest languages a simple way to express the semantics of their operations including language-specific mechanisms for collecting profiling feedback. The efficient machine code is derived from the interpreter via automatic partial evaluation. The main components reused from the underlying runtime are the compiler and the garbage collector. They are both agnostic to the executed guest languages.
The host compiler derives the optimized machine code for hot parts of the guest language application via partial evaluation of the guest language interpreter. The interpreter definition can guide the host compiler to generate deoptimization points, i.e., exits from the compiled code. This allows guest language operations to use speculations: An operation could for example speculate that the type of an incoming parameter is constant. Furthermore, the guest language interpreter can use global assumptions about the system state that are registered with the compiled code. Finally, part of the interpreter's code can be excluded from the partial evaluation and remain shared across the system. This is useful for avoiding code explosion and appropriate for infrequently executed paths of an operation. These basic mechanisms are provided by the underlying language-agnostic host runtime and allow separation of concerns between guest and host runtime.
Guest language objects are stored on the host heap and managed by the host garbage collector. Multiple executing languages can share the same heap. This enables language interoperability without marshaling at the language boundary, because the field value of one language can point to an object of another language. Reusing the allocation system of the host runtime is another major simplification for guest language runtimes.
About the Speaker
Thomas Würthinger is a Senior Research Manager at Oracle Labs. He is the lead of the Graal compiler OpenJDK project and the architect of the Truffle self-optimizing runtime system. Previously, he worked on the Crankshaft optimizing compiler of V8 at Google, and the Maxine research virtual machine at Sun Microsystems. He received his PhD degree from Johannes Kepler University Linz in Austria for his thesis about dynamic code evolution for Java.
Coccinelle: Reducing the Barriers to Modularization in a Large C Code Base
Friday, April 25th
9:00 - 10:00
Coccinelle is a program matching and transformation tool for C code that has been extensively used for bug finding and evolutions in the Linux kernel. In this talk, we show how Coccinelle can be used in maintaining and improving the modularity of software, taking as a case study the introduction of an API providing a form of managed resources into the Linux kernel.
About the Speaker
Julia Lawall is a Senior Researcher at Inria, and was previously an Associate Professor at the University of Copenhagen. Her research is at the intersection of programming languages, software engineering and operating systems. She has had over 1100 patches accepted into the Linux kernel based on tools developed in her research.