An Introduction to Component Software Robert Gallup MSCS Candidate Union College 16 May 2003.

An Introduction to An Introduction to Component SoftwareComponent Software

Robert GallupMSCS Candidate

Union College16 May 2003

AgendaAgenda

• IntroductionIntroduction• Software ComponentsSoftware Components• Component-Based DevelopmentComponent-Based Development• ConclusionConclusion• Questions / DiscussionQuestions / Discussion

IntroductionIntroduction

Traditional SoftwareTraditional Software

• Developed entirely from scratchDeveloped entirely from scratch– Uses only programming tools Uses only programming tools

and librariesand libraries• AdvantagesAdvantages

– May provide a competitive May provide a competitive edge, as it is optimized for a edge, as it is optimized for a user’s business modeluser’s business model

– Takes advantage of In-House Takes advantage of In-House proprietary knowledge or proprietary knowledge or practicespractices

• DisadvantagesDisadvantages– Very expensiveVery expensive– Often provides sub-optimal Often provides sub-optimal

solutionssolutions– High risk of failureHigh risk of failure– No guarantee of interoperability No guarantee of interoperability

with customers or business with customers or business partnerspartners

• OutsourcedOutsourced– Standard software is Standard software is purchasedpurchased, ,

then modified to provide a then modified to provide a solution that is ‘close enough’ to solution that is ‘close enough’ to what is neededwhat is needed

• Produced for a mass marketProduced for a mass market• Strong trend toward Standard Strong trend toward Standard

SWSW• AdvantagesAdvantages

– Can be parameterized to closely Can be parameterized to closely match customer’s needsmatch customer’s needs

– Retires Time-to-Market RiskRetires Time-to-Market Risk• DisadvantagesDisadvantages

– Does not offer a competitive Does not offer a competitive edge,edge,it’s available to competitors as it’s available to competitors as wellwell

– Cannot be quickly adapted to Cannot be quickly adapted to changing needschanging needs

Custom-MadeCustom-Made StandardStandard

Traditional SoftwareTraditional SoftwareProblems with Large Software ProjectsProblems with Large Software Projects

• 1 in 3 Projects Cancelled Prior to Completion1 in 3 Projects Cancelled Prior to Completion

• Average Project Suffers Schedule Overrun of 50%Average Project Suffers Schedule Overrun of 50%

• 1 in 8 Completed Projects Considered to be Successful1 in 8 Completed Projects Considered to be Successful

• 75% of Projects Fail to Perform According to Customer’s 75% of Projects Fail to Perform According to Customer’s RequirementsRequirements

Component SoftwareComponent Software

• Represents a Middle-Path between Custom and Represents a Middle-Path between Custom and Standard Software DevelopmentStandard Software Development

• Makes it Easier to Customize Standard SoftwareMakes it Easier to Customize Standard Software

• Component Component AssemblyAssembly Allows Individual Allows Individual Price/Performance Tradeoff ChoicesPrice/Performance Tradeoff Choices

• May be Combined with Custom-Made ComponentsMay be Combined with Custom-Made Components

• Eliminates the Need for Massive Upgrade CyclesEliminates the Need for Massive Upgrade Cycles

Software ComponentsSoftware Components

Software ComponentSoftware Component: Executable unit of independent production, : Executable unit of independent production, acquisition, and deployment that can be acquisition, and deployment that can be composedcomposed into a functioning into a functioning systemsystem

Component SoftwareComponent Software: Composite systems composed of software : Composite systems composed of software componentscomponents

Current Technologies:Current Technologies:– OMG CORBAOMG CORBA– Microsoft COM, OLE, and ActiveX, Visual BasicMicrosoft COM, OLE, and ActiveX, Visual Basic– SUN JavaBeans, EJBsSUN JavaBeans, EJBs– Modern Operating SystemsModern Operating Systems

• Sharing of File Systems, Common File Formats, use of Pipe and Filter Sharing of File Systems, Common File Formats, use of Pipe and Filter CompositionComposition

– Netscape and Plug-Ins (ie: Apple Quicktime)Netscape and Plug-Ins (ie: Apple Quicktime)– AppletsApplets

Spectrum Between Make-Spectrum Between Make-All and Buy-AllAll and Buy-All

Cost Efficiency

Flexibility, nimbleness, competitive edge

% Bought0 100

Custom Standard

Component Software Allows Customers to Set Priorities Based on Budget Restraints, Component Software Allows Customers to Set Priorities Based on Budget Restraints, Performance Requirements, etc.Performance Requirements, etc.

AnalogiesAnalogiesComponent Software Comparisons to Other Engineering DisciplinesComponent Software Comparisons to Other Engineering Disciplines

• Computer HardwareComputer Hardware– Integrated Circuits (Software IC)Integrated Circuits (Software IC)– Plug and Play TechnologyPlug and Play Technology

• Audio EquipmentAudio Equipment• Mechanical EngineeringMechanical Engineering

– Gears, nuts, and boltsGears, nuts, and bolts

• Software delivers a ‘blueprint’ for products, not the product Software delivers a ‘blueprint’ for products, not the product itselfitself

• Computers instantiate software blueprintComputers instantiate software blueprint

Why is Software Different?Why is Software Different?

Component-Based Component-Based DevelopmentDevelopment

Component Component CharacteristicsCharacteristics

• Unit of DeploymentUnit of Deployment– Isolatable part of a systemIsolatable part of a system

– Well separated from it’s environment and from other componentsWell separated from it’s environment and from other components

– Never partially deployedNever partially deployed

• Unit of Third-Party CompositionUnit of Third-Party Composition– Components must interact through a well-defined Components must interact through a well-defined interfaceinterface

• Has No Persistent StateHas No Persistent State– Ex: Database server = component, database = objectEx: Database server = component, database = object

• Typically Consists of a Collection of Related ClassesTypically Consists of a Collection of Related Classes– May consist of a single class, but rareMay consist of a single class, but rare

– May contain traditional procedures and global variablesMay contain traditional procedures and global variables

– May be implemented using functional languages, assembly May be implemented using functional languages, assembly language, or any other approachlanguage, or any other approach

– A component’s objects may be visible to clients (usually other A component’s objects may be visible to clients (usually other components)components)

Client Access to Client Access to ComponentsComponentsComponent AComponent A

Component BComponent B

Component CComponent C

Client of AClient of A

Client of BClient of B

Client of CClient of C

Object a

Object b

Object c

Procedure a

Procedure b

Procedure c

Object a

Object b

Procedure a

• Component A consists Component A consists solely of objects, of solely of objects, of which A’s client has which A’s client has access to 2access to 2

• Component B consists Component B consists solely of traditional solely of traditional procedures (& possibly procedures (& possibly global static variables)global static variables)

• Component C combines Component C combines objects & traditional objects & traditional procedures. Client has procedures. Client has access only to objects & access only to objects & cannot recognize that C is cannot recognize that C is “all O-O inside”“all O-O inside”

Components vs. ObjectsComponents vs. Objects

• What is a Component?What is a Component?– Characteristic propertiesCharacteristic properties

• a component is a unit of independent deploymenta component is a unit of independent deployment• a component is a unit of third-party compositiona component is a unit of third-party composition• a component has no persistent statea component has no persistent state

• What is an Object?What is an Object?– Characteristic propertiesCharacteristic properties

• an object is a unit of instantiation; it has a unique identityan object is a unit of instantiation; it has a unique identity• an object has a state; this state can be a persistent statean object has a state; this state can be a persistent state• an object encapsulates its state and behavioran object encapsulates its state and behavior

Blackbox vs Whitebox Blackbox vs Whitebox AbstractionAbstraction

• Blackbox AbstractionBlackbox Abstraction– Clients know Clients know onlyonly the interface and it’s specification the interface and it’s specification

• Whitebox AbstractionWhitebox Abstraction– The interface may still enforce encapsulation and The interface may still enforce encapsulation and

limit what clients can dolimit what clients can do– Implementation is fully availableImplementation is fully available

• Glassbox AbstractionGlassbox Abstraction– Implementation details may be viewed only, not Implementation details may be viewed only, not

modifiedmodified

• Graybox AbstractionGraybox Abstraction– A controlled part of their implementation is A controlled part of their implementation is

availableavailable

Visibility of an Implementation Behind it’s InterfaceVisibility of an Implementation Behind it’s Interface

Blackbox vs Whitebox ReuseBlackbox vs Whitebox Reuse

• Blackbox ReuseBlackbox Reuse– Reuses implementations relying on nothing but Reuses implementations relying on nothing but

their interfaces and specificationstheir interfaces and specifications• Example: Application Programming Interfaces (APIs)Example: Application Programming Interfaces (APIs)

• Whitebox ReuseWhitebox Reuse– Uses a software fragment through it’s interfacesUses a software fragment through it’s interfaces– Relies on information gained from studying the Relies on information gained from studying the

actual implementationactual implementation• Example: Class libraries and FrameworksExample: Class libraries and Frameworks

Component InterfacesComponent Interfaces• A Component Interface Provides the Means for A Component Interface Provides the Means for

Components to ConnectComponents to Connect

– Technically, it is a group of related functions that can Technically, it is a group of related functions that can be invoked by clientsbe invoked by clients

– Every operation must be specifiedEvery operation must be specified

• The specification serves both providers implementing the The specification serves both providers implementing the interface and clients using the interfaceinterface and clients using the interface

– A component may contain multiple interfacesA component may contain multiple interfaces

– An interface should be viewed independently of any An interface should be viewed independently of any component that may implement or use itcomponent that may implement or use it

• TerminologyTerminology

– ProviderProvider – The component that implements the – The component that implements the operations of an interfaceoperations of an interface

– ClientClient – The user of the services provided by an – The user of the services provided by an interfaceinterface

Interface SpecificationInterface Specification• The Semantics (Behavior) of Each Operation in an The Semantics (Behavior) of Each Operation in an

Interface is Given by a Interface is Given by a SpecificationSpecification

• This Specification Serves Both the Provider and the This Specification Serves Both the Provider and the ClientClient– ie.:ie.:

• ProviderProvider – Specification defines the requirements for the – Specification defines the requirements for the behavior to be implemented within the provider componentbehavior to be implemented within the provider component

• ClientClient – Specification defines the behavior that can be – Specification defines the behavior that can be expected from interactions with the Provider’s interfaceexpected from interactions with the Provider’s interface

• Interfaces are Specified Using an IDL (Interface Interfaces are Specified Using an IDL (Interface Definition Language)Definition Language)– Current competitors:Current competitors:

• OMG IDLOMG IDL• COM IDLCOM IDL

Direct and Indirect InterfacesDirect and Indirect Interfaces

• Direct InterfaceDirect Interface– Provided directly by a componentProvided directly by a component– Corresponds to procedural interfaces of traditional Corresponds to procedural interfaces of traditional

librarieslibraries

• Indirect InterfaceIndirect Interface– Provided by objects made available to clients by a Provided by objects made available to clients by a

componentcomponent– Corresponds to object interfacesCorresponds to object interfaces

Direct and Indirect InterfacesDirect and Indirect Interfaces

Component AComponent AClient of AClient of A

Procedure A

Component BComponent BClient of BClient of B

Object B

Method B.a

Method B.b

Procedure B

Procedure C

Direct InterfaceDirect Interface

Indirect InterfaceIndirect Interface

Interfaces as ContractsInterfaces as Contracts

• Contracts State What a Client Needs to do to Contracts State What a Client Needs to do to Use an InterfaceUse an Interface

• Also State What Providers Must Implement to Also State What Providers Must Implement to Meet Services Promised by the InterfaceMeet Services Promised by the Interface

• A Popular Method: Specifying Pre-Condition A Popular Method: Specifying Pre-Condition and Post-Condition Specifications for an and Post-Condition Specifications for an OperationOperation– Hoare triple convention:Hoare triple convention:

• {precondition} operation {postcondition}{precondition} operation {postcondition}

– Dijkstra’s weakest preconditions convention:Dijkstra’s weakest preconditions convention:• wp(S,Q)wp(S,Q)

– wp = weakest precondition for which execution of S is wp = weakest precondition for which execution of S is guaranteed to terminate while meeting postcondition Qguaranteed to terminate while meeting postcondition Q

Interface Specifications Between Provider and ClientInterface Specifications Between Provider and Client

Pre and Post ConditionsPre and Post Conditions• Specification of the Form: pre U, post VSpecification of the Form: pre U, post V

– Means: Condition U must be satisfied by client upon Means: Condition U must be satisfied by client upon method entry, and condition V will be satisfied by provider method entry, and condition V will be satisfied by provider upon method exit:upon method exit:

• Usually Specified Using PredicatesUsually Specified Using Predicates

• Example: Queue interfaceExample: Queue interface

interface Queue { boolean empty();

Queue enq(Object X); @post { !this.empty() } Queue deq(); @pre { !this.empty() }}

Post condition: Queue must not be empty Post condition: Queue must not be empty afterafter executing executing enq()enq()

Pre condition: Queue must not be empty Pre condition: Queue must not be empty beforebefore executing executing deq()deq()

SubstitutabilitySubstitutability

• An Interface Must be Specified CarefullyAn Interface Must be Specified Carefully– Should not require too much or too little from clients/providersShould not require too much or too little from clients/providers

• ie: An interface should require no more than is essential for the ie: An interface should require no more than is essential for the service to be providedservice to be provided

• Allows headroom for both client and provider to overfulfill their Allows headroom for both client and provider to overfulfill their contractcontract

– Client may establish more than required by the pre-condition, and Client may establish more than required by the pre-condition, and expect less than is guaranteed by the post-conditionexpect less than is guaranteed by the post-condition

• In General:In General:– What is established by a certain client:What is established by a certain client:

Demanded by interface (precondition)Demanded by interface (precondition) Required by certain providerRequired by certain provider

– What is established by a certain provider:What is established by a certain provider: Guaranteed by interface (postcondition)Guaranteed by interface (postcondition) Expected by certain clientExpected by certain client

Ability of a Component B to Replace Component A Without Breaking A’s Client(s)Ability of a Component B to Replace Component A Without Breaking A’s Client(s)

Substitutability ExampleSubstitutability Example

interface SimpleCounter { int getValue(); void dec(); void inc();}

interface PositiveCounter { int getValue(); void dec(); @pre { this.getValue() > 0 } void inc();}

class Counter implements SimpleCounter, PositiveCounter

SimpleCounter / PositiveCounter : Identical interface SimpleCounter / PositiveCounter : Identical interface methods, different functionalitymethods, different functionality

Contract VerificationContract Verification• Contract-Checking is Highly DesirableContract-Checking is Highly Desirable

– Ideally, contracts checked against interface specificationIdeally, contracts checked against interface specification• Compiler or other automatic toolCompiler or other automatic tool

– Contract violators would be rejectedContract violators would be rejected

• In Practice:In Practice:– Fully formalized interface contracts are hard to achieveFully formalized interface contracts are hard to achieve

• Difficult and expensiveDifficult and expensive• Efficient, general-purpose verifiers are not feasibleEfficient, general-purpose verifiers are not feasible• Current research focuses on theorem-provers using heuristicsCurrent research focuses on theorem-provers using heuristics

– ExpensiveExpensive– Requires expert manual assistanceRequires expert manual assistance

• Ultimate Goal: Develop automatic error-checking as Ultimate Goal: Develop automatic error-checking as early as possible to prevent catastrophic faultsearly as possible to prevent catastrophic faults

• Preferred order of error checking:Preferred order of error checking:1)1) Compile-TimeCompile-Time2)2) Load-TimeLoad-Time3)3) Run-TimeRun-Time4)4) No Checking at All !No Checking at All !

Memory ErrorsMemory Errors• Memory ErrorMemory Error - A program reads a memory cell - A program reads a memory cell

based on a wrong assumption of what the cell based on a wrong assumption of what the cell containscontains

– Can affect unrelated parts of a programCan affect unrelated parts of a program– Are notoriously hard to track downAre notoriously hard to track down– Can be arbitrarily destructiveCan be arbitrarily destructive

• A Way Around Memory Errors: A A Way Around Memory Errors: A TypeType System System– Group values of related semantics into sets, or Group values of related semantics into sets, or typestypes

• Integers, Reals, Object References, etc.Integers, Reals, Object References, etc.• Basic types (integers, reals) understood as sets of Basic types (integers, reals) understood as sets of

valuesvalues• Objects and interfaces understood as a set of objects Objects and interfaces understood as a set of objects

implementing a certain interfaceimplementing a certain interface

– Helps ensure memory accesses are type compatibleHelps ensure memory accesses are type compatible– Use with Automatic Memory Management and Use with Automatic Memory Management and

Runtime Checks to Eliminate all Memory ErrorsRuntime Checks to Eliminate all Memory Errors

Types and SubtypesTypes and Subtypes• A A TypeType Contains All of the Operations and Contains All of the Operations and

Signatures of an InterfaceSignatures of an Interface– Input parameters form a Input parameters form a partpart of an operation’s of an operation’s

preconditionspreconditions– Output parameters form a Output parameters form a partpart of an operation’s of an operation’s

postconditionspostconditions

– NOTENOTE: Other pre and post conditions may exist beyond an : Other pre and post conditions may exist beyond an operation’s signatureoperation’s signature

A Type is an Interface with a A Type is an Interface with a SimplifiedSimplified Contract Contract

A A SubtypeSubtype is a Type Derived From a Base Interface is a Type Derived From a Base Interface– Subtypes may be formed in 2 waysSubtypes may be formed in 2 ways

• Interface InheritanceInterface Inheritance– Similar to class inheritanceSimilar to class inheritance

• Structural SubtypingStructural Subtyping– Implementation of base interface is copied from derived interfaceImplementation of base interface is copied from derived interface

Types and Subtypes ExampleTypes and Subtypes Example• ViewView is a type: is a type:

interface interface ViewView { {void close();void close();void restore(int left, int top, int right, int bottom);void restore(int left, int top, int right, int bottom);

}}

• TextViewTextView is a subtype of is a subtype of ViewView (via interface inheritance): (via interface inheritance):

interface interface TextViewTextView extends View { extends View {int caretPos();int caretPos();void setCaretPos(int pos);void setCaretPos(int pos);

}}

• TextView1TextView1 is a subtype of is a subtype of ViewView (via structural subtyping): (via structural subtyping):

interface interface TextView1TextView1 { {void close();void close();void restore(int left, int top, int right, int bottom);void restore(int left, int top, int right, int bottom);int caretPos();int caretPos();void setCaretPos(int pos);void setCaretPos(int pos);

}}

• TextViewTextView and and TextView1 TextView1 can be used wherever can be used wherever ViewView is is expectedexpected

InheritanceInheritance• Three Facets of InheritanceThree Facets of Inheritance

– SubstitutabilitySubstitutability• Can a subclass replace it’s superclass without Can a subclass replace it’s superclass without

breaking the system?breaking the system?

– Subtyping (Interface Inheritance)Subtyping (Interface Inheritance)• Can the subclass use or conform to the interface of Can the subclass use or conform to the interface of

the superclass?the superclass?

– Subclassing (Implementation Inheritance)Subclassing (Implementation Inheritance)• Can the subclass use the implementation of the Can the subclass use the implementation of the

superclass?superclass?

• Interface Inheritance is Generally Preferred Interface Inheritance is Generally Preferred Over Implementation InheritanceOver Implementation Inheritance

Multiple InheritanceMultiple Inheritance• Two Principle Reasons for Supporting MITwo Principle Reasons for Supporting MI

– To merge interfaces from different sources To merge interfaces from different sources (Multiple Interface Inheritance)(Multiple Interface Inheritance)

– To merge implementations from different sources To merge implementations from different sources (Multiple Implementation Inheritance)(Multiple Implementation Inheritance)

• Multiple Interface InheritanceMultiple Interface Inheritance– Does not generate major technical problemsDoes not generate major technical problems– Supported by OMG IDL and JavaSupported by OMG IDL and Java

• Multiple Implementation InheritanceMultiple Implementation Inheritance– May cause problems if superclasses come from May cause problems if superclasses come from

disjoint inheritance graphsdisjoint inheritance graphs

Diamond InheritanceDiamond Inheritance• The Diamond Inheritance ProblemThe Diamond Inheritance Problem

– Superclasses may inherit code from a shared Superclasses may inherit code from a shared superclass further up the inheritance graphsuperclass further up the inheritance graph

• Issues with StateIssues with State– Do classes B1 and B2 share A’s state?Do classes B1 and B2 share A’s state?

• YesYes – Breaks encapsulation – Breaks encapsulation• NoNo – Which state does class C see? – Which state does class C see?

• Issues with Behavior (or Method Issues with Behavior (or Method Implementations)Implementations)– If B1 and B2 both override A’s If B1 and B2 both override A’s

methods, which version does C see?methods, which version does C see?

• Java’s Solution:Java’s Solution:– Support multiple interface Support multiple interface

inheritance, but only single inheritance, but only single implementation inheritanceimplementation inheritance

Fragile Base Class ProblemFragile Base Class Problem• Can a Base Class Evolve?Can a Base Class Evolve?

• Syntactic Fragile Base Class ProblemSyntactic Fragile Base Class Problem– Compatibility of compiled classes with new binary Compatibility of compiled classes with new binary

releases of superclassesreleases of superclasses– Unrelated to the semantics of inherited codeUnrelated to the semantics of inherited code

• Semantic Fragile Base Class ProblemSemantic Fragile Base Class Problem– Can a subclass remain valid when the Can a subclass remain valid when the

implementation of it’s superclass is changed?implementation of it’s superclass is changed?

Avoiding FBC IssuesAvoiding FBC Issues• Disciplined InheritanceDisciplined Inheritance

– Define Rules to Allow Subclass Construction Define Rules to Allow Subclass Construction Based on a Superclass SpecificationBased on a Superclass Specification• Allows subclasses to remain valid if superclass Allows subclasses to remain valid if superclass

implementation changesimplementation changes

• Object CompositionObject Composition– Messages are forwarded to other related objectsMessages are forwarded to other related objects– Outer objects (requestor)Outer objects (requestor)– Inner objects (helper)Inner objects (helper)

• Supports late composition (can be recompiled Supports late composition (can be recompiled without recompiling it’s outer object)without recompiling it’s outer object)

ConclusionConclusion• Component Software is an Evolution of Component Software is an Evolution of

Object-Oriented SoftwareObject-Oriented Software

• Implements Code ReusabilityImplements Code Reusability

• Addresses Traditional Software Addresses Traditional Software Development IssuesDevelopment Issues

• Provides Customers with Price/Performance Provides Customers with Price/Performance Tradeoff ChoicesTradeoff Choices

Questions / DiscussionQuestions / Discussion