Briefings

Format

At GTTSE 2015, a briefing is a combination of surveying and tutorial.

Lectures at the school

At the school, the briefings are delivered as lectures: approx. 3 hours each subdivided into 2-3 lecture slots, possibly distributed over several days. Each briefing may be of a different format. For instance, one briefing may involve with the audience through assignments, whereas another briefing may stick more to the classic lecture format.

Papers for the briefings

A draft paper will be available at the time of the school.

The final papers meet the following specification:

  • 15-25 pages for main content.
    • About 50 % dedicated to related work analysis.
    • About 50 % dedicated to author's research or a research vision.
  • 2-5 extra pages for bibliography (references).
  • Up to 10 extra pages for technicalities in an appendix.
  • LNCS style applies.

List of briefings

Details

Matthew Dwyer (University of Nebraska, USA)

matthew-dwyer.jpg

Title: Probabilistic program analysis

Abstract: A variety of static analysis techniques have been developed over the years that can be applied to software systems, e.g., data flow analysis, symbolic execution, and predicate-abstraction based model checking. These techniques have been used primarily to compute "binary outcomes" in the form of invariant sets or property verification or falsification results. We discuss the motivations for and efforts to shift analyses from computing, often one-sided, binary outcomes to instead quantify the probability with which specific analysis results hold. More specifically we will provide an overview of the use of probabilistic techniques to adapt data flow analysis, model checking, and symbolic execution of software systems.

We will focus in detail on recent work that uses statistical sampling and model counting to scale probabilistic symbolic execution.

Collaborators: Matthew Dwyer, Mitch Gerrard, Corina Pasareanu, Antonio Filieri, Willem Visser, Jaco Geldenhuys

Bio: Matthew B. Dwyer is the Lovell Professor in the Department of Computer Science and Engineering at the University of Nebraska-Lincoln . From 1985 through 1990 he developed compilers for embedded systems and obtained his PhD in 1995 from UMass-Amherst. He has published widely in the areas of program analysis, software specification, and automated formal methods. In recent years, with several colleagues, he has begun to explore how to incorporate techniques from probability and statistics into symbolic execution to quantify non-exhaustive analysis results.

Material: TBA

Cesar Gonzalez-Perez (Spanish National Research Council (CSIC), Spain)

cesar-gonzalez-perez.jpg

Title: How ontologies can help in software engineering

Abstract: Ontologies are often understood as having a historical background quite different to software engineering, which has caused a number of issues when trying to use them in this context. However, recent works have characterised ontologies as being very close to models and metamodels, thus allowing for an inclusive treatment and use. In this talk, I will describe how ontologies are understood today within software engineering, how they relate to models and metamodels, and how they are useful to software and systems engineering over different lifecycle phases, in different domains, and in relation to standards such as those from ISO/IEC JTC1 SC7.

This work has had the input of Prof. Brian Henderson-Sellers, University of Technology Sydney.

Bio: Cesar Gonzalez-Perez is a Staff Scientist with the Institute of Heritage Sciences (Incipit),Spanish National Research Council (CSIC), where he leads a co-research line on semantic technologies and cultural heritage. Cesar’s major interests are conceptual modelling, metamodelling and situational method engineering. Cesar is also a Visiting Fellow at the University of Technology Sydney, and has worked at a number of academic and industry organisations in Spain and Australia; he is active in the standards world, has started 3 technology-based companies, and is the author or co-author of over 100 publications.

Material: TBA

Stefan Hanenberg (University of Duisburg-Essen, Germany)

stefan-hanenberg.jpg

Title: Empirical Evaluation of Programming and Programming Language Constructs

Abstract: In the recent past, more and more people became interested in empirical research - especially in the area of programming languages it is a relatively new trend. Despite of this interest, still only few people apply empirical methods in order to evaluate programming and programming language constructs.This talk gives an overview of different empirical methods to evaluate programming and programming language constructs with the main focus on quantitative methods. In addition to an introduction to the very foundations, this talk gives a number of examples where, how and why these methods have been applied. After this listening to this talk, students should be able to understand the foundation of empirical methods and should be able to run first basid experiments on their own.

Bio: Stefan Hanenberg received his PhD from the University of Duisburg-Essen and works for the same institute as senior lecturer. His main research topic is the empirical evaluation of type systems based on controlled experiments. His works on that topic were published at different venues such as AOSD, ECOOP, OOPSLA, and ICSE. Stefan's main critique of nowadays research in the field of programming and programming languages is that hardly any documented empirical knowledge exists. Consequently, it is hard to determine which of the tools and languages that are applied nowadays actually improve the discipline — or even achieve the opposite.

Material: TBA

Frédéric Jouault (ESEO Institute of Science and Technology, France)

frederic-jouault.jpg

Title: Model Synchronization

Abstract: Model engineering heavily relies on model transformation to automatically process models. Complex software engineering tools and processes are now based on model transformation. Initially, most works tackled the issue of generating target models from source models.

However, recomputing whole target models for each source model change is often not an option any more. Moreover, it is sometimes not possible to give models unambiguous source and target roles with respect to a given transformation.

Therefore, transformations now need to be able to synchronize sets of models. We will first look at different model synchronization approaches, along with their properties. Then, we will focus on a specific approach based on active operations.

Collaborators: Olivier Beaudoux, Mickaël Clavreul

Bio: Frédéric is a research associate at ESEO, France. He received his PhD from the University of Nantes before doing a postdoc at the University of Alabama at Birmingham. His research interests involve model engineering, model transformation, as well as their application to Domain-Specific Languages (DSLs) and model-based legacy reverse engineering. Frédéric created ATL, a DSL for model-to-model transformation. He is now leading the development of ATL (language and toolkit) on Eclipse.org. He is in charge of the Eclipse modeling M2M project as well as a member of the modeling PMC.

Material: TBA

Julia Rubin (MIT, USA)

julia-rubin.jpg

Title: To merge or not to merge: managing software product families

Abstract: Developing high-quality software is a challenging task. It is even more challenging for organizations that simultaneously maintain families of similar, yet non-identical, software products that target different customers or market segments. In the last two decades, numerous Software Product Line Engineering approaches have been proposed for developing families of software products in an efficient manner. Yet, these approaches are rarely used in practice. In this talk, we will look at some reasons for this lack of adoption. We will then describe an approach for developing high-quality software families in a “bottom-up” manner, by analyzing and transforming existing artifacts.

Collaborators: Prof. Marsha Chechik and/or Prof. Krzysztof Czarnecki (for parts of the work)

Bio: Julia is a Postdoctoral Researches at the EECS department in MIT. Before that, she spent more than 12 years as a Research Staff Member and, part of that time, as a manager in IBM Research, Israel. Julia holds a PhD from the University of Toronto. Her research spans a wide range of software engineering areas, including functionality-based development (functionality restriction, transfer and repair), software reuse, multi-platform development, software security and data privacy. She serves on the PC of several major conferences, such as RE, FASE, SPLC and MODELS, and was a PC co-chair for SPLC and ECMFA earlier.

Material: TBA

Leif Singer (University of Victoria, Canada)

leif-singer.jpg

Title: People Analytics in Software Development

Abstract: Developers are using more and more different channels and tools to collaborate, and integrations between these tools are becoming more prevalent. In turn, more data about developers' interactions at work will become available. These developments will likely make People Analytics — using data to show and improve how people collaborate — more accessible and in turn more important for software developers. Even though developer collaboration has been the focus of several research groups and studies, we believe these changes will qualitatively change how some developers work. We provide an introduction to existing work in this field and outline where it could be headed.

Contributors: Margaret-Anne Storey (University of Victoria, Canada); Fernando Figueira Filho (Universidade Federal do Rio Grande do Norte, Natal, Brazil); Alexey Zagalsky (University of Victoria, Canada); Daniel M. German (University of Victoria, Canada)

Bio: Leif is a researcher and consultant based in Hannover, Germany. He got his PhD in computer science from the University of Hannover and is an Affiliate Researcher with the University of Victoria in Canada. At the New York-based startup iDoneThis.com, he currently uses both qualitative and quantitative research to steer and support product development for a collaboration tool used by companies such as Twitter, Airbnb, and Heroku.

Material: TBA

Ulrik Pagh Schultz (University of Southern Denmark, Denmark)

ulrik-pagh-schultz.jpg

Title: DSLs in Robotics: A Case Study in Programming Self-reconfigurable Robots

Abstract: Robotic systems blend hardware and software in a holistic way that raises many crosscutting concerns (concurrency, time constraints, …), for which reason general-purpose languages often lead to a poor fit between language features and implementation requirements. This briefing provides an overview of how Domain-Specific Languages (DSLs) are systematically used to overcome this problem, enabling the programmer to quickly and precisely solve complex problems within the robotics domain. The main topic of the briefing is a detailed case study of DSLs for self-reconfigurable (i.e., self-rebuilding) robots, including an analysis of the language design process.

Collaborators: Mirko Bordignon, David Christensen, Nico Hochgeschwender, Arne Nordmann, Kasper Stoy, Sebastian Wrede

Bio: Ulrik Pagh Schultz received his PhD from the University of Rennes 1, did research in program transformation and related topics for a few years, and now mainly does research in robotics at the University of Southern Denmark, where he is employed as an associate professor. His goal is to ease the pain of programming robots by using domain-specific languages and program generation techniques in general.

Material: TBA

Yannis Smaragdakis (University of Athens, Greece)

yannis-smaragdakis.jpg

Title: Structured Program Generation Techniques

Abstract: So, you can write a program that generates other programs. Sorry, … not impressed.
You want to impress me? Make sure your program-generating program only produces well-formed programs. What is "well-formed", you ask? Well, let's start with "it parses". Then let's get to "…and type-checks". You want to really impress me? Give me an expressive language for program generators in which any program you write will only generate well-formed programs.

In this briefing we will survey the state-of-the-art in program generation relative to the above goal. The importance of this goal is hard to overstate. If we want to establish program generation as a general-purpose, disciplined methodology instead of an ad hoc hack, we should be able to check the generator once and immediately validate the well-formedness of anything it might generate.

Some of the emphasis will be on my own work on "class morphing" (or just "morphing"): the statically-safe change of contents of a class, depending on other classes supplied as parameters. But, along the way, lots of other techniques will be discussed and contrasted, from different template facilities, to syntactically-safe program generation, to program staging techniques.

Collaborators: Aggelos Biboudis, George Fourtounis

Bio: Yannis Smaragdakis is an Associate Professor at the University of Athens. His interests include program analysis and testing (especially pointer analysis, static-dynamic analysis combinations, and invariant inference); declarative and extensible languages (especially program generators, generics/templates, and applications of the Datalog language); and languages and tools for systems (especially multi-threading, parallel and distributed computing, and program locality). He got his B.Sc. degree from the University of Crete (Greece) in 1993. His Ph.D. dissertation, from the University of Texas at Austin in 1999, introduced the concept of "mixin layers". His FC++ project for functional programming in C++ has influenced and has been partly integrated in the Boost C++ libraries, and he continues to maintain strong ties to industrial development and open-source projects. He is a recipient of an NSF Career award, an ERC Starting/Consolidator grant, and "best paper" awards at ISSTA'12, ASE'07, ISSTA'06, GPCE'04, and USENIX'99. He is currently serving as Program Chair of OOPSLA'16, Associate Editor of ACM TOSEM, and PC member of ICSE'15, OOPSLA'15. More information on his work can be found at:http://smaragd.org .

Material: TBA

Friedrich Steimann (FernUniversität in Hagen, Germany)

friedrich-steimann.jpg

Title: Refactoring and beyond

Abstract: Refactoring is the process of changing an artefact (usually a program) in such a way that its design changes (usually improves with respect to some specific goal), while its observable behaviour is maintained. Trivially, the latter includes the maintenance of the artefact’s well-formedness, since arguably, an ill-formed artefact has no behaviour to be maintained.

While the problem of refactoring is easily stated, casting it into fully functional refactoring tools for today’s programming languages is surprisingly hard. In fact, most refactoring tools in use today cannot even guarantee to preserve well-formedness, let alone behaviour, not even for some of the most basic refactorings (such as Rename or Pull Up Member).

In this briefing, I will report on some of the most promising techniques for implementing correct refactoring tools. Common to these techniques is that they give up the notion of behaviour preservation in favour of the more basic (and less demanding) notion of dependency preservation: to be correct, a refactoring tool must not change the binding of names, the overriding of methods, the dependence on a monitor, etc. (unless of course changing any of these is an explicit goal of the refactoring). Preservation of well-formedness is then the maintenance of dependencies used in defining well-formedness.

With dependency preservation as the basic refactoring invariant, it is straightforward to extend the notion of refactoring to other controlled changes of programs, including changes that (deliberately) change behaviour, while maintaining desired non-functional properties of an artefact (which, arguably, always include well-formedness, but may be extended to cover security and other interesting properties).

Collaborators: Andreas Thies, Jens von Pilgrim, Max Schäfer, Frank Tip

Bio: Friedrich Steimann studied Informatics at the Technical University of Karlsruhe (today known as the K.I.T.), specializing in Technical Informatics and Medical Informatics. His thesis was on parsing Latin sentences using dependency unification grammar enhanced with order-sorted feature types. After a year in industrial research on object-oriented analysis and design methods (at Alcatel Austria Research Center in Vienna, Austria), he remorsefully returned to academia, pursuing a PhD in Medical Informatics at the Technical University of Vienna. He habilitated (on software modelling with roles) at the University of Hannover, and is today a full professor at the Fernuniversität in Hagen (Germany’s distant learning university), where he heads the Programming Systems group. His current research is concerned with constraint-based capture of static semantics, and with extending programming languages with multiplicity.

Material: TBA

Guido Wachsmuth (Delft University of Technology, The Netherlands)

guido-wachsmuth.jpg

Title: Name Binding: Paradigms, Representation and Specification

Abstract: Naming is a pervasive concern in the design, specification, and implementation of programming languages. Names identify declarations of program entities (variables, functions, types, modules, etc.) and allow these entities to be referenced from other parts of the program.

In this briefing, we explore name binding paradigms by examples from various programming languages, different kinds of binding-sensitive program representations supporting program transformation and mechanised reasoning tools, and old and new ways to express name binding and scope rules in language specifications and implementations.

Bio: Guido Wachsmuth is an assistant professor in the Software Language Design and Engineering program at Delft University of Technology. He designs and implements declarative metalanguages for the Spoofax Language Workbench, including languages for name binding (NaBL) and type systems. His research focuses on new linguistic abstractions in metalanguages, which enable declarative definitions of software languages and form a single basis for efficiently executing various language-processing tasks.

Material: TBA

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License