Component Software

Clemens Szyperski joined Microsoft Research at its Redmond, Washington, facility in 1999 to continue his work on component software. He is currently also an Adjunct Professor of the Faculty of Information Technology at the Queensland University of Technology (QUT), Brisbane, Australia, where he was previously an Associate Professor. He joined the faculty in 1994 and received tenure in 1997. From 1995 to 1999 he has been director of the Programming Languages and Systems Research Centre at QUT. From 1992 to 1993 he held a Postdoctoral Fellowship from the International Computer Science Institute (ICSI) at the University of California at Berkeley. At ICSI he worked in the groups of Professor Jerome Feldman (Sather language) and Professor Domenico Ferrari (Tenet communication suite with guaranteed Quality of Service). In 1992, Clemens received his PhD in Computer Science from the Swiss Federal Institute of Technology (ETH), Zurich, Switzerland, where he designed and implemented the extensible operating system Ethos under the supervision of Professor Niklaus Wirth and Professor Hanspeter Mössenböck. In 1987, he received a degree in Electrical Engineering/Computer Engineering from the Aachen University of Technology (RWTH), Germany. Ever since joining ETH in 1987, his work has been heavily influenced by the work of Professor Wirth and Professor Jürg Gutknecht on the Oberon language and system. In 1993, he co-founded Oberon microsystems, Inc., developer of BlackBox Component Builder, first marketed in 1994 and one of the first development environments and component frameworks designed specifically for component-oriented programming projects. In 1997, Oberon microsystems released the new component-oriented programming language Component Pascal. He was a key contributor to both BlackBox and Component Pascal. In 2000, Professor John Gough, Dean of Information Technology at QUT, ported Component Pascal to the Microsoft .NET common language runtime. In 1999, Oberon microsystems spun out a new company, esmertec, inc., that took the hard realtime operating system then called Portos and turned it into JBed, an industry-leading hard realtime operating system for Java in embedded systems. Clemens has been a consultant to major international corporations. He served as an assessor and reviewer for Australian, Canadian, Irish, and US federal funding agencies and for learned journals across the globe. He served as a member of program and organizing committees of numerous events, including ECOOP, ICSE, and OOPSLA conferences. He has published numerous papers and articles, several books, and frequently presents at international events.

Preface to the second edition.


Preface.


About the author.


About the contributing authors.


Acknowledgements.
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.



Lessons learned.

2. Market versus technology.


Creating a market.



Fundamental properties of component technology.



Market development.



Strategic Focus (January 1995).



Ovum (1995).



IDC (May 1996).



IDC (April 1999).



ComponentSource (2001).



Flashline (2001).

3. Standards.


The utmost importance of (quasi) standards.



Wiring standards are not enough.



Too many competing standards are not useful.



Where is software component technology today?



What's next?

II. FOUNDATION.

4. What a component is and is not.


Terms and concepts.



Components.



Objects.



Components and objects.



Modules.



Whitebox versus blackbox abstractions and reuse.



Interfaces.



Explicit context dependencies.



Component “weight”.



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.



Versions.



Interfaces as contracts.



Contracts and extra-functional requirements.



Undocumented “features”.



What belongs to a contract?



Safety and progress.



Extra-functional requirements.



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.



Histories.



Specification statements.

6. Polymorphism.


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.



Module safety and metaprogramming.



Safety in a multilanguage environment.



Safety, security, trust.



Dimensions of independent extensibility.



Bottleneck interfaces.



Singleton configurations.



Parallel, orthogonal, and recursive extensions.



Evolution versus immutability of interfaces and contracts.



Syntactic versus semantic contract changes.



Contract expiry.



Overriding law.



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.



Multiple inheritance.



Mixins.



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.



Summary.

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 architecture–frameworks.



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.



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.



Compound documents.



On the wire–the rise of XML.



XML, XML Namespaces, XML Schema.



XML support standards.



XML document object and streaming models.



SOAP.



XML web services: WSDL, UDDI, WSFL, XLANG.



Web services and programming models.



Which way?

13. The OMG way: CORBA, CCM, OMA, and MDA.


At the heart–the object request broker.



From CORBA to OMA.



CORBA timeline.



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.



CCM components.



CCM containers.



CORBA-compliant implementations.



BEA's WebLogic.



IBM's WebSphere.



IONA's Orbix E2A Application Server Platform.



Borland's Enterprise Server.



Non-for-profit implementations.



CORBAfacilities.



Application objects.



CORBA, UML, XML, and MDA.



Meta-object facility.



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.



Garbage collection.



JavaBeans.



Events and connections.



Properties.



Introspection.



JAR files–packaging of Java components.



Basic Java services.



Reflection.



Object serialization.



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.



JXTA–peer-to-peer computing.



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.



Categories.



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.



Enterprise services.



Web services with .NET.

16. Some further technologies.


Computer Associates' Advantage Plex.



Hitachi Appgallery.



Groove Transceiver.

17. Strategic comparison.


Shared attributes.



Differences.



Consequences for infrastructure vendors.



Consequences for component vendors.

18. Efforts on domain standards.


OMG Domain Technology Committee.



OMG BODTF.



W3C.



Business processes and documents.



OASIS and ebXML.



RosettaNet and PIPs.



BizTalk.org.



DMTF's CIM and WBEM.



Java domain standard efforts.



OLE for process control.



Industry associations.



Information technology industry groupings.



Trade associations.



User associations.

19. Ongoing concerns.


Domain standards.



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.



Conceptualization–beyond objects?



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.



COM+ contexts.



EJB containers.



CCM containers.



CLR contexts and channels.



Tuple and object spaces.



BlackBox component framework.



Carrier-rider-mapper design pattern.



Directory objects.



Hierarchical model view separation.



Container modes.



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.



Realtime scheduler.



Cross-development environment.

22. Component development.


The methodology–component-oriented programming.



Problems of asynchrony.



Multithreading.



Learning from circuit design.



Living without implementation inheritance.



Nutshell classes.



Language support.



Dynamic base objects with forwarding semantics.



Caller encapsulation.



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.



Superdistribution.



Intermediaries.

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.



End-user assembly.



Component evolution.

25. On the horizon.


Advanced object composition.



Delegation.



Split objects.



Environmental acquisition.



Dynamic inheritance.



New forms of object and component abstraction.



Subject-oriented programming.



Aspect-oriented programming.



XML components.

part five Markets and components.

26. Gamut of markets.


Components.



Component platforms and infrastructure.



Tools.



Component design and implementation tools.



Component testing tools.



Component assembly tools.



Component system diagnosis and maintenance.



Professional services.



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.



Component developer.



Component assembler.

28. A component marketing paradox.


Branding.



Pay per use.



Co-placement of advertisements.



Leveraging on newly created markets.



Leverage of integrative forces.

Epilogue.
Appendix A Java versus C# versus Component Pascal.
Useful addresses and bibliography.
Glossary.
Index.