Summary of short tutorials
- Nelly Bencomo (INRIA, France): Requirements for Self-adaptation (slides: 1, 2)
- Anthony Cleve (University of Namur, Belgium): Dynamic Program Analysis for Database Reverse Engineering (slides)
- Tudor Gîrba (netstyle.ch GmbH, Switzerland): Tooling Research (slides, demo)
- Florian Heidenreich and Christian Wende (Technische Universität Dresden, Germany): Model-based Language Engineering (slides)
- Christian Kästner and Sven Apel (Philipps University Marburg and University of Passau, Germany): Feature-oriented Software Development (FOSD) (slides)
- Alfonso Pierantonio and Davide Di Ruscio (University of L’Aquila, Italy): Managing the Evolution of F/OSS with Model-Driven Techniques (slides: 1, 2)
- Markus Völter (independent/itemis, Germany): Language & IDE Development, Modularization and Composition with MPS (slides)
Nelly Bencomo (INRIA, France)
Requirements for Self-adaptation
Self-adaptation is emerging as an increasingly important capability for many applications, particularly those deployed in dynamically changing environments, such as ecosystem monitoring and disaster management. One key challenge posed by Self-Adaptive Systems (SAS) is the need to handle changes to the requirements and corresponding behavior of a SAS in response to varying environmental condition. This tutorial will focus on modelling techniques for the development of self-adaptive systems (a specific emphasis on goal-based techniques will be made). The tutorial will also cover the role of uncertainty for such systems and initial ideas of the need of run-time requirements).
Nelly Bencomo is a Marie-Curie Fellow in INRIA Paris — Rocquencourt, France. Her current project is called Requirements@run.time. Previously she was in Lancaster University, UK, where she was a Senior Research Associate and also finished her PhD (2008). Nelly Bencomo is the co-founder of the Workshops Models@run.time and Requirements@run.time. She is interested in all aspects of software modelling during the development and operation of dynamically adaptive systems. Lately, she have focused on Requirements-aware systems.
Anthony Cleve (University of Namur, Belgium)
Dynamic Program Analysis for Database Reverse Engineering
The documentation of a database includes its conceptual schema, formalizing the semantics of the data, and its logical schema translating the former in an operational database model. Important processes as database and program evolution must rely on an accurate database documentation. In many cases, however, this documentation is missing, or, at best, incomplete and outdated. Database redocumentation, a process also called database reverse engineering, typically involves the elicitation of implicit schema constructs. The most standard discovery technique of these implicit constructs is the static analysis of application programs, and, in particular of embedded SQL statements. Unfortunately, the increasing use of dynamic SQL in modern applications development often makes such techniques helpless. This tutorial elaborates on the use of dynamic program analysis for database reverse engineering. It illustrates and compares possible techniques for (1) capturing SQL query execution traces at runtime and (2) extracting implicit schema constructs from those traces. It reports on a comparative experiment evaluating the usefulness of the presented techniques. This tutorial is based on joint work with Jean-Luc Hainaut and Jean-Roch Meurisse.
Anthony Cleve is a post-doctoral researcher at University of Namur (FUNDP) and a part-time lecturer in database engineering at Université Libre de Bruxelles (ULB). Anthony's research interests include software maintenance and evolution, software and database reverse engineering, program analysis and transformation, software product line engineering, self-adaptive and context-aware systems. He is co-author of more than twenty peer-reviewed publications in international venues in software and information system engineering. He was the recipient of the IBM Belgium 2010 Award for the best PhD thesis in computer science and applications. Anthony serves and has served in the organizing and program committees of several international conferences and workshops, including ASE, CSMR, ER, ESEC/FSE, ICSM, IWPSE, SLE and WCRE. He is co-chair of the ERCIM Working Group on Software Evolution and steering committee member of the International Workshop on Principles of Software Evolution (IWPSE).
Tudor Gîrba (netstyle.ch GmbH, Switzerland)
Researchers hunt for new ideas that advance the current state-of-the-art. In a field oriented towards practice, like software engineering, these ideas need to be materialized so that they can be tested against real situations and be compared effectively with the related work.
To this end, we need tools. In many fields, such as chemistry, tools cannot be manufactured directly by the scientists because they simply do not possess the necessary skills. These tools are typically provided by external entities. In software engineering, the situation is significantly different: the knowledge of building the software tools needed for experiments is within the reach of scientists as they are typically software engineers themselves.
This constitutes a unique opportunity, and yet tool building is still not accepted as central in the research effort. In this tutorial I will incite you to change this. The presented ideas are drawn from the experience of being at the center of the Moose analysis platform.
Tudor Gîrba attained his PhD in 2005, and he now works as a consultant. His main expertise lies in the area of software engineering with focus on software and data assessment. Since 2003, he leads the work on Moose, an extensive analysis platform used both in research and in industry. He coined the term humane assessment, and he is currently helping companies assess and manage large software systems and data sets.
Florian Heidenreich and Christian Wende (Technische Universität Dresden, Germany)
Model-based Language Engineering
Textual Syntax as a form of model representation has made its way to the Model-Driven Software Development community and is considered a viable alternative to graphical representations. In this tutorial we introduce a model-based approach to engineering textual modelling languages and to integrate such languages with common software engineering. We apply EMFText, an EMF/Eclipse-integrated tool, for the stepwise development and extension of an textual modelling language. Using JaMoPP, a tool for handling Java code as models, we integrate this language with Java. Participants will learn hands-on how to develop productive DSLs. Furthermore, means for language modularisation and composition are presented and participants will learn about challenges and pitfalls when designing reusable language modules.
Florian Heidenreich is working as a Research Assistant at the Software Technology Group of the Dresden University of Technology within the group of Prof. Uwe Aßmann. His research interests are Software Product Lines, Model-Driven Software Development, Feature-Oriented Software Development, Generative Techniques, and Separation of Concerns.
Christian Wende is working as a Research Assistant at the Software Technology Group of the Dresden University of Technology within the group of Prof. Uwe Aßmann. His research interests are Language Engineering and in particular Language Composition.
Christian Kästner and Sven Apel (Philipps University Marburg and University of Passau, Germany)
Feature-oriented Software Development (FOSD)
Feature-oriented software development (FOSD) is an emerging paradigm that provides a multitude of formalisms, methods, languages, and tools for building well-structured, variable, customizable, and extensible software systems. The idea is to structure software along its end-user visible features and to generate tailored software systems based on feature selections of users. The set of valid feature combinations of a domain is called a software product line.
In this short tutorial, we will give an overview of the key concepts and challenges of FOSD, recent developments in this field, and relations to other development paradigms. Especially, we will concentrate on tools and theory and on recent attempts to ensure correctness properties despite variability and feature interactions.
Christian Kästner currently holds a PostDoc position at the Philipps University Marburg. He received his PhD from the University of Magdeburg, Germany in 2010. He works on implementing and analyzing variability in software systems, with a special focus on simple conditional-compilation based implementation techniques, named virtual separation of concerns.
Sven Apel is the leader of the Software Product-Line Group at the University of Passau, Germany. He received his Ph. D. in Computer Science in 2007 from the University of Magdeburg, Germany. His research interests include novel programming paradigms, software engineering and product lines, and formal and empirical methods.
Alfonso Pierantonio and Davide Di Ruscio (University of L’Aquila, Italy)
Managing the Evolution of F/OSS with Model-Driven Techniques
FOSS (Free and Open Source Software) systems present interesting challenges in system evolution. On one hand, most FOSS systems are based on fine-grained units of software deployment–called packages–which promote system evolution; on the other hand, FOSS systems are among the largest software systems known and require sophisticated static and dynamic conditions to be verified, in order to successfully deploy upgrades on users’ machines. The slightest error in one of these conditions can turn a routine upgrade into a system administrator’s nightmare. In this tutorial we introduce EVOSS – a model-based approach to support the upgrade of FOSS systems. The approach promotes the simulation of upgrades to predict failures before affecting the real system. Both fine-grained static aspects (e.g. configuration incoherences) and dynamic aspects (e.g. the execution of configuration scripts) are taken into account, improving over the state of the art of upgrade planners. The effectiveness of the approach is validated by instantiating the approach to widely-used FOSS distributions.
Alfonso Pierantonio is Associate Professor in computer science at the University of L’Aquila (Italy), he is currently director of the Master in Web Technology degree program. His current research interests include Model-Driven Engineering and in particular the theory and practice of model versioning/evolution with a speciﬁc emphasis on coupled evolution. In particular, he investigated the problem of co-evolution between metamodels and other artifacts in order to deﬁne the basis for their (semi) automatic adaptation. He has been and is currently part of program and organization committees of conferences and has been among the initiators and in the steering committee of the International Conference on Model Transformation (ICMT). He co-edited several special issues on Model Transformations which appeared on Science of Computer Programming and on the International Journal of Software and Systems Modeling.
Davide Di Ruscio is Assistant Professor in the Computer Science Department of the University of L’Aquila. His research interests include code generation, methodologies for Web development, Model Driven Engineering, and more specifically model differencing and model evolution. He published several papers in journals and international events in these topics. He has been in the PC of several workshops and conferences, and reviewer of many journals like Science of Computer Programming, Software and Systems Modeling, and IEEE Transactions on Software Engineering.
Markus Völter (independent/itemis, Germany)
Language & IDE Development, Modularization and Composition with MPS
JetBrains MPS is an Open Source language workbench. It uses projectional editing, which means that no parser is involved, and textual, tabular and graphical notations are handled with the same approach. As a consequence, it is an ideal language and IDE development environment. This tutorial has three parts: In part one, I will give a very short introduction to projectional editing. Part two provides examples of existing (modular) languages developed with MPS, showcasing the benefits of the tool and its possibilities. In part three, the longest one, I will show how to define languages in MPS, reusing/extending existing language modules. The tutorial will be mostly live demos; only part one will use a small number of slides.
Markus Völter works as an independent researcher, consultant and coach for itemis AG in Stuttgart, Germany. His focus is on software architecture, model-driven software development and domain specific languages as well as on product line engineering. Markus also regularly writes (articles, patterns, books) and speaks (trainings, conferences) on those subjects.
- Slide deck
- Part 1: MPS Intro (14:18)
- Part 2: The Entities Language (14:05)
- Part 3: Language Combination with the UI Language (14:51)
- Part 4: Language Extension with Expression Blocks (13:14)
- Part 5: Language Reuse (Separate Code) with the Persistence Languages (7:44)
- Part 6: Language Reuse (Mixed Code) with the RBAC Languages (7:57)
- Part 7: Language Embedding with the UI Validations/Expression Languages (12:55)
- Part 8: Bonus: MPS Annotations (6:24)