printethlogo
UDDI
 
Search
ETH Zürich - Chair of Software EngineeringTOOLS - conference series  - Tutorials
  

Tutorials

Please click on any hyperlink in one row to go to that tutorial details.

Id Title Length Day
T6 Writing Adaptable Software: Mechanisms for Implementing Variabilities in
Code and Models
full day Monday 25th
T7 SCOOP: Simple Concurrent Object-Oriented Programming full day Monday 25th
T1 Web services half day Tuesday 26th morning
T4 Putting MDA to work on Eclipse with the AMMA Tool suite half day Tuesday 26th morning
T3 Practice of Model Transformation and Model Weaving in the Eclipse Modeling
Project with ATL and AMW
half day Tuesday 26th afternoon
T2 Model Driven Security half day Wednesday 27th morning
T5 Patterns Principles and Practices of Tool Development using Model Driven
Engineering and Domain Specific Languages
full day Wednesday 27th
T8 A practical introduction to Eiffel and Design by Contract full day Wednesday 27th

T1: Web services

Given by: Gustavo Alonso (ETH Zurich)

Length: half day

Web Services have become an important tool to build complex distributed infrastructures out of heterogeneous systems. This tutorial provides an overview of the most important web service specifications and discusses in detail the role of web services in enterprise application integration and service oriented architectures. The emphasis will be on clarifying the intended goals of web services, explaining how they are being used today, and dispelling several myths around them. The differences between web services and other technologies such as distributed component models or object oriented design will also be covered and discussed.

About the speaker:

Gustavo Alonso is professor in the Department of Computer Science at the Swiss Federal Institute of Technology in Zurich (ETHZ). He holds degrees in Telecommunications Engineering from the Madrid Technical University (1989) and in computer science (M.S. 1992, Ph.D. 1994) from the University of California at Santa Barbara. Before joining ETH Zurich, he was a visiting scientist in the IBM Almaden Research Laboratory in San Jose, California. Currently, Gustavo Alonso leads the Information and Communication Systems Research Group and is the Chair of the Institute for Pervasive Computing. More information on the activities of the group can be found in www.iks.ethz.ch

T2: Model Driven Security

Given by: David Basin (ETH Zurich)

Length: half day

The integration of security into the software development process is poorly understood and inadequately supported by modern software development processes and tools. Although security requirements and threats are often considered in the early development phases (requirements analysis) and security mechanisms are commonly employed in the final development phases (system integration and test), continuous support for security engineering is lacking and the middle phases (design and development) are usually neglected. The concept of Model Driven Architecture has been proposed as a way of supporting the middle-phases of software engineering whereby systems are modeled in high-level languages and system architectures are automatically generated from the models. We show how this paradigm can be specialized to what we call Model Driven Security. Namely, models can be made of systems along with their security requirements and security architectures can be automatically generated from these models.

 

To illustrate these ideas we present SecureUML, a modeling language based on UML for modeling system designs along with their security requirements. From SecureUML models, we automatically generate security architectures, built from declarative and procedural access control mechanisms, for distributed middleware-based applications. The process has been implemented in the ArcStyler tool, which generates security infrastructures based on Sun's Enterprise Java Bean standard. We report on case studies using this tool, which illustrate the flexibility and power of our approach.

About the speaker:

David Basin is a full professor and has the chair for Information Security at the Department of Computer Science, ETH Zurich since January 2003. He is also the director of the ZISC, the Zurich Information Security Center. He received his bachelors degree in mathematics from Reed College in 1984, his Ph.D. from Cornell University in 1989, and his Habilitation from the University of Saarbrücken in 1996. His appointments include a postdoctoral research position at the University of Edinburgh (1990 - 1991), and afterwards he led a subgroup, within the programming logics research group, at the Max-Planck-Institut für Informatik (1992 - 1997). From 1997 - 2002 he was a full professor at the University of Freiburg where he held a chair in software engineering. His research focuses on information security, in particular methods and tools for modeling, building, and validating secure, reliable systems.

T3: Practice of Model Transformation and Model Weaving in the Eclipse Modeling Project with ATL and AMW

Given by: Mikael Barbero and Marcos Didonet del Fabro  (ATLAS Group,  INRIA & LINA, Nantes)

Length: half day

This tutorial presents model transformations and model weaving from a practical point of view. Model transformations and model weaving are two central components of every model management platform.

  • Model transformations enable translating a set of source models into a set of target models. Model transformations specify concrete and executable operations that visit a set of elements of the source models and that transform these elements into a set of elements of the target models.
  • Model weaving enables establishing different kinds of relationships between elements of different models. The relationships enable to specify high-level and domain specific transformation operations. These relationships are further translated into an executable transformation language.

This tutorial uses two eclipse components, Atlas Transformation Language (ATL) and Atlas Model Weaver (AMW). ATL is one official M2M Eclipse components. AMW is a component of the research incubator project GMT (Generative Modeling Technologies). These technologies can be applied for generating code from UML models, making interoperability bridges between Domain Specific Languages, doing legacy modernization, traceability of models, model decoration, or different tasks. This tutorial will introduce how to build these transformations and weaving models from a global perspective and provide hands on experiments in the field.

About the speakers:

Mikaël Barbero is a PhD candidate in Computer Science at the University of Nantes, France. He got his Master degree from the University of Nantes and an Engineer degree from the Polytech Nantes engineering school in 2006. His work is focused on Model Driven Engineering. Currently, he is working in Model Driven Reverse Engineering field (MDRE), especially Global Model Management (GMM) principles and Domain Specific Languages (DSLs) definition framework. These works are partially supported by MODELPLEX (MODELling solution for comPLEX software systems), IST European project 34081 and FLFS (Families of Languages for Families of Systems), a french ANR research project. As part of his research work, he is also an Eclipse commiter for the GMT Modeling project. Marcos Didonet del Fabro is a Ph.D. candidate at University of Nantes. His current research is about different use cases of model weaving and model transformations. He is the responsible for the AMW component in the Eclipse GMT research incubator project. His Ph.D. thesis is supervised by Jean Bézivin and Patrick Valduriez.

T4: Putting MDA to work on Eclipse with the AMMA Tool suite

Given by: Jean Bézivin, Freddy Allilaire, Hugo Bruneličre and Frédéric Jouault  (ATLAS Group,  INRIA & LINA, Nantes)

Length: half day

As part of the OMG process for issuing common recommendations, a request for information has recently been issued on "MDA Tool Capabilities". The objective is to find what capabilities (functionalities, methodology definition and process guidance) of MDA tools the MDA user community currently uses for their projects, and which capabilities they would like to have. As part of the Eclipse foundation process, a new modeling project (EMP) has recently been created to foster the evolution and promotion of model-based development technologies within the Eclipse community by providing a unified set of modeling frameworks, tooling, and standards implementations.

This tutorial will investigate the multiple relations between the complementary OMG and Eclipse activities in bringing together modelling specifications as open source tool solutions that may be deployed to implement the MDA approach and more generally model-based and DSL-based practical solutions to software production and maintenance. The various aspects of using modelling solutions to implement forward and reverse engineering will be particularly discussed. More concretely the tutorial will concretely show how a set of Eclipse open source components (KM3, ATL, AM3, AMW, TCS, MoDisco) may be used to find new solutions to difficult problems. These components are part of a modeling workbench named AMMA (ATLAS Model Management Architecture). The tutorial will conclude by revisiting the application scope of model engineering, seven years after the initial proposal of the MDA approach by OMG.

About the speakers:

Jean Bézivin is professor of Computer Science at the University of Nantes, France. He got his Master degree from the University of Grenoble and Ph.D. from the University of Rennes. Since 1980 he has been very active in Europe in the object-oriented community, participating in the creation of the ECOOP series of conference, the TOOLS series of conferences, and more recently the MODELS (previously UML) series of conferences. He founded in 1979, at the University of Nantes, one of the first Master programs in Software Engineering entirely devoted to Object Technology (Data Bases, Concurrency, Languages and Programming, Analysis and Design, etc.). His present research interests include model engineering and more especially the techniques of model transformation applied to data engineering and to software forward and reverse engineering. He is a member and deputy-lead of the ATLAS group, a new INRIA team created at the University of Nantes in relation with the LINA CNRS Lab. He has published many papers and organized tutorials and workshops in the domains of concurrency, simulation, object-oriented programming, and model-driven engineering. On the subjects of model-driven engineering and MDA, he has recently been leading the OFTA industrial group in France, co-animating a CNRS specific action and a Dagstuhl seminar. He is a member of the ECOOP and MODELS/UML steering committees. He was co-chair of ECOOP'2006 and PC chair of TOOLS'2007.

T5: Patterns Principles and Practices of Tool Development using Model Driven Engineering and Domain Specific Languages

Given by: Bruce Trask and Angel Roman (MDE Systems)

Length: full day

Model Driven Engineering (MDE) captures the basic anatomy, patterns, principles and practices of next generation tool development. The major players in the software industry including commercial companies such as IBM, Microsoft, standards bodies including the Object Management Group and leading Universities such as the ISIS group at Vanderbilt University are embracing this MDE fully. IBM is spearheading the Eclipse Foundation including its MDE tools like EMF, GEF and GMF. Microsoft has launched there Software Factories foray into the MDE space. Top software groups such as the ISIS group at Vanderbilt are using these MDE techniques in combination with Product Line Architectures for very complex systems. The Object Management Group is working on standardizing the various facets of MDE.

All of these groups are capitalizing on the perfect storm of critical innovations today that allow such an approach finally to be viable. The technology is particularly timely as the software industry reaches a complexity ceiling.

The goal of this tutorial is to educate attendees on what MDE technologies are, what the basic anatomy and patterns of MDE are and how exactly they relate to domain specific tool development. The tutorial will also demonstrate these concepts in action using real language workbench to develop a domain specific tool. The benefits of the technology are so far reaching that we feel the intended audience spans technical managers, developers and CTOs.

In general the target audience includes researchers and practitioners who are working on problems related to the design and implementation of domain specific tools and would like to understand the benefits of applying MDE techniques. The first half will be less technical than the second half where we cover the details of MDE in action in complete detail showing patterns and code.

About the speakers:

Bruce Trask has been working on complex Distributed Real-Time Embedded systems for over 20 years specializing in SPL and MDE as applied to these systems in the last 5 years. He has been teaching C++, Object Orientation, Design Patterns, UML, CORBA and Framework courses for over 7 years. He has lead multiple study groups in the New York, New Jersey, Connecticut area on various topics ranging from design patterns to middleware. He is a regular speaker/presenter at software industry conferences all year long. He has delivered tutorials at the OMG. He is the CEO of MDE Systems (www.mdesystems.com). Angel Roman is the Chief Software Architect at MDE Systems and is an expert on the Eclipse Development environment and its application frameworks. He has presented at various industry conferences on topics such as Software Defined Radios and MDE Technologies.

T6: Writing Adaptable Software: Mechanisms for Implementing Variabilities in Code and Models

Given by: Markus Völter (Independent Consultant, Goeppingen, Germany)

Length: full day

Today, a software system is often a member of a system family. Members have many things in common and differ in a set of well-defined respects. These differences are called variabilities and must be implemented in the software system. This tutorial provides an overview over techniques available for implementing such variabilities. Various alternatives exist in programming languages such as preprocessors (as in C/C++), static metaprogramming (e.g. C++ templates), aspect-oriented programming (e.g. AspectJ and CaesarJ), polymorhpism and design patterns (such as Bridge, Strategy or Interceptor), reflection and dynamic metaprogramming (as in Ruby). In addition, variabilities can also be handled in models in the context of model-driven development, for example by connecting structural models with varability models, model weaving and AO techniques for model-to-model and model-to-code transformations. The first part of the tutorial is a discussion of the different kinds of variability as well as notations for describing each form. This includes:

  • Structural and non-Structural Variability: To address structural variability you need to be able to "draw graphs" when selecting a variant, for non-structural variability you just need to "select options". Specifically, aspectual variability is typically an issue that falls into the second category.
  • Structural Modelling: Here I outline a number of techniques useful for structural modelling, mainly graphical modelling (with UML tools and other graph-based editors).
  • Feature Modelling: One of the most regularly used means for non-structural modelling is feature modelling. I will introduce the feature diagram notation and explain the advantages compared to UML models.

The second part part will take a look at the different implementation techniques for variabilities. These include:

  • Preprocessors: C/C++ has made this approach well-known, where prior to compilation, certain parts of the code are removed/retained based on the values of properties.
  • Static metaprogramming: this is basically C++ templates and C++ Compile-Time MOPs
  • Aspect-oriented programming (static & dynamic): AOP can be used for many things, among them specifically variant management. I will show this use of AOP using AspectJ and CaesarJ.
  • (External) Code generation: Classical External Code generation is a great means of handling structural variability. I will show examples using the openArchitectureWare framework.
  • Polymorhpism and Design Patterns: Although using Patters such as factory, strategy, bridge, adaptor or interceptor is well-known, a discussion of variability cannot be complete without them. So I'll illustrate them briefly here.
  • Reflection and Dynamic Metaprogramming: Reflection is the capability of a program to learn something about itself. While languages such as Java provide read-only reflection (introspection), the power of this technique comes with modifying reflection. I'll show this kind of metaprogramming with Ruby.
  • Expressing Variability in Models: here we use configuration models to vary structural models, expressing "variants of models". Another approach used here is aspect weaving on model-level.
  • Code Generaton Variability: Here we show how to use AOP as well as AO on generator-level to express different ways of varying the concrete code that is generated.

About the speaker:

Markus Völter works as an independent consultant and coach for software technology and engineering. He focuses on software architecture, middleware, model-driven software development as well as product line engineering. Markus is the author of several magazine articles, patterns and books on middleware and model-driven software development. He is a regular speaker at conferences world wide. Markus can be reached at voelter@acm.org via or www.voelter.de

T7: SCOOP-Simple Concurrent Object Oriented Programming

Given by: Bertrand Meyer (ETH) and Piotr Nienaltowski (Praxis High Integrity Systems Ltd, UK).

Length: full day

Of all fields of computer science, concurrent programming is among those where the chasm is largest between theory and practice. While an abundant literature studies conceptually attractive models, programmers building multi-threaded and multi-process applications continue to rely on mechanisms designed in the late sixties, as if caught in a time warp.

It's high time to bring concurrency to the same level of abstraction and trustworthiness as the rest of programming. This tutorial presents the SCOOP model for simple concurrent object-oriented programming, based on applying concepts of Design by Contract to the concurrent world; the key idea is that correctness is a special case of waiting.

SCOOP has undergone considerable refinement since the ideas were first proposed in the early nineties. In particular: an open-source implementation is available; many aspects have been simplified and a few extensions make the model more flexible; the semantics of SCOOP has been made more precise; a new type system ensures the absence of data races and atomicity violations while accommodating important object-oriented mechanisms such as inheritance, polymorphism, and genericity. The tutorial presents SCOOP as exists today and describes its applications.

 

About the speakers:

Bertrand Meyer is Professor of Software Engineering at ETH Zurich, founder and Chief Scientist of Eiffel Software.

Piotr Nienaltowski is a software engineer at Praxis High Integrity Systems Ltd (UK). His recent PhD thesis at ETH Zurich was devoted to the SCOOP model; it solved a number of open problems, provided a working implementation, defined the semantics, and constitutes the current reference on SCOOP.

T8: A practical introduction to Eiffel and Design by Contract

Given by: Bertrand Meyer (ETH) and Emmanuel Stapf (Eiffel Software)

Length: full day

Eiffel is a method, language and environment devised to permit the timely development of efficient, reliable, easy-to-change software with elegant architectures. Used in large industrial projects as well as in education, it places a particular emphasis on assertion-based development and automatic testing through Design by Contract techniques. This tutorial presents the essential concepts of the Eiffel approach with a practical focus, to enable participants to get started with the approach. It describes the latest developments in the ISO-standardized version of the language (in particular attached types, guaranteeing the absence of "null calls", programmer-defined conversions, and agents, a functional-programming-like mechanism) as well as in the EiffelStudio environment.

 

About the speakers:

Bertrand Meyer is Professor of Software Engineering at ETH Zurich, founder and Chief Scientist of Eiffel Software.

Emmanuel Stapf is Chief Engineer at Eiffel Software and in this capacity has led the development of successive versions of the Eiffel compiler and EiffelStudio environment since 1997.

Contact

Manuel Oriol, manuel.oriol@inf.ethz.ch, ETH Switzerland

top