Tutorial 1 (full day)

Architectural rendering with ISO/IEC 42010

IEEE Standard 1471, Recommended Practice for Architectural Description of Software-Intensive Systems, was published in 2000 as the first standard aimed at architecture description. In 2007, it was adopted by ISO and since then has been jointly updated by IEEE and ISO as ISO/IEC/IEEE 42010, Systems and software engineering — Architecture description.

This tutorial introduces the key concepts and mechanisms of the newly revised standard, in the context of practical approaches to architectural rendering of software-intensive systems. The tutorial presents the fundamentals of architecture description including: key concepts and requirements on architecture descriptions; codifying architecture frameworks and architecture description languages; and the role of architecture description in architecting and analyzing software-intensive systems. The recent joint revision of the standard by IEEE and ISO adds several new features presented in-depth here for the first time.

The tutorial begins with history and background of the development of the standard, and then focuses on the conceptual framework for architecture description on which ISO/IEC/IEEE 42010 is based. On this foundation, the tutorial introduces and motivates the key elements of architecture description, including: content requirements for architecture descriptions, stakeholders and their concerns, architecture views and viewpoints, architecture frameworks and architecture description languages and architectural modeling.

Case studies will emphasize a wide range of architectural concerns, both technical and managerial, and address a range of representation issues pertaining to: aspects and perspectives, patterns and styles, architecting multiple systems and product lines; defining viewpoints and frameworks; and decision and rationale capture.

The tutorial is intended for anyone with an interest in representation, modeling and analysis of software architectures.

Presenter’s biography:

Rich Hilliard is a freelance consultant in software architecture and software engineering to public and private sector clients. He is project editor of ISO/IEC 42010 and served as editor of its predecessor, IEEE Std 1471:2000 (for which he received the IEEE Computer Society’s Outstanding Contribution Award). He is a member of IFIP Working Group 2.10 on Software Architecture. He is a visiting scholar at Massachusetts Institute of Technology, Experimental Study Group. Rich is member of the IEEE Computer Society, the Free Software Foundation and an officer of the League for Programming Freedom.

Tutorial 2 (full day)

The DCI Architecture: Lean and Agile at the Code Level

Agile favors "working software" rather than software that meets user expectations, and it "responds to change" rather than plans for change. Agile has slid away from these broader business principles that can be found in its object-oriented roots, including capturing the end-user conceptual model in code. This talk overviews how the DCI architecture implements the vision of Lean and Agile in achieving business goals. Based on the new book "Lean Architecture and Agile Software Development."

  1. Definitions: Lean, Agile, Architecture
  2. Motivating the need for up-front planning
  3. Mental models and Model-View-Controller
  4. BeYond MVC: The Elements of Architectural Form
  5. What the system is: ABCs and domain dictionaries
  6. What the system does: use cases
  7. The OO crisis and DCI
  8. Roles and DCI Implementation
  9. DCI advantages
  10. The process
  11. Advanced topics (optional) — nested contexts and habits
  12. Conclusion
Presenter biography:

Jim ("Cope") Coplien is the father of Organizational Patterns, is one of the founders of the Software Pattern discipline, a pioneer in practical object-oriented design in the early 1990s and is a widely consulted authority, author, and trainer in the areas of software design and organizational improvements.

As one of the founders and proponents of Agile software development, one of Cope's passions is to root out dysfunction in widely but naively adopted software practices such as TDD and On-Site Customer, that look good on the surface but which do harm in practice. He also is actively leading the work in Agile Architecture in conjunction the Scrum community. Most recently he has been working with Trygve Reenskaug to take the DCI architecture forward. He sits on the editorial board of the LNCS Pattern Journal. He is certified as a CSM, CSP, and CST.

Tutorial 3 (half day)

Requirements Engineering Meets Architecture - An Integrated Approach

Traditionally, requirements engineering and architecture are two software engineering disciplines sharing on the one hand lots of goals, but, on the other hand, are treated separately within mostly disjoint research communities. Theoretically, the requirements engineer’s task lies in the problem domain – find out WHAT the system is supposed to do. The architect’s task lies in the solution domain – find out HOW the system should achieve the WHAT. Often, Requirements Engineering has to consider the solution domain, e.g. by sketching technical constraints and Architects have to take care for the problem domain too, e.g. by considering which are the most important quality requirements. But there is no integration of RE and Architecture tasks.

With this tutorial, we want to improve the situation. By showing how requirements engineering (RE) can be done to fulfill the architects’ information needs and we want to show how architects can use requirements information to support their activities: communication, decision making, quality assessment, documentation, and knowledge acquisition. We want to bring together the lonesome architect and the loquacious requirements engineer.

This tutorial aims at bringing together requirements engineering and architecture from the architecture viewpoint. So, on an abstract level the topics that this tutorial covers are:

  • The Information needs of architects for architecture development
  • Information that can be provided from requirements engineering with a task-oriented approach
  • Information that can be used during architecture creation: How to do stakeholder and scenario analysis and make optimal use of requirements engineering information
Presenter biography:

Isabel John is a senior engineer at Fraunhofer IESE. She works in several research and industrial projects in the context of requirements engineering, architecture. Software product lines, and service oriented engineering. She has given several presentations and tutorials on different topics at Software Engineering conferences and in industrial context. Depending on the project context, she is both – a requirements engineer and an architect.

Anne Gross is a researcher at Fraunhofer IESE with focus on requirements engineering for information and interactive systems. In industrial projects she gained experience in analyzing and evaluating specification documents with regard to standard conformity and providing appropriate teaching. Her research interests include empirical investigations of requirements specification methods and techniques.

Tutorial 4 (half day)

Architecting Multi-Agent Systems

Modern distributed software systems such as Web-based e-commerce, intelligent transportation systems, and power grids pose huge engineering challenges. As these systems interact with one another, they necessarily become decentralized. The underlying system components and collaborations change over time, often in unanticipated ways. The systems must therefore make adaptations at runtime—that is, they need to be self-adaptive. Engineering such systems requires concepts, methods, and infrastructures beyond what current practice offers.

Multi-agent systems belong to a class of decentralized systems in which each component (agent) is an autonomous problem solver, typically able to operate successfully in various dynamic and uncertain environments. These agents interact to solve problems that are beyond their individual capabilities or knowledge. Multi-agent systems have features that are key to engineering self-adaptive systems— specifically, loose coupling, context sensitivity, and robustness to failures and unexpected events.

The goal of this tutorial is to provide an introduction to architecture-based design of multi-agent systems. The content of the tutorial is based on +8 years of extensive experience with building real-world multiagent systems. The material is illustrated with running examples from the tutor’s practice. Illustrative examples include a didactic robotic application, an intelligent traffic monitoring application, a distributed supply-chain management system, and an industrial automated transportation system consisting of a number of automatic guided vehicles transporting loads in an industrial environment.

The tutorial will give the attendees a thorough insight in architectural design of multi-agent systems. Attendees will understand the added value of multi-agent system architecture, but also the costs and implications that come with adopting a multi-agent system.

Presenter biography:

Danny Weyns is a post-doctoral researcher at KULeuven. He received a Ph.D in Computer Science in 2006 for research on multi-agent systems and software architecture. His main research interests are in software architecture, multi-agent systems, self-adaptive systems, and middleware for decentralized systems. Danny published over 100 refereed papers on these subjects and is author of the book “Architecture-Based Design of Multi-Agent Systems” that will be published by Springer in April 2010. Danny instructs courses at the Department of Computer Science of KULeuven on software architecture, autonomic computing, and self-adaptive systems.

Tutorial 5 (half-day)

Software Architecture Knowledge Management in Practice

Software architecture is the manifestation the major early design decisions made for a software-intensive system. These decisions in turn will determine much of the system’s development, deployment and evolution. Making better architectural design decisions is a key challenge in software engineering, made even more difficult by the complexity and heterogeneity of the systems we want to develop, and the distribution of the development teams. Great gains in efficiency and quality can be achieved when organizations can capture, capitalize and then transfer software (and system) architectural knowledge. This tutorial presents the challenges, introduces a conceptual framework for architectural knowledge management, and describes practices, methods, and tools for software architects to manage efficiently the vast amount of information necessary to make enlighten architectural design decisions.

Presenter Biography:

Philippe Kruchten is professor of software engineering at the University of British Columbia in Vancouver, Canada, which he joined in 2004 after a 30+ year career in the software industry, developing systems in telecommunications, defense and aerospace. His main interests are in software architecture, software project management and software development processes. During his time with Rational Software (now IBM) he led the development of the RUP, which embeds an architecture-centric method. He is the co-founder and secretary of the IFIP WG2.10 on Software Architecture.

Paris Avgeriou is Professor of Software Engineering at the Department of Mathematics and Computing Science, University of Groningen, the Netherlands. He has co-organized more than 10 international workshops in conferences such as ICSE, ECOOP, ICSR, UML, ACM SAC. He serves in the PC of several international conferences and is the general chair of the European Pattern Languages of Programming (EuroPLoP 2010) conference.

Call for tutorial proposals (closed)