- Latest News
- Advance Program
- Calls for Participation
- Important Dates
- Conference Committee
- Program Committee
- Sponsors and Supporters
- Sponsorship Opportunities
- ASE Community
- News Feed
University of Toronto, Canada
Virginie Wiels (Virginie.Wiels@cert.fr)
|T1:||Software Reuse and Evolution with Generative Techniques|
Monday, November 5, 2007 (Full day)
8:45am - 5:30pm
|Organizers:||Krzysztof Czarnecki (University of Waterloo, Canada)|
Evolution and reuse are key challenges in software development. Evolution is challenging because it usually requires developers to manually modify the program code and a change to a single requirement may easily require multiple changes in different parts of the code. Software reuse is challenging because previous software solutions, even if matching nearly all the requirements for a new application, are still notoriously hard to adapt to the new context. Generative software development aims at addressing these challenges by providing system specifications expressed in one or more textual or graphical domain-specific languages (DSLs). The specifications allow developers to state the desired changes at the right level of abstraction and then propagate these changes to code automatically.
The first part of the tutorial will focus on basic concepts and techniques underlying generative software development, including product line engineering, feature modeling, and DSLs. The second part of the tutorial will provide an in-depth treatment of selected techniques. It will include an overview of tools and notations for feature modeling, a discussion of how features can be mapped to structural and behavioral models, and a presentation of how DSLs can be developed based on object-oriented frameworks and how round-trip engineering can be achieved in such a setting in order to keep domain-specific models and code in sync.
The discussion of the concepts and techniques will be based on practical examples from a variety of domains including enterprise and embedded software.
Krzysztof Czarnecki is an Associate Professor at the University of Waterloo, Canada. Before coming to Waterloo, he spent eight years at DaimlerChrysler Research working on the practical applications of generative programming. He is co-author of the book "Generative Programming" (Addison-Wesley, 2000), which is regarded as founding work of the area and is used as a graduate text at universities around the world. He was a keynote speaker the 2006 International Conference on Generative Programming and Component Engineering (GPCE) and will be the program chair for MoDELS 2008. His current work focuses on realizing the synergies between generative and model-driven software development.
|T2:||Empirical Research Methods for Software Engineering|
Tuesday, November 6, 2007 (Full day)
8:45am - 5:30pm
|Organizer:||Steve Easterbrook (University of Toronto, Canada)|
This full day tutorial introduces the use of empirical methods appropriate to research in automated software engineering. Using a blend of lecture and discussion, it aims to provide ASE researchers and practitioners with a foundation for conducting and critiquing empirical studies. The tutorial covers of the principal methods applicable to ASE: controlled experiments, quasi-experiments, case studies, survey research, ethnographies, and action research and relates these methods to relevant metatheories in the philosophy and sociology of science. The tutorial presents techniques applicable to each of the steps of a research project, including formulating research questions, theory building, data analysis (using both qualitative and quantitative methods), building evidence, assessing validity, and publishing. The tutorial is relevant for researchers, who will be able to conduct and write more credible empirical studies; for reviewers who will be able to provide qualified judgments of papers; and for practitioners, who will be able to more effectively interpret published results within the context of their own organizations.
|T3:||Rosetta: Language Support for System Level Design|
Tuesday, November 6, 2007 (Half day)
8:45am - 12:30pm
|Organizer:||Perry Alexander (University of Kansas, USA)|
The essence of system-level design is the desire to predict the behavior of complex, heterogeneous systems. To properly assess system-level properties such as security, power consumption, availability, and response time, impacts of local design decisions on global properties must be predictable. Traditionally associated with physically large systems, system-level design is increasingly important in computer-based system design. As computer-based systems continue to grow in size, complexity, and societal impact, understanding and addressing system-level design problems has become paramount.
Rosetta is an emerging IEEE standard for supporting system-level design. It provides explicit support for heterogeneous modeling, model composition, and model transformation necessary for representing and analyzing system-level properties. Originally designed for engineering electronic systems, its requirements were defined by the Semiconductor Industry Council as a next-generation design language to encompass both hardware and software components. Expanding well beyond its original scope, Rosetta has been used for modeling applications ranging from aircraft hydraulics and semiconductors to telecommunications and software systems. Current applications focus on design of high-assurance, software intensive computer-based systems such as secure operating systems and control systems.
At the heart of Rosetta models are facets that describe individual system views. Much like aspects in aspect-oriented programming, facets define a system from one, domain-specific perspective. Each facet is written by extending a domain that defines units of semantics, a model of computation and specification vocabulary for a particular engineering domain. Writing facets using different domains allows a specifier to model heterogeneous system aspects using domain-specific semantics and vocabulary.
Domain specific facets are composed to define system models using the facet algebra. The facet algebra provides relations, composition operators, and transformation operators defined over domains. Composition operators include products for merging specifications, sums for defining modal specifications, and structural composition for modeling and instantiating system architectures. Transformation operators define morphisms for moving specifications among domains, exchanging information between domains, and synthesis of designs and analysis models. Composing facets from different domains allows a specifier to define a composite system from heterogeneous models.
The collection of Rosetta specification domains defines a lattice with interactions defining pair-wise interaction between domains. These interactions define how and when information from one domain impacts information in another. New domains are added to the lattice by extending existing domains and may vary from simple unit-of-semantics declarations to full engineering domains. Composing interacting facets from different domains allows a specifier to model the impacts of design decisions local to one domain on other interacting domains.
This tutorial presents a 1/2 day introduction to modeling using Rosetta. The presentation will open with a discussion of industry requirements the Rosetta modeling methodology. The language will then be presented in three sections: (i) the expression sub-language; (ii) the facet and component sub-language; and (iii) the domain sub-language and lattice. The tutorial will conclude with a presentation of Rosetta's formal semantics. Emphasis will be placed on writing specifications with Rosetta and how those specifications support system-level specification and analysis.
|T4:||Meta Tools for Implementing Domain Specific Visual Languages|
Tuesday, November 6, 2007 (Half day)
2:00pm - 5:30pm
(University of Auckland, New Zealand)
John Hosking (University of Auckland, New Zealand)
This tutorial provides an introduction to the use of meta tools for specifying and implementing DSVLs. We commence with a brief introduction to the concept of a DSVL and describe a range of exemplars. We show how these DSVLs naturally arise from the development of complex frameworks that require script-based customization. We then explore common concepts of visual meta-modeling and introduce evaluation approaches for DSVL tools. We will illustrate these concepts by a live demonstration of the development of a simple visual language using our Marama meta tool set. We will also briefly describe a range of other DSVL environments developed using our meta toolsets together with application of the toolset as a rapid prototyping tool in industrial consultancy. Following this in depth introduction to one meta modeling toolset we will then broaden out to explore a range of other meta tools, both commercial quality and academic prototypes providing participants with an understanding of the range of different paradigms for language specification and implementation available. This exploration will include a comparative evaluation across a range of functional dimensions allowing participants to understand the relative strengths of the different toolsets.