Component software beyond object- oriented programming. Author(S) Clemens Szyperski. Publication. Data. Harlow, England: Addison – Wesley. Publication. Component Software: Beyond Object-Oriented Programming by Clemens Szyperski. ISBN This new book has been touted as a paradigm- shifter. In Component Software, Second Edition, Clemens Szyperski has updated his definitive guide to software component technologies, their technical and business .
|Published (Last):||24 October 2007|
|PDF File Size:||2.79 Mb|
|ePub File Size:||14.9 Mb|
|Price:||Free* [*Free Regsitration Required]|
With the advent of new enabling technologies, the need for the information put forth in this new edition is greater than ever.
Component Software, Second Edition explains what the key software component technologies are, how to use them properly, and why they are important to a development organization. Furthermore, the author presents this material in terms of both the technical and business issues involved with the adoption of component-based software engineering. The book defines components and clarifies the key questions surrounding them, demonstrating how components can be the key to successful software design and construction.
Preface to the second edition. About the contributing authors. Components are for composition.
ACM.Szyperski:Component Software_p2, 2nd Edition
Components—custom-made versus standard software. The nature of software and deployable entities. Components are units of deployment. Fundamental properties of component technology. Strategic Focus January The utmost importance of quasi standards.
Wiring standards are not enough.
Too many competing standards are not useful. Where is software component technology today? Whitebox versus blackbox abstractions and reuse. Horizontal versus vertical markets. Standard component worlds and normalization. Direct and indirect interfaces. Contracts and extra-functional requirements. What belongs to a contract?
Specifying time and space requirements. Dress code—formal or informal? Examples of callbacks and contracts.
Component Software: Beyond Object-oriented Programming – Clemens Szyperski – Google Books
A client of the directory service. Same client, next release. 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: Substitutability—using one for another. Types, subtypes, and type checking.
Component Software: Beyond Object-Oriented Programming (ACM Press)
Object languages and types. Types, interfaces, and components. The paradigm of independent extensibility. Safety by construction—viability of components. Module safety and metaprogramming. Safety in a multilanguage environment. Dimensions of independent extensibility. Parallel, orthogonal, and recursive extensions.
Evolution versus immutability of interfaces and contracts. Syntactic versus semantic contract changes. Other forms of polymorphism. Inheritance—the soup of the day? More flavors to the soup. 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.
Component Software: Beyond Object-Oriented Programming by Clemens Szyperski
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. Units of fault containment. Units of system management. Forms of design-level reuse. Sharing concrete solution fragments—libraries.
Sharing individual interaction fragments—messages and protocols. Sharing individual interaction architecture—patterns. Sharing overall structure—system architecture. Systems of subsystems—framework hierarchies. Interoperability, legacies, and re-engineering. Different programming methods for different programmers. Programming to a system. Message syntax and schema—XML.
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. Oscar Nierstrasz and Dennis Tsichritzis and Ovum Report on Distributed Objects Desmond D’Souza and Alan Wills Krzysztof Czarnecki and Ulrich Eisenecker Peter Herzum and Oliver Sims Where it all came from. From procedures to objects. Specification of interfaces and object references.
Interface relationships and polymorphism. Naming and locating services. On the wire—the rise of XML. XML document object and streaming models. Web services and programming models. At the heart—the object request broker. A bit of history—system object model SOM. Services supporting enterprise distributed computing.
Services supporting architecture using fine-grained objects. Object-orienyed and history of Java component technologies. Java versus Java 2. Runtime environment and reference implementations.