Tutorials

TA1

Architecture-centric Software Engineering

Authors

Jan Bosch, University of Groningen

Prof. dr. ir. Jan Bosch is a professor of software engineering at the University of Groningen, The Netherlands, where he heads the software engineering research group. He received a MSc degree from the University of Twente, The Netherlands, and a PhD degree from Lund University, Sweden. His research activities include software architecture design, software product families, software variability management and component-oriented programming. He is the author of a book "Design and Use of Software Architectures: Adopting and Evolving a Product Line Approach" published by Pearson Education (Addison-Wesley & ACM Press) and (co-)editor of three volumes in the Springer LNCS series. He has organised numerous workshops, served on many programme committees, including the ICSR'6, CSMR'2000, ECBS'2000, GCSE, SPLC and TOOLS conferences and is member of the steering groups of the GCSE and WICSA conferences. He was the PC co-chair of the 3rd IFIP (IEEE) Working Conference on Software Architecture (WICSA-3), is the general chair for WICSA-4 and PC co-chair for the 8th International Conference on Software Reuse (ICSR-8).

Abstract + Keywords

Many software organizations are in the process of moving from project-centric to architecture-centric engineering of software. The two typical reasons for this move are (1) the architecture allows for a clear break-down in parts whereas a project-centric approach easily leads to a monolithic system and (2) the organization is interested in exploiting the commonalities between its products or systems. This tutorial addresses this development by providing an overview and in depth treatment of the issues around architecture-centric engineering of software. Topics include software architecture design in the presence of existing components and infrastructure (top-down versus bottom-up), architecture evaluation and assessment, software artefact variability management, software product lines and the role of the software architect. These topics are, in addition to the technical perspective, discussed from process and organizational viewpoints. The topics are extensively illustrated by examples and experiences from many industrial cases.

Attendee Background

It is assumed that the participant has some experience with industrial software development and has a general awareness of the increased importance of software variability.

Tutorial Objectives

This tutorial provides an overview and in depth treatment of the issues around architecture-centric engineering of software. Topics include software architecture design in the presence of existing components and infrastructure (top-down versus bottom-up), architecture evaluation and assessment, software artefact variability management, software product lines and the role of the software architect.

TA2

Software Architectures for Safe and Secure Systems  

Authors

Jan Jürjens, TU Munich

Jan Jürjens is a  researcher at TU Munich (Germany) - author of the book "Secure Systems Development with UML" (Springer-Verlag, 2004) - 30 papers, 4 invited talks, 20 tutorials in international refereed journals and conferences, mostly on computer security and software engineering, - initiator and current chair of working group on Formal Methods and Software Engineering for Safety and Security (FoMSESS) within German Computer Society (GI) - leader of various security-related projects with industry. member of: - executive board of Division of Safety and Security within GI - advisory board of Bavarian Competence Center for Safety and Security - working group on e-Security of Bavarian regional government - IFIP Working Group 1.7 "Theoretical Foundations of Security Analysis and Design" - chaired two workshops on critical systems development with UML (satellite of UML'02,03). He has been leading various security-related projects with industry.

Abstract

The high quality development of critical systems (be it dependable, security- critical, real-time, or performance-critical systems) is difficult. Many critical systems are developed, deployed, and used that do not satisfy their criticality requirements, sometimes with spectacular failures.

Part of the difficulty of critical systems development is that correctness is often in conflict with cost. Where thorough methods of system design pose high cost through personnel training and use, they are all too often avoided.

UML offers an unprecedented opportunity for high-quality critical systems development that is feasible in an industrial context, because a large number of developers is trained in UML, UML is relatively precisely defined, and a number of tools are developed to assist its use.

The tutorial aims to give background knowledge on using UML for critical systems development and to contribute to overcoming some challenges in this context including:

Adaptation to critical system application domains.
Providing advanced tool-support for critical systems
development with UML – using various extensions, such as UML-RT, UMLsec, UMLsafe.

It includes a demo of a tool supporting critical systems analysis with UML.

The content is identical to ECOOP tutorial TS2 (Monday).

Attendee Background

The tutorial addresses practitioners (i.e. system and software developers, architects, and technical managers) and researchers interested in critical systems development using UML (in particular for dependable, security-critical, or real-time systems). Basic knowledge of object-oriented software and UML is assumed. No specific knowledge of the various application domains is assumed.

Tutorial Objectives

By the end of the tutorial, the participants will have knowledge on how to use the UML for a methodological approach to critical systems development. They will be able to use this approach when developing or analyzing critical systems, by making use of existing solutions and of sound methods of critical systems development.

TA3

Software Variability Management

Authors

Jan Bosch, University of Groningen

Prof. dr. ir. Jan Bosch is a professor of software engineering at the University of Groningen, The Netherlands, where he heads the software engineering research group. He received a MSc degree from the University of Twente, The Netherlands, and a PhD degree from Lund University, Sweden. His research activities include software architecture design, software product families, software variability management and component-oriented programming. He is the author of a book "Design and Use of Software Architectures: Adopting and Evolving a Product Line Approach" published by Pearson Education (Addison-Wesley & ACM Press) and (co-)editor of three volumes in the Springer LNCS series. He has organised numerous workshops, served on many programme committees, including the ICSR'6, CSMR'2000, ECBS'2000, GCSE, SPLC and TOOLS conferences and is member of the steering groups of the GCSE and WICSA conferences. He was the PC co-chair of the 3rd IFIP (IEEE) Working Conference on Software Architecture (WICSA-3), is the general chair for WICSA-4 and PC co-chair for the 8th International Conference on Software Reuse (ICSR-8).

Abstract

In a variety of approaches to software development, software artifacts are used in multiple contexts or for various purposes. The differences lead to so-called variation points in the software artifact. During recent years, the amount of variability supported by a software artifact is growing considerably and its management is developing as a main challenge in the development, usage and evolution of software artifacts. Examples of approaches where the management of variability is evolving as a challenge include software product families, component-based software development, object-oriented frameworks and configurable software products such as enterprise resource planning systems.

The tutorial presents insights gained, techniques developed and lessons learned in the European IST project ConIPF (Configuration in Industrial Product Families) and in other research performed by the software engineering research group at the University of Groningen. The tutorial first establishes the importance of software variability management, defines the concept of variability, discusses notational and visualization aspects, assessment of software artifacts for variability, design of architectures and components for variability, usage of variation points while configuring instantiated software artefacts and, finally, some advanced issues including variation versus composition.

Attendee Background

It is assumed that the participant has some experience with industrial software development and has a general awareness of the increased importance of software variability.

Tutorial Objectives

The tutorial presents insights gained, techniques developed and lessons learned in the European IST project ConIPF (Configuration in Industrial Product Families) and in other research performed by the software engineering research group at the University of Groningen. The tutorial first establishes the importance of software variability management, defines the concept of variability, discusses notational and visualization aspects, assessment of software artifacts for variability, design of architectures and components for variability, usage of variation points while configuring instantiated software artefacts and, finally, some advanced issues including variation versus composition.

TA4

Software Architecture Documentation with the Unified Modeling Language (UML)

Authors

Paul Clements, Robert Nord , Software Engineering Institute, Judith Stafford, Tufts University

Paul Clements is a senior member of the technical staff at Carnegie Mellon University's Software Engineering Institute, where he leads or co-leads efforts in software architecture and software product lines. He is co-author of five books on software engineering, including Software Architecture in Practice, Evaluating Software Architectures: Methods and Case Studies, and Documenting Software Architectures: Views and Beyond. He has years of experience in teaching and speaking, having presented courses in software engineering, real-time systems, and software architecture in dozens of settings. He has also delivered dozens of keynote and other invited lectures. Clements received his Ph.D. in computer sciences from the University of Texas at Austin in 1994.

Robert L. Nord is a senior member of the technical staff in the Product Line Systems Program at the Software Engineering Institute (SEI) where he works to develop and communicate effective methods and practices for software architecture. Prior to joining the SEI, he was a member of the software architecture program at Siemens, where he balanced research in software architecture with work in designing and evaluating large-scale systems. He earned a Ph.D. in Computer Science from Carnegie Mellon University. Dr. Nord lectures internationally on architecture-centric approaches. He is co-author of Applied Software Architecture and Documenting Software Architectures: Views and Beyond.

Judith Stafford is an assistant professor in the Department of Computer Science at Tufts University, and is also a visiting scientist at the Software Engineering Institute, Carnegie Mellon University. Dr. Stafford has worked for several years in the area of compositional reasoning and its application to software architectures and component-based systems. She has organized workshops, given invited talks, taught tutorials, and written widely in these areas including several book chapters on software architecture and componentbased software engineering. In addition she co-authored the book, Documenting Software Architectures: Views and Beyond.

Abstract

Software architecture has become a widely-accepted conceptual basis for the development of non-trivial software in all application areas and by organizations of all sizes. Effectively documenting an architecture is as important as crafting it, because if the architecture is not understood, or worse, misunderstood, it cannot meet its goals as the unifying vision for software development. Development-based architecture strategies, such as Rational's Unified Process, stop short of prescribing documentation standards. The Unified Modeling Language (UML) provides a notational mechanism for describing certain architectural elements and relations, but comes up short when it comes to representing some standard architectural constructs.

There is a pressing need for a practical approach to software architecture documentation. This tutorial presents such an approach based on the well-known concept of views. We present the information in the context of prevailing prescriptive models for architecture, including the Unified Process and the upcoming UML 2.0, which promises to address architecture.

Attendee Background

Participants should have some knowledge of the Unified Modeling Language and experience with descriptions of large software systems.

Tutorial Objectives

The primary aim of this tutorial is to teach developers what constitutes good documentation of a software architecture, why it is worth the effort to create and maintain a documentation package, and how to write it down. We will provide practical guidance on how to capture an architecture that is independent of a particular language or notation. However, in order to make the presentation concrete and accessible to a wide audience, examples will be presented in UML, where possible. Other widely used notations will presented when UML needs to be supplemented. A secondary aim is to teach other stakeholders why they should care about architectural documentation and how they can use it to make their life easier, increase productivity, and decrease overall system development and maintenance costs.

TA5

Authors

Juha-Pekka Tolvanen, MetaCase

Juha-Pekka Tolvanen is the CEO of MetaCase. He received his Ph.D. in 1998 from the University of Jyväskylä, Finland. His area of expertise is in engineering of software development methods for application-specific needs. In this role, Mr. Tolvanen has acted as a consultant worldwide for method development and he has published papers on software development methods in several journals and conferences.

Abstract

Domain-Specific Modeling (DSM) provides a viable solution for improving development productivity by raising the level of abstraction beyond coding. With DSM, the models are made up of elements representing concepts that are part of the domain world, not the code world (like e.g. in UML). These languages follow domain abstractions and semantics, allowing developers to perceive themselves as working directly with domain concepts. In a fair number of cases - most often product family development - final products can be automatically generated from these high-level specifications. 

This tutorial introduces DSM by emphasizing the differences to modeling languages originating from the semantics of programming languages. This is followed by examples from various fields of software product development, with a special focus on product families. The main part of the tutorial addresses the guidelines for implementing DSM for various application domains: how to identify the necessary language constructs; what options are available for code generation; and what are the industry experiences.

Attendee Background

Attendees should have significant software development experience, not necessarily OO, must have used at least one methodology and design/generation tool.

Tutorial Objectives

The primary aim is to teach the principles of Domain-Specific Modeling.