构件化软件：超越面向对象编程英文版

内容简介

　　自从这本经典著作的第一版发行之后，又出现了大量的构件化软件技术。EJB、J2EE、CORBA3、COM+以及.NET的出现，则是超越OOP的构建化软件市场正在成熟的有力证据。本书为我们客观地描述了构件的市场前景；提供了对市场动力的独特观察，该动力影响着系统的部署；并揭示了深层次的实际问题及解决方案。本书将帮助软件开发人员、系统架构师、CTO以及系统集成人员理解构件软件内部的技术问题市场动力。ClemensSzyperski：瑞士Oberon微系统公司的创始人之一，并参与了BlackBox构件构造器的研制。他是工业界与学术界活跃的演讲者，还参与了多个国家的国家研究基金的评审工作。Szyperski教授发表了许多学术文章并撰写了若干部著作。本书全面介绍了软件构件技术涉及的问题。作者以构件与市场的关系作为入口，逐步转入对构件、接口、对象、模式、框架、体系结构等基本概念与知识的讨论。书中结合OMG、Sun和Microsoft的解决方案，介绍了构件模型与构件平台；接着在此基础之上，讨论了构件体系结构，以及构件的发布、获取、组装等与开发过程相关的问题。最后，本书简介了构件软件技术的市场前景。全书覆盖面广，内容丰富，语言简练，并从不同的角度进行了分析、预测，是一本优秀的软件技术参考书。本书适合于从事软件设计开发的软件开发人员、系统架构师、CTO、系统集成人员等。

作者简介

　　ClemensSzyperski：瑞士Oberon微系统公司的创始人之一，并参与了BlackBox构件构造器的研制。他是工业界与学术界活跃的演讲者，还参与了多个国家的国家研究基金的评审工作。Szyperski教授发表了许多学术文章并撰写了若干部著作。

图书目录

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