Component software : beyond object-oriented programming = 构件化软件 : 超越面向对象编程 / 2nd ed.

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