Component software : beyond object-oriented programming
著者
書誌事項
Component software : beyond object-oriented programming
（The Addison-Wesley component software series / Clemens Szyperski, series editor）
ACM Press, c2002
2nd ed
注記
First published: 1999
Reprint. Originally published: 2002
内容説明・目次
内容説明
In Component Software, Second Edition, Clemens Szyperski has updated his definitive guide to software component technologies, their technical and business value, and their most effective use. Building on the book that earned the prestigious Software Development Magazine 1999 Jolt Award for Product Excellence, Szyperski has added thorough coverage of today's most compelling component-related technologies, including Enterprise JavaBeans, .NET, XML, and SOAP. He presents a unique blend of market and technology coverage, broad and fair coverage of all current component technologies, as well as a deep discussion of the key challenges faced by component developers, and the most effective solutions. The book has been updated throughout, with new and revised material on CORBA, COM+, XML, BizTalk, the state of the component market, standards, and more -- including an insightful preview of the future. The First Edition's Java and Component Pascal examples are updated and supplemented with new C# examples; and many key topics are now illuminated by UML class diagrams. For all software architects, developers, and project managers seeking to use software components more effectively -- now, and in the future.
目次
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.
「Nielsen BookData」 より
