582420 Middleware -- course contents and working instructions
Module I: Introduction
The aim of this module is to get acquinted with the role of middleware, its common services, and learn to identify different types of middleware.
TODO:
- See learning goals of themes "Roles of middleware" and "Relationship of software architecture, software engineering process and tools, and middleware"
- Read (links available in the material section!)
- Chapters "Introduction", 6.1-6.2 from the textbook
- [intro1] Bakken, D. E., Middleware. Encyclopedia of Distributed Computing. Kluwer Academic Press, 2001.
- [intro2] Bernstein, P. A, Middleware. CACM, Feb 1996.
- [intro3] Campbell, A., Coulson, G., Kounavis, M. E., Managing Complexity: ^M Middleware Explained. Distributed Computing. IT Professional, Volume: 1 , Issue: 5 , Sept.-Oct. 1999, Pages 22 - 28.
- [intro4] Charles, J., Architectures for Distributed Systems: Open Distributed Processing Reference Model.
- Some background slides: Introduction
- Learn to explain the following terminology
- Types: RPC-oriented, MOM-oriented (message passing systems), transactional middleware, object middleware, component middleware, service-oriented middleware,
- Layers: see the layers illustrated by Schmidt
- Key concepts: remote object, difference between object and component, transparencies,
- Write a learning diary entry for the following topics:
- What does the concept middleware mean?
- What kind of middleware exists? What is the main contributio for application support introduced by each of them? What differentiates between them?
- What is the relationship between software engineering tools and runtime middleware?
- What questions were left unanswered? Return to this list of yours as the topics are addressed in more detail.
Module II: ODP reference model
The aim is to learn to use a neutral framework to compare different middleware solutions (or any distributed system in general). The goal is not to create formal definitions of these systems, but to find some common terminology independent of the systems themselves, and to use a set of viewpoint-driven questions to be discussed about each system.
TODO
- See learning goals of themes "Relationship of software architecture, software engineering process and tools, and middleware"
- Some introductory slides: the ODP reference model
- Read (links available in material section!)
- Kutvonen, L., Architectures for Distributed Systems: Open Distributed Processing Reference Model. HeCSE Workshop on Emerging Technologies in Distributed Systems. Lammi, Finland, January 1998. Helsinki University of Technology, Digital Systems Laboratory, Series A, Number 50. March 1998.
- Note
- concept of partial, but overlapping specifications of the same system under construction from different viewpoints;
- identifying the contribution of ODP as a general framework directing consoria like OMG, setting shared vocabulary
- model for distributed computing platform (engineering viewpoint),
- transparencies
- Write a learning diary entry for the following topics:
- RPC mechanism seen through the ODP viewpoints; in order to do that you may need to cover message-oriented and procedure-oriented ideas as covered in the next item
- What each of the presented transparencies mean and at least one mechanism that supports each transparency
- Is distribution transparency always preferrable or achievable?
Module III: Message-oriented and procedure-oriented middleware
The aim of this module is to get to know message oriented and procedural middleware, and to recall what kind of mechanisms can be used for addressing faulty communication channels or faulty processing units.
TODO
- See learning goal "Different types of middleware"
- Some ideas on slides: RPC and MOM
- Read from the textbook
- Chapter 1 on Message-oriented middleware and note a) use of message queues for reliable communication b) various communication models supported c) synchronous vs. asynchronous communication
- Procedural middleware in Chapter 1 (and as discussed on lectures) a) communication semantics and methods of arranging for them (maybe, at least once, at most once) b) idempotent operations c) methods of identifying failures; basic methods of recovery: timers, retries, incarnation numbers, replication, orphan detection c) programming language based and IDL based RPC
- Return to your learning diary with ODP viewpoints of the RPC scheme and focus on the engineering viewpoint view: how different recovery mechanisms are realised
- How reliable multicast with total ordering is implemented?
- Is it possible to mask both messaging and processing failures at the same time? Why?
Module IV: Object and component middleware
The aim of this module is to get to know object middleware basics through the example of CORBA objects on one hand, and on the other hand extend that view to component middleware.
TODO
- See learning goals of "Different types of middleware"
- Read from the textbook chapter 17 the pieces relevant for understanding the basic CORBA architecture and basic vocabulary (bus/core, object, interface, IDL, object reference, stub, skeleton, DII, DSI, object adapter, GIOP, services such as time, event notification, naming, streaming, lifecycle, concurrency, logging, trading, property.
- Slides on CORBA object arhcitecture may be helpful
- Write learning diary entries for
- goals and services of object middleware
- concept of dynamic binding, and services required for its implmeentation,
- management of interface information and use of the interface information.
- Write learning diary entry describing CORBA object bus using the ODP viewpoints; put the description side-by-side with the RPC description - what do you find as added value here?
- Read from the textbook chapter 6 the pieces relevant for understanding the CORBA component architecture and basic vocabulary (component reference, external interface, callback interface, internal interface, component home, container, POA, facets, event sink and sources, receptacles) and additional services (component packaging and deployment, different operational policy modes)
- Slides on CORBA component arhcitecture may be helpful
- Write learning diary entries for goals and services of component middleware and compare those with the object middleware
- Write learning diary entry describing CORBA component architecture using the ODP viewpoints; put the description side-by-side with the CORBA object bus description - what do you find as added value here? Did you pay enough attention on the additional services of the component model when doing your ODP-driven map, especially information viewpoint?
Module V: Service oriented architecture
The aim of this module is to get to know what service orientation refers to and what kind of services and models it involves.
TODO
- See learning goals of "Different types of middleware"
- Read articles [soa1] and [soa2].
- Some slides.
- Write learning diary entries responding to questions like
- Describe the basic SOA model.
- How SOC and SOA differ?
- What kind of languages can be used for service descriptions? What UDDI brings in? Is that adequate?
- What is orchestration? What is meant by choreography? What kind of languages are used for those? What is the difference between the two conepts?
- Work though an example using a language of either category.
Module VI: Reflective middleware
The aim of this module is to study adaptive systems and the role of reflective systems in the support of adaptation.
TODO
- See learning goals of "Different types of middleware"
- Read the textbook chapter 2.
- Some slides will be produced here, shortening the presentation from old stuff.
- Look up what Gordon Blair has written about the reflective system his project developed.
- Write learning diary entriese on
- Definition of adaptation? Definition of reflection? What models and metadata has to do with it?
- Take an example implementation and try to understand how the model can be expressed and the model state changed. How the system state is represented? How the system state can change or be changed? Who or what triggers the changes? Is the system safe?
Module VII: Transactional middleware
The goal of this module is to recall the concept of transaction, with ACID properties, and to study new transaction concepts that are more suitable for business transactions, long-running transactions, and transactions that cannot be rolled back.
- See learning goals of "Different types of middleware"
- Read textbook chapters 1 and 3
- Recall from Distributed systems course how transactions can be performed; i.e, commit-abort-rollback, distributed algorithms for locking, two phase commit, optimistic sequencing of events, distributed snapshot algorithms.
- How a distributed transaction is implemented?
- On what levels transactionality is used in middleware as a supporting element for building programmer concepts?
- On what levels the programmers need to address transactionality?
- Can transaction transparency be supported? When?
Module IIX: Model-oriented middleware and tools
The aim of this module is to get to know how software engineering with modern, model-driven software engineering process is supported.
TODO
- See learning goals of "Different types of middleware"
- Read the textbook chapter 7. Pick up concepts of CIM, PIM and PSM; transformations; role of MDA tools in software engineering.
- Search from the web what Douglas Schmidt has written about MDA; select an article that seems to cover enough detail and comparison to compiler techniques.
- Write learning diary entries that discuss
- What is referred to by the terms MDA?
- What kind of models are involved?
- What kind of tools are made available? What is their impact on software production?
Module IX: Fault tolerance
The goal of this module is to identify sources of errors, faults and failures and to find out a few ways of recovery for them. Topics of further interest include self-healing systems ( and in some extent also reflective and adaptive systems).
- Read Chapter 18 from the textbook
- Write diary items
- error, failure, fault
- recovery methods
- relationship to reflective middleware?
- what an example implementation looks like
Module X: Other issues
The goal of this module is to open up challenges and some common techniques on areas such as QoS management, trust management, grid and P2P middleware.
Quality of service management
- Chapters 6 and 14
- Learning diary topics
- Define QoS
- Introduce mechnaisms needed
- differences between operational and stream based communication
- resource reservation methods
- Chapters 4 and 5
- Compare the services provided and the architectures suggested
- Read 9.2
Lea.Kutvonen@cs.Helsinki.FI