Evaluating a Service-Oriented Architecture

Are you involved in the development of a service-oriented architecture (SOA), or are you considering this approach in your next project? Do you believe architecture evaluation is an important step in the software life cycle because, among other benefits, it detects problems that are hard to fix once the implementation is in place? If you answered "yes" to both questions, we invite you to attend this tutorial where we'll provide practical information for the architecture evaluation of an SOA system. We'll discuss how to describe the architecture, what architectural approaches are applicable, what questions and design considerations can be used to probe the architecture, and other aspects of architecture analysis—always looking at the specifics of SOA solutions. In this tutorial, the SEI Architecture Tradeoff Analysis Method (ATAM) is used as a reference for the steps, inputs, and outputs of an architecture evaluation technique.

Phil Bianco, Software Engineering Institute, Carnegie Mellon University

Philip Bianco holds a master's degree in software engineering from Carnegie Mellon University and a bachelor's degree with honors in computer science from the University of Pittsburgh. Currently, he conducts research in the area of software architecture for the Software Engineering Institute's Product Line Systems Program. His research topics include tools to assist Architects (ArchE), service-oriented architecture (SOA), and architectural enforcement.

Software Architecture for Safety-Critical Systems

The increasingly complex and integrated nature of software used in safety-critical systems presents software architects with new challenges. The traditional strategy of isolating safety-critical functionality from the rest of the system increasingly conflicts with other architectural goals such as performance, re-use, security and inter-operability. This tutorial will provide participants with insights from a system/software safety perspective about reconciling the stringent demands of safety requirements with other demands faced by software architects. The tutorial begins with an overview of the general safety requirements of a safety-critical system that must be addressed by software architects. One such requirement is highly deterministic behavior. Another requirement is the isolation of safety-critical functionality from other functionality so that a defect in the latter does not affect the former. Yet another general requirement is facilitation of specialized verification objectives that may be required for the certification of a safety-critical system, e.g., identifying the presence of unintended functionality. An understanding of these general safety requirements is essential for a software architect to make decisions that contribute to the overall goal of reducing safety risk. In addition to describing these general safety requirements, the tutorial will examine how these requirements are expressed in a variety of key safety-related standards, such as RTCA DO 178B and IEC 61508.

Dr. Jeffrey J. Joyce, Ph.D., P.Eng., Critical Systems Labs, Inc.

Dr. Joyce is the president and co-founder of an engineering consultancy, Critical Systems Labs Inc., that specializes in the specification, analysis and verification of software-intensive critical software. As a Senior Systems Engineer with Raytheon from 1994 until 2001, he worked on the development of the Canadian Automated Air Traffic System (CAATS). With clients from Europe, North America and Asia, Dr. Joyce and his associates have have worked with software architects in a variety of technical domains including aerospace, automotive. defense, rail and medical devices. He earned a Ph.D. in Computer Science from Cambridge University in 1990. In 2006, Dr. Joyce was named "Engineer of the Year" by the International System Safety Society.

Architecture and Agile Methodologies—How to Get Along

Agile development methodologies are growing in their adoption across a wide variety of industries. However, there is still significant concern and confusion surrounding how architects and central architecture initiatives can work with agile development teams. Indeed, there is some belief that fulfilling architectural objectives can not be accomplished using agile methods. This tutorial dispels such myths by describing specific techniques that have been successfully used on actual development programs to involve architects in agile development efforts. Attendees will learn about agile development methods first, with a particular focus on those methods that either present the greatest opportunities for architects or that are seen to be the most problematic. Using examples from the attendees, we'll step through specific techniques to show how agile development methods can successfully implement and incorporate architectural objectives and initiatives. As agile techniques continue to gain momentum, belief in the incompatibility of architecture and agile must be replaced with a practical understanding of how to make these disciplines and approaches consistent and effective together.

Rebecca Parsons, CTO ThoughtWorks

Rebecca Parsons currently serves and the VP of Global Innovation and the Chief Technology Officer for ThoughtWorks, a software consultancy. Over the past several years, she has worked as the chief architect on several large agile development efforts building complex distributed object applications. She earned her PhD at Rice University, with research interests in programming languages, computational biology, evolutionary computation, and parallel and distributed systems.

Security patterns and the design of secure architectures

Security is one of the most critical problems in current software development. Security patterns join the extensive knowledge accumulated about security with the structure provided by patterns to provide guidelines for secure system design and evaluation. They can help developers with little background on security build secure software. They are being adopted by companies such as IBM, Sun, and Microsoft. We show the anatomy of a security pattern, a variety of them, and their use in the construction of secure architectures. These patterns include Authentication, Authorization, Role-Based Access Control, Firewalls, Web Services Security, and others. We apply these patterns through a secure system development method based on a hierarchical architecture whose layers define the scope of each security mechanism. The patterns are shown using UML models and some examples are taken from my book Security Patterns: Integrating security and systems engineering (Wiley 2006).

Prof. Eduardo B. Fernandez, Florida Atlantic University

Eduardo B. Fernandez has published numerous papers on security models, and object-oriented analysis/design, including a book on security patterns. He has lectured all over the world at both academic and industrial meetings. He holds a MS degree in EE from Purdue University and a Ph.D. in Computer Science from UCLA. More details: http://www.cse.fau.edu/~ed.

Economics-Driven Architecting

Since software engineering artifacts exist to serve the business goals of an enterprise, optimizing the value of software systems is a central concern. However, software architects are not well equipped with techniques that can assist them in making value-based decisions. Existing techniques in software engineering economics address life-cycle practices, most of which focus on implementation and code-level activities. Equipping software architects with the ability to reason about software economics will provide them with the vocabulary and tools needed to make architectural decisions with confidence and to articulate the value-driven impact of architectural decisions. This full-day tutorial will provide researchers and practitioners with economics-driven techniques for making software architecture decisions. The tutorial will present proven, road-tested techniques for combining utility, quality attribute reasoning, and software architecture decision-making to best serve the business context. The tutorial format involves lectures, a case study where the techniques presented are applied in a real-world setting, and a hands-on exercise.

Ipek Ozkaya, Software Engineering Institute, Carnegie Mellon University
Rick Kazman, Software Engineering Institute, Carnegie Mellon University

Rick Kazman is a Professor at the University of Hawaii and a Visiting Scientist (and former Senior Member of the Technical Staff) at the Software Engineering Institute of Carnegie Mellon University. His primary research interests are software architecture, design and analysis tools, software visualization, and software engineering economics. Kazman is the author of over 100 papers, and co-author of several books, including Software Architecture in Practice, and Evaluating Software Architectures: Methods and Case Studies. Rick Kazman can be contacted at kazman(AT)sei.cmu.edu. Further information about Dr. Kazman can be found at http://www.sei.cmu.edu/staff/rkazman/.

Ipek Ozkaya is a Member of the Technical Staff at the Software Engineering Institute of Carnegie Mellon University. Her research interests include developing methods for improving software architecture practices focusing on software economics and requirements management. She received her PhD in computational design from Carnegie Mellon University in 2005. Ipek Ozkaya can be contacted at ozkaya(AT)sei.cmu.edu. Further information about Dr. Ozkaya can be found at http://www.sei.cmu.edu/staff/ozkaya/.

Introduction to SysML and Object Oriented Systems Engineering Methodology (OOSEM)

This Tutorial will provide an "introduction" to the evolving use of Object Oriented Methods for use by systems engineers. The Tutorial is split into two parts: 1) Introduction to SysML; 2) Introduction to an Object Oriented Systems Engineering Method (OOSEM) being worked within the International Council on Systems Engineering (INCOSE) OOSEM Working Group. OOSEM integrates a top down systems approach with object oriented concepts and modeling techniques. Using the widely known Unified Modeling Language (UML) and the recently adopted (by OMG) standardized extension for Systems Engineering (i.e., SysML), this method brings object oriented modeling to the systems engineering community, and adapts it for modeling systems-level requirements and design. OOSEM brings to Systems Engineering a technique for leveraging some of the advantages of OO to help architect more flexible, extensible, and upgradeable systems with new evolving technology. Another major goal of OOSEM is ease of integration with object-oriented methods for software engineering and integration with hardware engineering and other disciplines. Models developed by this method simultaneously serve the needs of systems engineers and facilitate the systems-to-software and hardware transition. OOSEM can thus serve as the systems engineering front end of an integrated method for systems, software and hardware development.

Abraham Meilich, Ph.D., C.C.P, Lockheed Martin Corporation

Dr. Meilich is an Enterprise Information Systems Architect at Lockheed Martin. His present position is Lead, Enterprise Architecture and Engineering in the Advanced Programs Organization. His professional focus has on the application of system engineering principles and best practices to enterprise architecture and systems of systems engineering to support the design of Net-Centric solutions for the DOD and modernization of government information systems.

Representing Application Architectures in Software Factories

This tutorial will explain the concept of packaging software development guidance and assets, and in particular the guidance about the application architecture, in the form of software factories. It will demonstrate, using specific examples, how application architectures were encoded in software factories, and show the tutorial participants that architectures can be effectively captured for reuse. The intended audience includes both the practicing architects and the software researches, who have heard about software factories, are intrigued yet skeptical about their viability and applicability, and would like to see a pragmatic view of how to use them to capture architectural, reusable, and actionable knowledge. "Application architecture" means many things to different people. In most cases application architectures travel in the heads of the architects from project to project. It is also left to the creativity of those architects to decide how to apply those architectures in every new context. On the other hand, the enterprise applications follow a few architecture patterns such as composite client, entity service, integration service, service buss, or portal. This tutorial will illustrate how such reusable, highly repeatable architectures can be captured in software factories. The tutorial is not about the example factories, but it is about the concepts underlying them, and about showing that we are ready, as the software engineering community, to codify architectures in tools. The tutorial will be a fast-paced presentation interleaved with working examples of factory platform, factory authoring and factories themselves.

Wojtek Kozaczynski, Microsoft

Wojtek Kozaczynski is Microsoft Principal Architect for Microsoft's Patterns and Practices Group. He has been with Microsoft for 4.5 years, working on the software factory platform and instances. Before Microsoft he worked, in reverse chronological order, for University of Illinois in Chicago, Andersen Consulting, SSA, and Rational Software. He has a PhD in information and decision sciences, and over 30 journal and conference publication. He has coauthored a book and contributed to another book.

An Introduction to Architecture-level Reliability Analysis

Today, dependability of software systems is as vital as the functionality they provide. Reliability - an aspect of dependability - represents the probability that the software system performs its intended functionality without failure. Similar to other dependability properties, reliability must be built into the software systems from the ground up. This requires methodologies, models, techniques, and tools that can be applied to various phases of the software development life cycle. Design decisions can have a critical impact on the reliability of software and systems. In this tutorial we present an overview of architecture-level software reliability modeling techniques. Attendees will learn how these techniques can be used to predict the impact of their architecture and design choices on the future reliability of the software system under development. These approaches will also help them make appropriate trade-offs among design choices based on their impact on the reliability.

Roshanak Roshandel, Seattle University
Nenad Medvidović, University of Southern California

Roshanak Roshandel is an Assistant Professor of Computer Science and Software Engineering at Seattle University. She received her Ph.D. in Computer Science from University of Southern California. Her research is in the area of architecture-based software development, architectural modeling and analysis, and dependability modeling of software systems. Her teaching experience spans over a variety of graduate courses in software engineering, more specifically software architecture, software reliability, software security, and distributed computing. She is a member of the Association for Computing Machinery (ACM), and ACM Special Interest Group on Software Engineering (SIGSOFT).

Nenad Medvidović is an Associate Professor in the Computer Science Department at the University of Southern California. He is a faculty member of the USC Center for Systems and Software Engineering (CSSE) and a faculty associate of the Institute for Software Research (ISR) at the University of California, Irvine. Medvidović received his Ph.D. in 1999 from UC Irvine. Medvidović is a recipient of the National Science Foundation CAREER award (2000), as well as the Okawa Foundation Research Grant (2005). Medvidović's research interests are in the area of architecture-based software development. His work focuses on software architecture modeling and analysis; middleware facilities for architectural implementation; product-line architectures; architectural styles; and architecture-level support for software development in highly distributed, mobile, resource constrained, and embedded computing environments. He has extensive teaching experience both in academia and industry covering a variety of topics in software engineering, software architectures, and distributed systems. He is a member of the Association for Computing Machinery (ACM), ACM Special Interest Group on Software Engineering (SIGSOFT), and the Institute of Electrical and Electronics Engineers (IEEE).