Preface to the second edition.
About the author.
About the contributing authors.
I. MOTIVATION–COMPONENTS AND MARKETS. 1. Introduction.
Components are for composition.
Components–custom-made versus standard software.
Inevitability of components.
The nature of software and deployable entities.
Components are units of deployment.
2. Market versus technology.
Creating a market.
Fundamental properties of component technology.
Strategic Focus (January 1995).
IDC (May 1996).
IDC (April 1999).
The utmost importance of (quasi) standards.
Wiring standards are not enough.
Too many competing standards are not useful.
Where is software component technology today?
II. FOUNDATION. 4. What a component is and is not.
Terms and concepts.
Components and objects.
Whitebox versus blackbox abstractions and reuse.
Explicit context dependencies.
Standardization and normalization.
Horizontal versus vertical markets.
Standard component worlds and normalization.
5. Components, interfaces, and re-entrance.
Components and interfaces.
Direct and indirect interfaces.
Interfaces as contracts.
Contracts and extra-functional requirements.
What belongs to a contract?
Safety and progress.
Specifying time and space requirements.
Dress code–formal or informal?
Callbacks and contracts.
Examples of callbacks and contracts.
A directory service.
A client of the directory service.
Same client, next release.
A broken contract.
Prevention is better than cure.
Proofing the directory service.
Test functions in action.
From callbacks to objects.
From interobject consistency to object re-entrance.
Self-interference and object re-entrance: a summary.
Processes and multithreading.
Substitutability–using one for another.
Types, subtypes, and type checking.
More on subtypes.
Object languages and types.
Types, interfaces, and components.
The paradigm of independent extensibility.
Safety by construction–viability of components.
Module safety and metaprogramming.
Safety in a multilanguage environment.
Safety, security, trust.
Dimensions of independent extensibility.
Parallel, orthogonal, and recursive extensions.
Evolution versus immutability of interfaces and contracts.
Syntactic versus semantic contract changes.
Other forms of polymorphism.
7. Object versus class composition or how to avoid inheritance.
Inheritance–the soup of the day?
More flavors to the soup.
Back to basic ingredients.
The fragile base class problem.
The syntactic fragile base class problem.
The semantic fragile base class problem.
Inheritance–more knots than meet the eye.
Approaches to disciplined inheritance.
The specialization interface.
Typing the specialization interface.
Behavioral specification of the specialization interface.
Reuse and cooperation contracts.
Representation invariants and method refinements.
Disciplined inheritance to avoid fragile base class problems.
Creating correct subclasses without seeing superclass code.
From class to object composition.
Forwarding versus delegation (or making object composition as problematical as implementation inheritance).
A brief review of delegation and inheritance.
8. Aspects of scale and granularity.
Units of abstraction.
Units of accounting.
Units of analysis.
Units of compilation.
Units of delivery.
Units of deployment.
Units of dispute.
Units of extension.
Units of fault containment.
Units of instantiation.
Units of installation.
Units of loading.
Units of locality.
Units of maintenance.
Units of system management.
9. Patterns, frameworks, architectures.
Forms of design-level reuse.
Sharing consistency–programming languages.
Sharing concrete solution fragments–libraries.
Sharing individual contracts–interfaces.
Sharing individual interaction fragments–messages and protocols.
Sharing individual interaction architecture–patterns.
Sharing overall structure–system architecture.
Systems of subsystems–framework hierarchies.
Interoperability, legacies, and re-engineering.
10. Programming–shades of gray.
Different programming methods for different programmers.
Programming to a system.
Connection-oriented programming–advanced concepts.
Events and messages.
Message syntax and schema–XML.
Events versus calls.
Call syntax and protocol–SOAP.
Ordering of events–causality, races, and glitches.
Very late binding–dispatch interfaces and metaprogramming.
Degrees of freedom–sandboxing versus static safety.
Recording versus scripting.
11. What others say.
Grady Booch (1987).
Oscar Nierstrasz and Dennis Tsichritzis (1992 and 1995).
Gio Wiederhold, Peter Wegner, and Stefano Ceri (1992).
Ivar Jacobson (1993).
Meta Group (1994).
Jed Harris (1995).
Ovum Report on Distributed Objects (1995).
Robert Orfali, Dan Harkey, and Jeri Edwards (1995, 1996).
Johannes Sametinger (1997).
UML 1.3 Standard (1999).
Desmond D'Souza and Alan Wills (1999).
Krzysztof Czarnecki and Ulrich Eisenecker (2000).
Peter Herzum and Oliver Sims (2000).
CBSE Handbook (2001).
III. COMPONENT MODELS AND PLATFORMS. 12. Object and component “wiring” standards.
Where it all came from.
From procedures to objects.
The fine print.
Specification of interfaces and object references.
Interface relationships and polymorphism.
Naming and locating services.
On the wire–the rise of XML.
XML, XML Namespaces, XML Schema.
XML support standards.
XML document object and streaming models.
XML web services: WSDL, UDDI, WSFL, XLANG.
Web services and programming models.
13. The OMG way: CORBA, CCM, OMA, and MDA.
At the heart–the object request broker.
From CORBA to OMA.
A bit of history–system object model (SOM).
Common object service specifications (CORBAservices).
Services supporting enterprise distributed computing.
Services supporting architecture using fine-grained objects.
CORBA Component Model.
Portable object adapter.
IONA's Orbix E2A Application Server Platform.
Borland's Enterprise Server.
CORBA, UML, XML, and MDA.
Model-driven architecture (MDA).
14. The Sun way–Java, JavaBeans, EJB, and Java 2 editions.
Overview and history of Java component technologies.
Java versus Java 2.
Runtime environment and reference implementations.
Spectrum of editions–Micro, Standard, and Enterprise.
Java, the language.
Interfaces versus classes.
Exceptions and exception handling.
Threads and synchronization.
Events and connections.
JAR files–packaging of Java components.
Basic Java services.
Java native interface.
Java AWT and JFC/Swing.
Advanced JavaBeans specifications.
Component variety–applets, servlets, beans, and Enterprise beans.
Java server pages (JSP) and servlets.
Contextual composition–Enterprise JavaBeans (EJB).
Data-driven composition–message-driven beans in EJB 2.0.
Advanced Java services.
Distributed object model and RMI.
Java and CORBA.
Enterprise service interfaces.
Java and XML.
Interfaces versus classes in Java, revisited.
JXTA and Jini.
Jini–federations of Java objects.
Java and web services–SunONE.
15. The Microsoft way: COM, OLE/ActiveX, COM+, and .NET CLR.
The first fundamental wiring model–COM.
COM object reuse.
Interfaces and polymorphism.
Interfaces and versioning.
COM object creation and the COM library.
Initializing objects, persistence, structured storage, monikers.
From COM to distributed COM (DCOM).
Meta-information and automation.
Other COM services.
Uniform data transfer.
Dispatch interfaces (dispinterfaces) and dual interfaces.
Outgoing interfaces and connectable objects.
Compound documents and OLE.
OLE containers and servers.
Controls–from Visual Basic via OLE to ActiveX.
Contextual composition and services.
COM apartments–threading and synchronization.
Microsoft transaction server–contexts and activation.
COM+–generalized contexts and data-driven composition.
Take two–the .NET Framework.
The .NET big picture.
Common language infrastructure.
COM and platform interoperation.
Exemplary .NET language–C#.
Visual Studio .NET.
Assemblies–the .NET components.
Common language frameworks.
AppDomains, contexts, reflection, remoting.
Windows Forms, data, management.
Web Forms, Active Server Pages (ASP) .NET.
XML and data.
Web services with .NET.
16. Some further technologies.
Computer Associates' Advantage Plex.
17. Strategic comparison.
Consequences for infrastructure vendors.
Consequences for component vendors.
18. Efforts on domain standards.
OMG Domain Technology Committee.
Business processes and documents.
OASIS and ebXML.
RosettaNet and PIPs.
DMTF's CIM and WBEM.
Java domain standard efforts.
OLE for process control.
Information technology industry groupings.
19. Ongoing concerns.
Rethinking the foundations of software engineering.
But is it object-oriented?
Object mobility and mobile agents.
Foundations–better contracts for better components.
part four Components meet architecture and process. 20. Component architecture.
The roles of an architecture.
Definitions of key terms.
A tiered component architecture.
Components and middleware.
Components versus generative programming.
21. Component frameworks.
Contributions of contextual component frameworks.
Foundation and roots.
Component frameworks versus connectors.
Component frameworks versus metaprogramming.
Component frameworks versus aspect-oriented programming.
Frameworks for contextual composition.
CLR contexts and channels.
Tuple and object spaces.
BlackBox component framework.
Carrier-rider-mapper design pattern.
Hierarchical model view separation.
Cascaded message multicasting services.
Advanced applications based on compound documents.
BlackBox and OLE.
Portos–a hard realtime component framework and its IDE.
Structure of Portos.
22. Component development.
The methodology–component-oriented programming.
Problems of asynchrony.
Learning from circuit design.
Living without implementation inheritance.
Dynamic base objects with forwarding semantics.
The environment–selecting target frameworks.
The tools–selecting programming languages.
23. Component distribution and acquisition.
Building what sells–applications not components?
Product cataloging and description.
Component location and selection.
24. Component assembly.
Systematic initialization and wiring.
Visual component assembly.
Compound documents to supersede visual assembly.
Components beyond graphical user interface environments.
Managed and “self-guided” component assembly.
25. On the horizon.
Advanced object composition.
New forms of object and component abstraction.
part five Markets and components. 26. Gamut of markets.
Component platforms and infrastructure.
Component design and implementation tools.
Component testing tools.
Component assembly tools.
Component system diagnosis and maintenance.
Component system and framework architects.
Component assembly consultants.
Component configuration management.
Component warehouses, marketing, and consulting.
Component operators, web services, application service providers.
27. New professions.
Component system architect.
Component framework architect.
28. A component marketing paradox.
Pay per use.
Co-placement of advertisements.
Leveraging on newly created markets.
Leverage of integrative forces.
Appendix A Java versus C# versus Component Pascal.
Useful addresses and bibliography.