Summary of long tutorials
- Darius Blasband (RainCode, Belgium): Compilation in the 21st century—Too Real for Comfort (slides)
- Olivier Danvy (Aarhus University, Denmark): Tips & Tricks for Communication in CS: Reviews, Papers and Talks (slides: 1, 2, 3, 4, 5)
- Arie van Deursen (Delft University of Technology, The Netherlands), Test Automation: An Empirical Perspective (slides: 1, 2, 3)
- Martin Erwig (Oregon State University, USA): Variation Programming with the Choice Calculus (slides: 1, 2, 3; code)
- Robert Fuhrer (IBM Research, USA): Exposing and Exploiting Program Analyses in an IDE (slides)
- Richard Paige (University of York, UK): Model Management in the Wild: Foundations & Applications (slides: 1, 2, 3)
- Eleni Stroulia (University of Alberta, Canada): Methods and Tools for Analyzing Software Evolution (slides)
- James F. Terwilliger (Microsoft Corporation, USA): Bidirectional by Necessity (slides: 1, 2, 3)
Darius Blasband (RainCode, Belgium)
Compilation in the 21st century—Too Real for Comfort
PL/1 was originally designed as a best of breed of the languages available at the time, a mixture between COBOL, FORTRAN and ALGOL. This school of thought has pretty well vanished by now, as the combination of such heterogeneous sets of features has proven toxic. It makes the language hard to compile, hard to maintain and counter-intuitive in places. This tutorial tells the true story of the development of a PL/1 compiler for Microsoft's .NET platform, emphasizing the most uncommon aspects of this project. It covers the usage of a front-end designed for legacy modernization purposes for a compiler, having no influence whatsoever on the language design (as the whole purpose of this project is to port existing applications with minimal change) and the resulting impact on the design, targeting a virtual machine to compile a language designed for a totally different architecture together with the corresponding performance issues. The tutorial also covers more pragmatic concerns such as compile-time performance, testing and quality control, emulating PL/1 numeric data types, CICS and SQL extensions.
Darius Blasband has a Master's degree and a PhD from the Université Libre De Bruxelles. His interests cover all aspects of programming language processing, including compilation, reverse engineering, parsing technologies, types systems and optimizations. He runs RainCode, based in Brussels, Belgium, which offers products and services for the legacy modernization market. He is responsible for product design and strategic alliances.
Olivier Danvy (Aarhus University, Denmark)
Tips & Tricks for Communication in Computer Science: Reviews, Papers and Talks
Research results in computer science are peer-reviewed, read, and listened to. To communicate our results, we thus need to write them down, submit what we wrote to peer review, and present them orally. The three lectures of this tutorial are dedicated to (a) criticism: how to receive and to offer reviews; (b) the written word: how to read and to write papers; and (c) the spoken word: how to attend and to give talks.
Olivier Danvy is interested in all aspects of programming languages, including programming. His other mother is the Universite Pierre et Marie Curie (Paris VI: PhD, 1986) and his other mother in law is Aarhus University (DSc, 2006), where he is currently supervising his 22nd PhD student.
- Slides: Communication in Computer Science, Part 1
- Slides: Communication in Computer Science, Part 2
- Slides: Communication in Computer Science, Part 3
- Slides: Deﬁnitions
- Slides: Your Graduate Life in Pictures
Arie van Deursen (Delft University of Technology, The Netherlands)
Test Automation: An Empirical Perspective
This is joint work with Michaela Greiler (Delft University of Technology, The Netherlands) and Ali Mesbah (University of British Columbia, Canada).
Arie van Deursen is full professor at Delft University of Technology, where he is leading the Software Engineering Research Group. His research interests include software testing, empirical methods, software architecture, end user programming, and collaborative software development. He holds an MSc degree from the Vrije Universiteit Amsterdam (1990) and a PhD degree from the Universiteit van Amsterdam (1994). He is general chair of the 8th Working Conference on Mining Software Repositories (MSR'11) and program co-chair of the 20th IEEE International Conference on Program Comprehension (ICPC'12) as well as of the ICSE 2013 New Ideas and Emerging Research track (NIER'13).
- Slides: Part I — Introduction
- Slides: Part II — Testing Web Applications
- Slides: Part III — Testing Plug-ins
Martin Erwig (Oregon State University, USA)
Variation Programming with the Choice Calculus
The choice calculus provides a language for representing and transforming variation in software and other structured documents. Variability is captured in localized choices between alternatives. The space of all variations is organized by dimensions, which provide scoping and structure to choices. The variation space can be reduced through a process of selection, which eliminates a dimension and resolves all of its associated choices by replacing each with one of their alternatives. The choice calculus also allows the definition of arbitrary functions for the flexible construction and transformation of all kinds of variation structures. In this tutorial we will first present the motivation, general ideas, and principles that underlie the choice calculus. This is followed by a closer look at the semantics, transformation laws, and design guidelines. We will also present practical applications based on several small example scenarios, such as, “variation-aware programming”, “variation querying”, and “feature model programming”. The practical applications involve work with a Haskell library that supports variation programming and experimentation with the choice calculus.
This is joint work with Eric Walkingshaw.
Martin Erwig is Professor of Computer Science at Oregon State University where he has been teaching since 2000. He received his Ph.D. and Habilitation in Computer Science from the University of Hagen in Germany. He is the author or co-author of two books and over 90 peer-reviewed publications, for which he received several best paper awards. His research interests are in language design, functional programming, and visual languages.
- Slides: Variation Programming with the Choice Calculus
- Slides: Variation Programming with the Choice Calculus
- Slides: Variation Programming with the Choice Calculus
- Source code
Robert Fuhrer (IBM Research, USA)
Exposing and Exploiting Program Analyses in an IDE
Modern, feature-rich Integrated Development Environments (IDEs) offer advanced functionality that eases the construction, navigation, understanding and manipulation of source programs. The critical foundation for this functionality lies in two core aspects: (1) static program analyses, and (2) incorporating and presenting analysis results in an IDE setting. Analyses examine both the syntactic and organizational structure of the program, as well as the rich semantic relationships that interlace the code. Meanwhile, these analyses enable presentations in many forms, such as specialized views that focus on various program characteristics, such as type hierarchy or call graph views, and rich source editing, such as content assist or refactoring. This tutorial intends to give participants a working understanding of the kinds of IDE tooling that can be constructed to improve programmer productivity through increased understanding, and high-leverage program manipulations.
Robert is project lead for the X10DT team, which has produced an Eclipse-based IDE for the X10 concurrent programming language, and for the IMP Eclipse Technology Project, whose aim is to greatly simplify and accelerate the IDE development process. Robert is also currently working on refactoring and advanced tooling for concurrent programs. Before starting that project, Robert spent several years developing static analyses and advanced refactorings for Java, some of which are part of the Eclipse JDT since version 3.1. In the past, he has worked on a diverse set of projects, including visual programming languages, manufacturing optimization, hardware synthesis and verification for asynchronous circuits, and a film scoring system. Robert received his Ph.D. in Computer Science from Columbia Univ. in 1999. He is the author of a graduate text in asynchronous logic synthesis and of several papers at top conferences. He has also co-organized workshops on refactoring and IDE construction at major conferences.
Richard Paige (University of York, UK)
Model Management in the Wild: Foundations & Applications
We describe the foundations of model management: the basic concepts, features and patterns that underpin the discipline. We then present more advanced features, including different kinds of model transformations (for merging, evolving, and updating models), and then talk about applications of model management in the wild, including dealing with issues of scalability, bidirectionality and traceability.
Richard Paige is Professor of Enterprise Systems at the University of York, and is director of the Engineering Doctorate Centre in Large-Scale Complex IT Systems. He leads research on software and systems modelling, model management, agile methods and formal methods at York. He is principal investigator on several European and UK national projects in these areas. He is on the steering committees of the ECMFA, ICMT and TOOLS series of conferences, and enjoys really bad science fiction films far too much.
- Slides: Model Management in the Wild, Part 1
- Slides: Model Management in the Wild, Part 2
- Slides: Advanced Concepts
Eleni Stroulia (University of Alberta, Canada)
Methods and Tools for Analyzing Software Evolution
The overall problem of analyzing software evolution involves the analysis of the software artifacts and the people-related process through which the software has evolved. In the context of software-artifact evolution, we will review two state-of-the-art algorithms for analyzing the evolution of an Object-Oriented software system and our comparative empirical study of their performance on a real system: 1) UMLDiff, a heuristic, UML-specific algorithm, and 2) VTracker, a domain-independent tree-differencing algorithm. Next we review a suite of methods designed to infer relevant information from the communication and documentation artifacts produced during software development. Specifically, we discuss a method for clustering code-evolution events with communication artifacts (with the objective of finding interesting textual information explaining the rationale and issues around changes), and a text-analysis method for recognizing interesting relations (knowledge, expertise, contribution) among developers, artifacts, tasks and tools. Finally, we review WikiDev, a lightweight web-based tool for support software teams, in which these analyses have been deployed.
Eleni Stroulia is a Professor and NSERC/iCORE Industrial Research Chair on Service Systems Management (w. support from IBM) with the Department of Computing Science at the University of Alberta. She holds M.Sc. and Ph.D. degrees from Georgia Institute of Technology. Her research addresses industrially relevant software-engineering problems with automated methods, based on artificial-intelligence techniques. Her team has produced automated methods for migrating legacy interfaces to web-based front ends, and for analyzing and supporting the design evolution of object-oriented software. More recently, she has been working on the development, composition, run-time monitoring and adaptation of service-oriented applications, and on examining the role of web 2.0 tools and virtual worlds in offering innovative services in the domains of health-care, education, business and government.
James F. Terwilliger (Microsoft Corporation, USA)
Bidirectional by Necessity
Most modern applications are driven by large persistent data stores whose model of data may significantly differ from its corresponding application. To bridge this modeling gap, one must specify some form of mapping to connect those models to provide data query and update access to the application. The most studied solution in database literature to this mapping problem is the updatable view. However, updatable views are almost never used in practice because of usability issues, lack of support in commercial systems, and an inability to handle schema evolution, when the application evolves and its data store schema and instances must evolve with it. Consequently, most systems resort to a menagerie of custom solutions. In this tutorial, we examine some of the shortcomings of the updatable view, as well as describe more recent and promising mapping solutions, both declaratively and incrementally specified.
James Terwilliger is a Senior Software Development Engineer at Microsoft in the SQL Server division. He graduated from Portland State University in 2009 with a Ph.D. in Computer Science. His dissertation has actually been read on at least two documented occasions by people not on his graduation committee. James's research work has focused on schema evolution scenarios and making database management easier to often neglected classes of users. After an internship and a post-doc at Microsoft Research, he switched to the development side of the force to work on new techniques in data modeling and management.