PART ONE Motivation - components and markets
1 Introduction
1.1 Components are for composition
1.2 Components - custom-made versus standard software
1.3 Inevitability of components
1.4 The nature of software and deployable entities
1.5 Components are units of deployment
1.6 Lessons learned
2 Market versus technology
2.1 Creating a market
2.2 Fundamental properties of component technology
2.3 Market development
2.3.1 Strategic Focus (January 1995)
2.3.2 Ovum (1995)
2.3.3 IDC (May 1996)
2.3.4 Forrester Research (October 1996)
2.3.5 IDC (Apdl 1999)
2.3.6 ComponentSource (2001)
2.3.7 Rashline (2001)
Standards
3.1 The utmost importance of (quasi) standards
3.2 Wiring standards are not enough
3.3 Too many competing standards are not useful
3.4 Where is software component technology today?
3.5 What's next?
TWO Foundation
4 What a component is and is not
4.1 Terms and concepts
4.1.1 Components
4.1.2 Objects
4.1.3 Components and objects
4.1.4 Modules
4.1.5 Whitebox versus blackbox abstractions and reuse
4.1.6 Interfaces
4.1.7 Explicit context dependencies
4.1.8 Component "weight"
4.2 Standardization and normalization
4.2.1 Horizontal versus vertical markets
4.2.2 Standard component worlds and normalization
5 Components, Interfaces, and re-entrance
5.1 Components and interfaces
5.1.1 Direct and indirect' interfaces
5.1.2 Versions
5.1.3 Interfaces as contracts
5.1.4 Contracts and extra-functional requirements
5.1.5 Undocumented "features"
5.2 What belongs to a contract.?
5.2.1 Safety and progress
5.2.2 Extra-functional requirements
5.2.3 Specifying time and space requirements
5.3 Dress code - formal or informal?
5.4 Callbacks and contracts
5.5 Examples of callbacks and contracts
5.5.1 A directory service
5.5.2 A client of the directory service
5.5.3 Same client, next release
5.5.4 A broken contract
5.5.5 Prevention is better than cure
5.5.6 Proofing the directory service
5.5.7 Test functions in action
5.6 From callbacks to objects
5.7 From interobject consistency to object re-entrance
5.8 Self-interference and object re-entrance: a summary
5.9 Processes and multithreading
5.10 Histories
5.11 Specification statements
6 Polymorphlsm
6.1 Substitutability - using one for another
6.2 Types, subtypes, and type checking
6.3 More on subtypes
6.4 Object languages and types 6.5 Typos, interfaces, and components
6.6 The paradigm of independent extensibility
6.7 Safety by construction - viability of components
6.7.1 Module safety
6.7.2 Module safety and metaprogramming
6.7.3 Safety in a multilanguage environment
6.8 Safety, security, trust
6.9 Dimensions of independent extensibility
6.9.1 Bottleneck inte#aces
6.9.2 Singleton configurations
6.9.3 Parallel, orthogonal, and recursive extensions
6.10 Evolution versus immutability of interfaces and contracts
6.10.1 Syntactic versus semantic contract changes
6.10.2 Contract expiry
6.10.3 Overriding law
6.11 Other forms of polymorphism
7 Object versus class composition or how to avoid Inheritance
7.1 Inheritance - the soup of the day?
7.2 More flavors to the soup
7.2.1 Multiple inheritance
7.2.2 Mixins
7.3 Back to basic ingredients
7.4 The fragile base class problem
7.4.1 The syntactic fragile base class problem
7.4.2 The semantic fragile base class problem
7.5 Inheritance - more knots than meet the eye
7.6 Approaches to disciplined inheritance
7.6.1 The specialization interface
7.6.2 Typing the specialization interface
7.6.3 Behavioral specification of the specialization interface
7.6.4 Reuse and cooperation contracts
7.6.5 Representation invariants and method refinements
7.6.6 Disciplined inheritance to avoid fragile base class problems
7.6.7 Creating correct subclasses without seeing suporclass code
7.7 From class to object composition
7.8 Forwarding versus delegation (or making object composition as problematical
as implementation inheritance)
7.9 A brief review of delegation and inheritance
8 Aspects of scale and granularity
8.1 Units of abstraction
8.2 Units of accounting
8.3 Units of analysis
8.4 Units of compilation
8.5 Units of delivery
8.6 Units of deployment
8.7 Units of dispute
8.8 Units of extension
8.9 Units of fault containment
8.10 Units of instantietion
8.11 Units of installation
8.12 Units of loading
8.13 Units of locality
8.14 Units of maintenance
8.15 Units of system management
8.16 Summery
9 Patterns, frameworks, architectures
9.1 Forms of design-level reuse
9.1.1 Sharing consistency - programming languages
9.1.2 Sharing concrete solution fragments - Ilibraries
9.1.3 Sharing individual contracts - interfaces
9.1.4 Sharing individual interaction fragments - messages and protocols
9.1.5 Sharing individual interaction architecture - pattams
9.1.6 Sharing architecture - frameworks
9.1.7 Sharing overall structure - system amhitecture
9.1.8 Systems of subsystems - framework hierarchies
9.2 Intereperability, legacies, and re-engineering
10 Programming - shades of gray
l0.1 Different progremming methods for different programmers
10.2 Programming to a system
10.3 Connection-oriented programming
10.4 Connection-oriented programming- advanced concepts
10.5 Events and messages
10.5.1 Message syntax and schema - XML
10.5.2 Events versus calls
10.5.3 Call syntax and protocol - SOAP
10.6. Ordering of events - causality, races, and glitches
10.7 Very late binding - dispatch interfaces and metapregramming
10.8 Degrees of freedom - sandboxing versus static safety
10.9 Recording versus scripting
11 What others say
11.1 Grady Booch (1987)
11.2 Oscar Nierstrasz and Dennis Tsichritzis (1992 and 1995)
11.3 Glo Wiederhold, Peter Wegner, and Stefano Ceri (1992)
11.4 Ivar Jacobson (1993)
11.5 Meta Group (1994)
11.6 Jed Harris (1995)
11.7 Ovum Report on Distributed Objects (1995)
11.8 Robert Orfali, Dan Harkey, and Jeri Edwards (1995, 1996)
11.9 Johannes Sametinger (1997)
11.10 UML 1.3 Standard (1999)
11.11 Desmond D'Souza and Alan Wills (1999)
11.12 Krzysztof Czamecki and Ulrich Eisenecker (2000)
11.13 Peter Herzum and Oliver Sims (2000)
11.14 CBSE Handbook (2001)
PART THREE Component models and platforms
12 Object and component "wiring" standards
12.1 Where it all came from
12.2 From procedures to objects
12.3 The fine print
12.3.1 Specification of interfaces and object references
12.3.2 Interface relationships and polymorphism
12.3.3 Naming and locating services
12.3.4 Compound documents
12.4 On the wire - the rise of XML
12.4.1 XML, XML Namespaces, XML Schema
12.4.2 XML support standards
12.4.3 XML document object and streaming models
12.4.4 SOAP
12.4.5 XML web services: WSDL, UDDI, WSFL, XLANG
12.4.6 Web services and programming models
12.5 Which way?
13 The OMG way: CORBA, CCM, OMA, and MDA
13.1 At the heart - the object request broker
13.1.1 From CORBA to OMA
13.1.2 CORBA timeline
13.1.3 A bit of history - system object model (SOM)
13.2 Common object service specifications (CORBAsewices)
13.2.1 Services supporting enterprise distributed computing
13.2.2 Services supporting architecture using fine-grained objects
13.3 CORBA Component Model
13.3.1 Portable object adapter
13.3.2 CCM components
13.3.3 CCM containers
13.4 CORBA-compliant implementations
13.4.1 BEA's WebLogic
13.4.2 IBM's WebSphere
13.4.3 IONA's Orbix E2A Application Server Platform
13.4.4 Borland's Enterprise Sewer
13.4.5 Non-for-profit implementations
13.5 CORBAfacilities
13.6 Application objects
13.7 CORBA, UML, XML, and* MDA
13.7.1 Meta-object facility
13.7.2 Model-driven architecture (MDA)
14 The Sun way - Java, JavaBeans, EJB, and Java 2 editions
14.1 Overview and history of Java component technologies
14.1.1 Java versus Java 2
14.1.2 Runtime environment and reference implementations
14.1.3 Spectrum of editions - Micro, Standard, and Enterprise
14.2 Java, the language
14.2.1 Interfaces versus classes
14.2.2 Exceptions and exception handling
14.2.3 Threads and synchronization
14.2.4 Garbage collection
14.3 JavaBeans
14.3.1 Events and connections
14.3.2 Properties
14.3.3 Introspection
14.3.4 JAR files - packaging of Java components
14.4 Basic Java services
14.4.1 Reflection
14.4.2 Object serialization
14.4.3 Java native interface
14.4.4 Java AWT and JFC/Swing
14.4.5 Advanced JavaBeans specifications
14.5 Component variety - applets, servlets, beans, and Enterprise beans
14.5.1 Java server pages (JSP) and servlets
14.5.2 Contextual composition - Enterprise JavaBeans (EIB)
14.5.3 Data-driven composition - message-driven beans in EIB 2.0
14.6 Advanced Java sewices
14.6.1 Distributed object model and RMI
14.6.2 Java and CORBA
14.6.3 Enterprise service interfaces
14.6.4 Java and XML
14.7 Interfaces versus classes in Java, revisited
14.8 JXTA and Jini
14.8.1 Jini - federations of Java objects
14.8.2 JXTA - peer-to-beer computing
14.9 Java and web services - SunONE
15 The Microsoft way: COM, OLE/ActiveX, COM+, and .NET CLR
15.1 The first fundamental wiring model - COM
15.2 COM object reose
15.3 Interfaces and polymorphism
15.3.1 Categories
15.3.2 Interfaces and varsioning
15.4 COM object creation and the COM library
15.5 Initializing objects, persistence, structured storage, monikers
15.6 From COM to distributed COM (OCOM)
15.7 Meta-information and automation
15.8 Other COM services
15.8.1 Uniform data transfer
15.8.2 Dispatch interfaces (dispinterfaces) and dual interfaces
15.8.3 Outgoing interfaces and connectable objects
15.9 Compound documents and OLE
15.9.1 0LE containers and servers
15.9.2 Controls - from Visual Basic via OLE to ActiveX
15.10 Contextual composition and services
15.10.1 C0M apartments - threading and synchronization
15.10.2 Microsoft transaction server - contexts and activation
15.10.3 COM+ - generalized contexts and data-driven composition
15.11 Take two - the .NET Framework
15.11.1The .NET big picture
15.11.2common language infrastructure
15,11.3COM and platform interoperation
15.11.4 Exemplary .NET language - Ce
15.11.5Visual Studio ,NET
15.12 Assemblies - the .NET components
15.13 Common language frameworks
15.13.1 AppDomains, contexts, reflection, remoting
15,13.2 Windows Forms, data, management
15.13.3 Web Forms, Active Server Pages (ASP) .NET
15.13.4 XML and data
15.13.5 Enterprise services
15.13.6 Web services with .NET
16 Some further technologies
16.1 Computer Associates' Advantage Plex
16.2 Hitachi Appgallery
16.3 Groove Transceiver
17 Strategic comparison
17.1 Shared attributes
17.2 Differences
17.3 Consequences for infrastructure vendors
17.4 Consequences for component vendors
18 Efforts on domain standards
18.1 0MG Domain Technology Committee
18.1.10MG BODTF
18.2 W3C
18.3 Business processes and documents
18.3.1 OASIS and ebXML
18.3.2 RosettaNet and PIPs
18.3.3 BizTalk.org
18.4 DMTF's CIM and WBEM
18.5 Java domain standard efforts
18.6 0LE for process control
18.7 Industry associations
18.7.1 Information technology, industry groupings
18.7.2 Trade associations
18.7.3 User associations
19 Ongoing concerns
19.1 Domain standards
19.2 Rethinking the foundations of software engineering
19.3 But is it object-oriented?
19.4 Object mobility and mobile agents
19.5 Foundations - better contracts for better components
PART FOUR Components meet architecture and process
20 Component architecture
20.1 The roles of an architecture
20.2 Conceptualization - beyond objects?
20.3 Definitions of key terms
20.4 A tiered component architecture
20.5 Components and middieware
20.6 Components versus generative programming
21 Component frameworks
21.1 Contributions of contextual component frameworks
21.1.1 Foundation and roots
21.1.2 Component frameworks versus connectors
21.1.3 Component frameworks versus metaprogramming
21.1.4 Component frameworks versus aspect-oriented programming
21.2 Frameworks for contextual composition
21.2.1 COM+ contexts
21.2.2 EJB containers
21.2.3 CCM containers
21.2.4 CLR contexts and channels
21.2.5 Tuple and object spaces
21.3 BlackBox component framework
21.3.1 Career-rider-mapper design pattern
21.3.2 Directory objects
21.3.3 Hierarchical model view separation
21.3.4 Container modes
21.3.5 Cascaded message multicasting services
21.3.6 Advanced applications based on compound documents
21.4 BlackBox and.OLE
21.5 Portos - a hard realtime component framework and its IDE
21.5.1 Structure of Portos
21.5.2 Realtime scheduler
21.5.3 Cross-development environment
22 Component development
22.1 The methodology - component-oriented programming
22.1.1 Problems of asynchrony
22.1.2 Multithreading
22.1.3 Learning from circuit design
22.1.4 Living without implementation inheritance
22.1.5 Nutshell classes
22.1.6 Language support
22.1.7 Dynamic bas, objects with forwarding semantics
22.1.8 Caller encapsulation
22.2 The environment - selecting target frameworks
22.3 The tools - selecting programming languages
23 Component distribution and acquisition
23.1 Building what sells - applications not components?
23.2 Product cataloging and description
23.3 Component location and selection
23.4 Superdistribution
23.5 Intermediaries
24 Component assembly
24.1 Systematic initialization and wiring
24.2 Visual component assembly
24.3 Compound documents to supersede visual assembly
24.4 Components beyond graphical user interface environments
24.5 Managed and "self-guided" component assembly
24.6 End-user assembly
24.7 Component evolution
25 On the horlzon
25.1 Advanced object composition
25.1.1 Delegation-
25.1.2 Split objects
25.1.3 Environmental acquisition
25.1.4 Dynamic inheritance
25.2 New forms of object and component abstraction
25.2.1 Subject-oriented programming
25.2.2 Aspect-oriented programming
25.2.3 XML components
nye Markets and components
26 Gamut of markets
26.1 Components
26.2 Component platforms and infrastructure
26.3 Tools
26.3.1 Component design and implementation tools
26.3.2 Component testing tools
26.3.3 Component assembly tools
26.3.4 Component system diagnosis and maintenance
26.4 Professional services
26.4.1 Component system and framework architects
26.4.2 Component assembly consultants
26.4.3 Component configuration management
26.4.4 Component warehouses, marketing, and consulting
26.4.5 Component operators, web services, application service providers
27 New professions
27.1 Component system architect
27.2 Component framework architect
27.3 Component developer
27.4 Component assembler
28 A component marketing paradox
28.1 Branding
28.2 Pay per use
28.3 Co-placement of advertisements
28.4 Leveraging on newly created markets
28.5 Leverage of integrative forces
Epilogue
Appendix A Java versus C# versus Component Pascal
Useful addresses and bibliography
Glossary
Index
鄂公网安备 42010302001612号 