summer school
TC2 on Software
 
> Presentation Descriptions:

Designing Software Architectures to Achieve Quality Attribute Requirements by Len Bass

I will describe the principles involved in the design of software architecture. The premise is that the design of software architecture is determined by the quality attributes requirements for a system. The quality attributes that we have focused on are: availability, modifiability, performance, and usability.

Our premise leads us to
1. specifying the quality attribute requirements in a common form
2. cataloging design primitives that support the achievement of each quality attribute, and
3. having mechanisms for managing trade offs among the attributes.

 
View-Oriented Representation of Software Architectures by Paul Clements
 

A software architecture for a system is the structure or structures of the system, which comprise elements, the externally visible properties of those elements, and the relationships between them. The software architecture for a system largely determines the system's quality attributes such as performance or modifiability, and it serves to constrain and guide the implementation. The software architecture serves as the vehicle for negotiating tradeoffs among requirements and stakeholder needs, and for tracking progress of teams. In order for the architecture to serve all these important roles, it must be effectively communicated -- that is, written down -- so that everyone who uses it can understand it. Hence, architecture documentation has emerged as a critical part of the architecting process. Modern treatments of architecture take a view-based approach, and in this session we will present a view-based documentation approach developed at the Software Engineering Institute for capturing software architectures. We will cover a set of very useful views and show how to capture each one using UML and other notations. Finally we will discuss a procedure for choosing which views of an architecture to capture in its documentation.

 
Evolution of software composition mechanisms by Carlo Ghezzi

Software has been evolving from pre-defined, monolithic, centralized architectures to increasingly decentralized, distributed, dynamically composed federations of components. Binding mechanisms have been evolving from static to highly dynamic schemes based on discovery, negotiation and optimization. The talk surveys the evolution of software composition mechanisms, from "in-the-small" embedded environments to "in-the-large" environments like web services.

 
Program Debugging and Profiling by Nigel Horspool
All developers strive for error-free software, but good programming practices can only go so far in reducing the number of bugs and their impact. This tutorial goes a step further in categorising bugs, discussing ways of tracking down elusive bugs, and presenting the modern tools that are available. We will explore the features of a typical debugger, examine how a debugger works, and show how to use a debugger effectively when tracking down bugs. In addition, we will look at the features available in modern languages for instrumenting potentially incorrect code, such as assert statements, exception handlers and checked modifiers. For practical demonstrations with debuggers, we will use Eclipse to debug Java code and Visual Studio to debug C# code.
 
An Introduction to Strategic Software Engineering by Rick Kazman
A strategic decision (as opposed to a tactical one) is one that helps plan for and achieve particular project-wide cost, schedule, and quality goals as they are subject to benefit, value, and risk factors. A strategic decision-making perspective is a crucial foundation to any mature business process (software or otherwise), because it helps to set a context in which rational tactical decisions can subsequently be made. Computer science and software engineering have historically been more focused on tactical decisions than strategic ones. This is slowly changing, and the field of software architecture is a good example of this change in focus. In this tutorial I will describe the underpinnings of strategic software engineering and exemplify its use with examples and method centered around software architecture analysis.
 
Model-based design and analysis of concurrent and distributed programs by Jeff Kramer

The wide acceptance of the Java programming language with its built-in concurrency constructs means that concurrent programming is no longer restricted to the minority of programmers involved in operating systems and embedded real-time applications. Concurrency is useful in a wide range of applications. Errors in these applications and systems may be life threatening, adversely affect our quality of life or may have severe financial implications. An understanding of the principles of concurrent programming and an appreciation of how it is practiced is essential for software engineering professionals. This tutorial takes a model-based approach to the design of concurrent and distributed programs. The models, based on finite state machines, provide insight into the composite behaviour of the programs, and can be automatically analysed to check various properties before implementation. The approach, concurrency concepts and analysis will be demonstrated through a series of examples and using the LTSA toolkit. In addition, current research work in the area will be discussed and demonstrated.

 
The Practice of Eiffel and Design by Contract by Bertrand Meyer

The Eiffel method promotes the construction of quality software through a number of principles such as seamless development, to ensure the continuity of the software process, and Design by Contract. It takes advantage of object-oriented techniques including multiple inheritance and genericity, and covers the entire lifecycle. This set of lectures presents an in-depth introduction to the method and its applications, sufficient to start building quality reusable components and perform contract-based analysis and design.

Hardware and Software Co-design for Embedded Systems by Micaela Serra

Hardware-software codesign is a recent research area whose biggest focus is to facilitate the design of small embedded systems, that is, those consisting of a microprocessor (such as DSP), for which software is required, plus one or more semicustom ASICs or FPGAs (field programmable gate arrays). Codesign methodologies are intended to give relief to designers struggling with ad hoc divisions of hardware and software components, and the attendant integration problems. Their purpose is to streamline the design process, thus reducing design costs and shortening time-to-market; to optimize the hardware/software partitioning, thus reducing direct product costs; and to ease integration, by automatically generating hardware/software interfaces.

 


hosted in South Africa  webdesign by Clements Solutions