No Words Wasted Sale

Special Offers see all

Enter to WIN a $100 Credit

Subscribe to
for a chance to win.
Privacy Policy

Visit our stores

    Recently Viewed clear list

    Original Essays | January 19, 2015

    Emma Hooper: IMG From Musician to Novelist

    I was asleep on the floor of the magicians' apartment. Not one, but three magicians lived there, and their mysterious, mischievous, and sometimes... Continue »
    1. $18.20 Sale Hardcover add to wish list

Qualifying orders ship free.
Used Hardcover
Ships in 1 to 3 days
Add to Wishlist
Qty Store Section
1 Local Warehouse Software Engineering- Object Oriented Programming

Component Software Beyond Object Oriented Software 1ST Edition


Component Software Beyond Object Oriented Software 1ST Edition Cover


Synopses & Reviews

Publisher Comments:

There has been an explosive growth in component software technologies since the first edition of this classic book was published. The advent of EJB, J2EE, CORBA 3, COM+ and the .NET framework are evidence of a maturing market in component software that goes 'beyond OOP'.

Clemens Szyperski gives us an objective survey of the component landscape, blended with unique insights into the market forces that influence deployment and in-depth coverage of real problems and their solutions.

Highlights of the Second Edition include:

  • A comprehensive update of market-leading technologies including COM+, CORBA, EJB and J2EE
  • New sections evaluating the strengths and weaknesses of emerging technologies like .NET, the CORBA Component Model, XML Web Services, showing how they work together with components and XML-related standards
  • New examples in C# in addition to Java and Component Pascal

Component Software, Second Edition will help software developers, architects, CTOs and system integrators to understand both the technical issues and the market dynamics that underlie component software.


About the Author

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.


Table of Contents

Preface to the second edition.


About the author.

About the contributing authors.



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?


4. What a component is and is not.

Terms and concepts.



Components and objects.


Whitebox versus blackbox abstractions and reuse.


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.


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.


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.


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.

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


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.


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.


Application objects.


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.


Events and connections.



JAR files—packaging of Java components.

Basic Java services.


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.


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.


Consequences for infrastructure vendors.

Consequences for component vendors.
18. Efforts on domain standards.

OMG Domain Technology Committee.



Business processes and documents.

OASIS and ebXML.

RosettaNet and PIPs.


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.


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.


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.


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.


Component platforms and infrastructure.


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.


Pay per use.

Co-placement of advertisements.

Leveraging on newly created markets.

Leverage of integrative forces.

Appendix A Java versus C# versus Component Pascal.

Useful addresses and bibliography.



Product Details

Beyond Object-Oriented Programming
Szyperski, Clemens
Addison-Wesley Professional
New York :
Programming Languages - General
Programming - General
Programming - Object Oriented Programming
Application Software - General
Programming - Software Development
Object-oriented programming (computer science
Component software
The Component Software Series
Publication Date:
Grade Level:
Professional and scholarly
9.58x6.38x.92 in. 1.40 lbs.

Other books you might like

  1. Game Programming Gems 4 with CDROM Used Hardcover $34.00
  2. Hardball: How Politics Is Played... Used Trade Paper $4.95
  3. Design Patterns: Elements of...
    Used Hardcover $38.00
  4. Microsoft Secrets: How the World's... New Trade Paper $32.95
  5. Hayao Miyazaki: Master of Japanese...
    Used Trade Paper $11.95
  6. Game Programming Gems (Book ) with...
    Used Hardcover $35.00

Related Subjects

» Computers and Internet » Software Engineering » General
» Computers and Internet » Software Engineering » Object Oriented Programming
» Computers and Internet » Software Engineering » Programming and Languages

Component Software Beyond Object Oriented Software 1ST Edition Used Hardcover
0 stars - 0 reviews
$1.75 In Stock
Product details 624 pages PEARSON EDUCATION - English 9780201178883 Reviews:
  • back to top


Powell's City of Books is an independent bookstore in Portland, Oregon, that fills a whole city block with more than a million new, used, and out of print books. Shop those shelves — plus literally millions more books, DVDs, and gifts — here at