download flyer
CFP as [plain-text]
Picture by Bracani Antonio



Tue 16
Basic & Advanced topics
The organizers
Eric Bodden
Coffee break
Jacques Noyé
Mircea Lungu
Coffee break
Tom Dinkelaker

Analyzing Java Programs with Soot

Eric Bodden

Static program analysis can give information about many interesting program properties, such as which variables may point to the same objects, whether or not your program may leak sensitive information, or whether it may invoke certain sensitive functionality without acquiring proper authentication.

In this lecture we explain how to conduct static program analysis with Soot. Soot is one of the most widely used program analysis and transformation frameworks for Java. The tutorial will first provide an overview of the entire system, and then a more in depth look at the intermediate representations produced by Soot. Of particular interest is a typed, three-address representation (Jimple) that provides a good foundation for program analysis.

Based on the introductory material the lecture will then look at various applications of Soot including an overview of the intra-procedural analysis framework, an introduction to the pointer analysis framework, examples of using the framework to modify or instrument bytecode, and a discussion of how to encode flow analysis results in bytecode attributes.

We will also briefly discuss our novel effort to enable static whole-program analyses of programs that use reflection and custom class loaders. Such programs are hard to analyze statically because it is non-trivial to acquire the program’s code or to estimate the program’s calling structure.

Back to program

Concurrency in Scala

Jacques Noyé

Scala is one of today’s most interesting programming languages. It combines in a consistent and effective way object-oriented programming and functional programming. Thanks to an expressive type system with local type inference and clever syntax, it reconciles the conciseness of scripting languages and the robustness of statically-typed languages. Also, its object-oriented core and its interoperability with Java provides a smooth migration path for Java developers who can reuse Java code and knowledge.

In this talk, however, we are going to focus on yet another feature of Scala, concurrency (*). This may come as a surprise, but concurrency is not addressed in the Scala Language Specification. This is not because it is a side issue, Scala was designed with concurrency in mind, but because the extensibility of Scala makes it possible to deal with concurrency as a library. Looking at the implementation of concurrency is therefore a good way to get a feel for the various mechanisms that make Scala extensible. Beyond implementation, Scala also improves on concurrency in Java. Java was very successful in that it made concurrency accessible to a wide community. However, it stuck to a shared-memory model of concurrency. Scala is much more flexible: it integrates both a shared-memory model and a message-passing model of concurrency, better suited to a distributed context, through an extended actor model. We will explore this continuum starting from standard concurrency à la Java and consider, if time allows, another interesting extension, so far not part of the standard Scala offering: join patterns, inspired by the join calculus. Whereas monitors and actors date back to the seventies, the join calculus was developed in the nineties. It takes time to bring good ideas to the practioner. Extensible languages may help shorten the path.

(*) We will not assume familiarity with Scala, but familiarity with Java, and introduce the necessary Scala features along the talk.

Back to program

Reverse Engineering Software Ecosystems

Mircea Lungu

“No man is an island, entire of itself” (John Donne, XVI Century)

Reverse engineering is an active area of research, concerned with the development of techniques and tools that support the understanding of software systems. All the state of the art approaches in reverse engineering study software systems in isolation. However real systems are seldom developed in isolation; instead, they are developed together with other projects in the wider context of an organization or an open source community.

In this talk I will present my approach to ecosystem reverse engineering. The methodology that I will present is based on the static analysis of the source code and the evolutionary analysis of the information available in the versioning systems of the projects that make up a software ecosystem. Based on these analyses one can generate ecosystem viewpoints, which are graphical representations that capture complementary facets of an ecosystem. The viewpoints can present either social or project-centric aspects of an ecosystem. The social aspects focus on the community of developers that emerges around the projects and their collaboration relationships. The project-centric aspects focus on the projects that make up an ecosystem and their interactions and dependencies.

During the presentation I will also give a hands-on demo of a state of the art ecosystem analysis platform.

“No software project is an island” (Mircea Lungu, XXI Century)

Back to program

Groovy and Embedded Domain-Specific Languages

Embedding DSLs in a Reflective Language

Tom Dinkelaker

“I should not design a small language, and I should not design a large one. I need to design a language that can grow” (Guy L. Steele, in Growing a Language)

Traditionally, preprocessors are used to introduce domain-specific abstractions into general-purpose languages (GPLs). However, implementing preprocessors is labor intensive, since a sophisticated language processing infrastructure has to be built on top of the GPL.

There are a special DSL implementation approaches for embedded domain-specific languages(embedded DSLs). These heavily reduce the initial costs of implementing DSLs. Roughly speaking, embedded DSL are DSLs that are implemented as libraries in a GPL. Following this approach allows reusing the general-purpose features of the host language. The reuse of features implemented in the GPL significantly reduces the development costs of language features of the embedded DSL.

Embedded DSLs are said to be easier to implement, to extend, and to compose than DSLs that are implemented by preprocessors. However, conversely, existing approaches for embedded DSLs lack support for many features found traditional preprocessor-based approaches, such as, analyzing or transforming DSL programs, and supporting arbitrary domain syntax.

In this talk I will explain how to embed DSLs into Groovy – a reflective GPL that allows introspecting programs and manipulating them. First, I will introduce a selection of Groovy’s language features that support embedding. Then, I will present an architecture for embedding DSLs that makes use of reflective features of the GPL. The architecture helps language developers to design languages that can grow. The architecture uses reflective features to provide support for analysis and transformation of DSL programs, and support for arbitrary domain syntax

Back to program