Software Architecture (SENG 422/SENG522)

Summer 2005

Instructor:

Dr. Issa Traore, P. Eng.

Phone: (250) 721-8697
E-mail: itraore@ece.uvic.ca

Office hours: Monday, Thursday: 11:00am- 12:30pm
Location: EOW 415

Time/Location:
ELL 061, 1:00-2:30pm, Monday, Thursday.

Students are advised to read the faculty of Engineering document Standards for professional behavior (http://www.engr.uvic.ca/policy/professional-behaviour.html), which contains important information regarding conduct in courses, in labs and in the general use of facilities.

Course Description

This course introduces to the concepts, principles and standards underlying modern software architecting. Notions and practice of some of the most popular notations, techniques and tools involved in the different steps of software architecting are given. More specifically UML for the requirement specification phase, UML and CORBA-IDL for the design phase, and CORBA-IDL and Java/C++ for the implementation. The basic concepts, techniques and tools of software component-based development are introduced.

Lab works will consist of a mainstream project aimed at the design and implementation of an actual software system, using the techniques, tools and notations introduced in the course. That will be carried out through successive mini projects, each corresponding to specific steps in the course. The initial lab sessions will consist of analyzing the requirements of the corresponding system. Then during subsequent sessions, we will build step by step the system, by focusing mainly on the aspects concerned with software architecting. At the end of the course each student should come up with the implementation of a specific component.

Prerequisites:

-Notions of requirements and design specifications.

-Programming knowledge in Java and C++.

Textbook:

The main text for this course consists of a draft book, which will be made freely available through a secure weblink accessible only to students registered in SENG422/SENG522.

"Quality-Driven Software Architectures-How to Design Dependable Systems", by I. Traore and J.H. Janhke, (draft book).

Reading List

Further Reading:

1. The Unified Modeling Language User Guide, by Grady Booch, James Rumbaugh, Ivar Jacobson, Addison-Wesley, 1999.

2. Inside CORBA: Distributed object Standards and Applications, by Thomas Mowbray and William Ruh,Addison-Wesley, ISBN: 0-201-89540-4

3. Large-Scale, Component-Based Development, by Alan W. Brown, Prentice Hall, 2000, ISBN: 0-13-088720-X.

4. Software Architecture in Practice, by Len Bass, Paul Clements, Rick Kazman, Ken Bass. Addison-Wesley.

5. Pattern-Oriented Software Architecture (Part I), A System of Patterns, by F. Buschmann, R. Meunier, H. Rohnert, P. Sommerlad, M. Stal, Wiley, 1996, ISBN: 0 471 95869 7

Required Software:

Rational Rose, Orbacus (for CORBA Development)

Programming Languages:

- Java
- C++

Syllabus

Lectures:

Chapter 1: Introduction to Software Architecture

Introduce software architecture with primary emphasis on the IEEE Recommended Practice for Software Architecture description. Concepts covered include:

Views and Viewpoints.
Place of software architecting in the whole software life cycle.
Discussion of the issues surrounding modern software architecture: abstraction, reusability etc.

Presentation of the decisions making process leading to architecture definition.
Presentation of the interlocking views underlying the architecture of a software intensive system.
Presentation of an Architecture Description Language (ADL): the UML.

Introduction of the Rational Unified Process: overview of the 4+1 views of software architecture: use case, logical, process, implementation, and deployment views.

Chapter 2: Use Case View

Notation and documentation of the Use Case View of Software Architecture.

Chapter 3: Logical View
Notation and Documentation of the Logical view of Software Architecture.

Chapter 4: Design Planning
Introduction to the processes of tradeoff and risk analysis that prelude and guide the design of a resilient software architecture. Identification of factors and quality attributes that characterize a system; identification of underlying design issues, and suitable design strategies.

Chapter 5: Implementation, Process, and Deployment Views
Notation and Documentation of the Implementation, Process, and Deployment Views.

Chapter 6: Using Metrics to Manage Software Risks
Presentation of software metrics, and how they can be used to measure quality factors such as testability, maintainability, reusability and so on.

Chapter 7: Patterns
Presentation of commonly used architectural styles and patterns. Overview of design patterns. Introduction of the techniques and notations provided by the UML for modeling design and architectural patterns.

Chapter 8: Introduction to CORBA
Introductionto distributed systems and discussion of the issues surrounding distributed architectures; presentation of the CORBA standard as an example of Distributed Object Architecture (DOA).

Chapter 9: CORBA-IDL
Presentation of CORBA Interface Definition Language (IDL).

Chapter 10: Designing CORBA Systems
Techniques used to derive a CORBA System from an OO design.

Chapter 11: Implementing CORBA Applications
Steps and methods followed in implementing a CORBA object-based application. Discussion of issues surrounding distributed objects location in the network. Presentation of CORBA Naming and Trading services as medium for locating distributed CORBA objects.

Chapter 12: Introduction to Software Component-based Development
Introduction to component-based design (CBD); link with software architecture. Components, connectors and protocols design using the UML. Insight into standard component models.

Chapter 13: CORBA Component Model (CCM)
Presentation of the CORBA Component Model (CCM); Extended IDL for CCM; CIDL code for CCM; Implementation issues and examples.
Chapter 14: Specialized Software Architectures

This chapter will consist of presentations on various issues surrounding or influencing software architecture. Selected topics among the following issues will be covered:
- Real-time architecture design
- Fault-tolerant architecture design
- User interface design
- Integration of legacy systems in a software architecture
- Embedded systems architecture design
- Secure software architecture design
- Version-control and configuration management (VCCM)
- Project management (PM) and software architecture

Lab:

Lab sessions are scheduled on Thursdays and Fridays from 2:30 to 5:30.
The course project is divided in 6 small components that will be performed during the different lab sessions; there are, in principle, 7 lab sessions. The project consists of the design and implementation of the software architecture of a Weather Mapping System (WMS). Implementation will take place both in Java and C++ (combination of both languages).
Each lab assignment consists of a theoretical part and a practical part, which are defined in specific lab assignment statements that are posted at least one or two weeks before the session.
Report and demo. (if applicable) for each assignment is due for the following session.

Session 0: Tool Presentation
This session is an introductory session; there is no lab assignment for this session.

Introduction to working with an industrial strength software development environment, namely Rational Rose: how to write and maintain a UML specification; configuration management; architecture design; CORBA-IDL document generation; Java code generation from a UML model etc.
Presentation of the Project: Weather Mapping System.

Session 1: Use Case View
Design of the Use Case View. Risk Analysis.

Session 2: Logical View
Design of the Logical View of the Weather Mapping System (WMS).

Session 3: Integrating Patterns in the Architecture
Integration of selected architectural and design patterns in the logical view obtained previously.

Session 4: Implementation, Process, and Deployment Views
Design of the implementation, process, and deployment views for the Weather Mapping System.

Session 5: Component and Interprocess Communication Design
Generation from the previous architecture design of CORBA Interfaces and Components Definitions.

Sessions 6: Implementation of WMS
Implementation of the Weather Mapping System (Java & C++), with a particular emphasis on the interprocess communication mechanism and the software components identified.

Lab Reports:
Lab reports should include:

The answers to the questions included in the assignment statement. The answers should motivate briefly your design choices.
The printout of the diagrams and related documents (e.g. class, use cases, operations descriptions etc.) produced using Rational Rose.

Schedule

The dates given are subject to change, so you are responsible for checking this page regularly.

Lectures:

Weeks	Units
2-6 May 9-13 May	Chap 1: Introduction to Software Architecture Chap 2: Use Case View Chap 3: Logical View
16-20 May	Chap 4: Design Planning
May 23	Victoria Day
23-27 May	Chap 5: Implementation, Process, and Deployment Views
30 May - 3 June 6-10 June	Chap 6: Using Metrics to Manage Software Risks Chap 7: Patterns
13-17 June 20-24 June	Chap 8: Introduction to CORBA Chap 9: CORBA-IDL Chap 10: Designing CORBA Systems
June 27	Midterm Exam
June 30	Reading break
4-8 July, 11-15 July	Chap 11: Implementing CORBA Applications Chap 12: Introduction to Software Component-based Development Chap 13: CORBA Component Model (CCM)
18-22 July	Chap 14: Specialized Software Architecture
25^th July	Review-Final exam preparation
29^th July	Project demo (Place: SEng Lab)

Lab:

Lab 0: 19/20 May
Lab 1: 26/27 May
Lab 2: 2/3 June
Lab 3: 9/10 June
Lab 4: 16/17 June
Lab 5: 7/8 July
Lab 6: 14/15 July
Lab 7: 21/22 July (dedicated to the project)

Exams:

Mid-term: June 27th, 2005.

The midterm is open book and will cover chapters 1-7

Final: FRI 05 AUG 9:00 AM UVC A180

The final exam is open book and covers all the chapters.

Evaluation

Lab project is done by team of 2 students for SENG 422 and by team of 1 student for SENG 522.

Activity	Weight
Lab Assignment 1: Use Case View (due 2/3 June )	5%
Lab Assignment 2: Logical View (due 9/10 June)	5%
Lab Assignment 3: Implementation, Process, and Deployment Views (due 16/17 June)	5%
Lab Assignment 4: Patterns (due 7/8 July)	5%
Lab Assignment 5: Component and Interprocess Communication Design (due 14/15 July)	5%
Project: Implementation of WMS (report/demo due 29 July)	10%
Mid-Term Exam (June 27th, 2005)	20%
Final Exam (FRI 05 AUG 9:00 AM UVC A180)	45%

Grading
The final grade obtained from the above marking scheme will be based on the following percentage-to-grade point conversion:
90<= A+ <= 100
85<= A < 90
80<= A- < 85
75<= B+ < 80
70<= B < 75
65<= B- < 70
60<= C+ < 65
55<= C < 60
50<= D < 55
         E < 50 Fail, conditional supplemental exam
         N         Fail, did not write examination or otherwise complete
                     course requirements by the end of the term or session;
                     no supplemental examination.

Special Notice for SENG522 Students

Students registered in SENG522 will follow the same lectures as students in SENG422. The main difference between both courses will concern the evaluation method. There is no mid-term exam for SENG522; instead the students will make a presentation on specialized software architectures such as real-time systems software architectures. Each student will select a topic (see chapter 17), and prepare his presentation by following specific guidelines. The presentation will take place during chapter 17.

Lab Assignments, and final exam are the same for both courses, except a difference in teams composition:
-Assignment team: 1 student by team.

The following evaluation scheme will be used for SENG522:

-(Lab) Assignments: 25% (with the same breakdown as for SENG422)

-Project: 15%

-Seminar: 10%

-Final Exam: 50%