WICSA/ECSA 2009 is offering 5 half-day tutorials on Monday, 14 September. Be sure to sign up when you register. Limited space available.
instructors: Anna Liu and Dr. Hye-young Paik, Univ of New South Wales, Australia
There is an emergence of cloud computing application development platforms such as Microsoft Azure, Google's AppEngine and Amazon's EC2/SimpleDB/S3. Startups and enterprise developers alike, lured by the promise of 'infinite scalability', 'ease of development', 'low infrastructure set up cost', are increasingly using these cloud service building blocks to construct their web based application, that in turn consume and deliver services. In this tutorial, we firstly present the motivation for cloud computing, and the common myths surrounding this hot topic, and also how enterprises and startups should think strategically about cloud computing. Then, we take a deep dive into the 3 leading cloud application platforms: MS Azure, Google App Engine, and Amazon WS, and provide an overview of these cloud computing application development environments and platforms. We will demonstrate the programming, debugging and monitoring capability, and use performance evaluation techniques to motivate the analysis of underlying platform architecture, and point out the capabilities (and deficiencies) of the current platforms. We will then present a set of architecture primitives that enables the design and development of cloud applications that achieves certain quality goals: including data consistency, performance, manageability, reliability and scalability quality attributes.
instructor: Juha-Pekka Tolvanen, MetaCase, Finland
Domain-Specific Languages and Model-Driven Development have moved from scattered successes, through industry hype, to increasingly widespread practical use. Well-attested benefits include raising the level of abstraction, improving productivity, and improving quality. The main questions are no longer what or why, but where and how. This tutorial will teach participants about Domain-Specific Modeling and code generation, where they can best be used (and where not), and how to apply them effectively to improve your software development.
This tutorial introduces DSM and looks at how it differs from modeling languages like UML that focus more on the level of the code world. This is followed by real-life examples of DSM from various fields of software development. The main part of the tutorial addresses the guidelines for implementing DSM: how to choose where to use it, how to identify the domain concepts and formalize them into a metamodel, different ways of building code generation, and how to integrate generated code with legacy or manually-written code. Participants will have the chance to learn practical skills in language creation and modification exercises.
when: Monday, 14 September 2009, 9:00 – 12:30
instructor: Olaf Zimmerman, IBM Research GmbH, Switzerland
Software architects view systems under construction from multiple viewpoints such as the 4+1 logical, development, physical, process, and scenario viewpoints. Their methods and tools typically center on these structural viewpoints. The capturing of architectural decision rationale, however, is another essential viewpoint, which only recently has become a software architecture research topic. Unfortunately, most of the emerging architectural decision modeling tools only support the retrospective capturing of decisions made; they do not support a proactive modeling of decisions required (issues) and available solutions (alternatives). This limits the opportunities for reuse.
In this tutorial, we first present two large-scale industry projects to motivate the benefits of proactive architectural decision modeling. Next, we introduce a meta model which separates decisions required from decisions made to support reuse. As meta model instances, we present excerpts from a 400-node Service-Oriented Architecture (SOA) decision model harvested from full lifecycle projects since 2001: We investigate selected SOA design decisions such as the selection of integration style and message exchange patterns, session management and request correlation, and the design of business and system transaction boundaries. After that, we demonstrate how to capture decisions required and their alternatives in Architectural Decision Knowledge Wiki, a Web 2.0 collaboration system and application wiki supporting decision maker collaboration over the Web. Meta model, reusable SOA decision model and application wiki jointly support real-world usage scenarios such as project team education, architecture design method support, facilitation of technical quality assurance reviews, and IT governance.
when: Monday, 14 September 2009, 13:30 – 17:00
instructor: Raghvinder Sangwan, Pennsylvania State University, USA
Complexity, in its many forms, is a systemic property of a system, indeed it is an emergent property that arises from the interdependence and interconnectivity of the system, both structurally and dynamically. Consequently, an appropriate approach to system development likely to keep excessive complexity in check must be systemic. Mainstream design methodologies such as Object-Oriented Analysis and Design (OOAD), however, treat systemic properties only indirectly or implicitly. The quality of systems developed using such methodologies, thus, depends largely on the skill level and experience of its architect. It has been suggested, therefore, that augmenting these methodologies with software architecture-centric methods such as the Quality Attribute Workshop (QAW) and Attribute Driven Design (ADD) can provide explicit and methodical guidance to an architect in creating systems with desirable qualities.
In this tutorial, we will first go through the exercise of applying OOAD techniques (use case analysis, domain modeling, and component-based design) for creating the architecture for a system from the building automation domain. We then use the techniques prescribed by the architecture-centric methods (quality attribute workshop and attribute driven design) for creating the architecture for the same system. These two exercises are used to clearly demonstrate the shortcomings of OOAD. We finally demonstrate how OOAD can be augmented with architecture-centric methods to overcome these shortcomings.
instructor: Marco Bernardo, Univeristy of Urbino, Italy
Despite its strengths like compositionality, abstraction, and analyzability, process algebra is rarely adopted in the practice of software development. After recalling the basics of process calculi and behavioral equivalences, this tutorial addresses the usability issue for process algebra by providing a set of guidelines inspired by the software architecture level of design. The aim of these guidelines is to enforce a clear component-oriented approach to the process algebraic modeling of system families, thus resulting in a fully fledged architectural description language.
In order for a process algebraic architectural description language to be effective, component-oriented modeling must be accompanied by component-oriented analysis. On the functional verification side, this tutorial presents some topology-related techniques based on equivalence checking for the detection of architecture-level mismatches and the provision of diagnostic information to be exploited for modififying in-house components or synthesizing wrappers/adaptors for off-the-shelf components. On the performance evaluation side, this tutorial illustrates a procedure for the prediction, improvement, and comparison of the performance of software architectures formalized with a process algebraic description language, which relies on the use of queueing network models.