Date post: | 22-Dec-2015 |
Category: |
Documents |
Upload: | brett-lane |
View: | 218 times |
Download: | 1 times |
Component-Based Component-Based Software EngineeringSoftware Engineering
Introduction and OverviewIntroduction and Overview
Paul KrausePaul Krause
Lecture 1 - OverviewLecture 1 - Overview
ContentsContents Software EngineeringSoftware Engineering Components as architectureComponents as architecture What is a software component?What is a software component? InterfacesInterfaces Software as a “metaproduct”Software as a “metaproduct”
Why Software Engineering?Why Software Engineering?
The difference between writing a program The difference between writing a program and engineering a software systemand engineering a software system
is like the difference between building a is like the difference between building a patio table and building a bridgepatio table and building a bridge
You can patch up one until it worksYou can patch up one until it works You need careful analysis and design to You need careful analysis and design to
succeed with the othersucceed with the other Good Software Engineering practice is Good Software Engineering practice is
essential for Software Componentsessential for Software Components
EngineeringEngineering
The The professionprofession in which in which
a knowledge of the a knowledge of the mathematicalmathematical and and natural sciencesnatural sciences gained by study, experience and practicegained by study, experience and practice
is applied with is applied with judgementjudgement
to develop ways to to develop ways to utiliseutilise, economically, the , economically, the materials and materials and forces of nature for the benefit of mankindforces of nature for the benefit of mankind
Accreditation board for Engineering and Technology, 1996Accreditation board for Engineering and Technology, 1996
Lecture 1 - OverviewLecture 1 - Overview
ContentsContents Software EngineeringSoftware Engineering Components as architectureComponents as architecture What is a software component?What is a software component? InterfacesInterfaces Software as a “metaproduct”Software as a “metaproduct”
Software Components mean?Software Components mean?
The main driver behind software The main driver behind software components is components is reuse.reuse.
That means we must That means we must modularisemodularise applications if they are to have potentially applications if they are to have potentially reusable parts.reusable parts.
The expectation is that if the parts (often The expectation is that if the parts (often collections of classes) can be reused then collections of classes) can be reused then costs will be reduced (in the long run…).costs will be reduced (in the long run…).
So what’s new?So what’s new?
Modularisation of software is Modularisation of software is notnot new. new. What we want of a component is thatWhat we want of a component is that
It may be used by other program elements It may be used by other program elements ((clientsclients) ) • (encapsulation and low coupling – good strategies (encapsulation and low coupling – good strategies
for any modular design)for any modular design) The clients and their authors do not need to The clients and their authors do not need to
be known to the component’s authorsbe known to the component’s authors• This is a little bit new, and only works if all the This is a little bit new, and only works if all the
respective authors work to a common standardrespective authors work to a common standard
An Example ComponentAn Example Component
A Windows A Windows executableexecutable
Can be dynamically Can be dynamically linked to any linked to any Windows applicationWindows application
Can be composed Can be composed with other COM with other COM objectsobjects
account
COM Object
Computation interface
Identification interface
getName( ) setName( )
Asset interface
Do we get anything for free?Do we get anything for free?
Of course not!Of course not! Components may be classes (or Components may be classes (or
collections of classes), but they must collections of classes), but they must satisfy satisfy additionaladditional guidelines: guidelines: So we really do understand what is provided So we really do understand what is provided
and what is required at their interfacesand what is required at their interfaces So that we know the framework or So that we know the framework or
architecture in which they are to be usedarchitecture in which they are to be used
Components as architectureComponents as architecture
Could view “independent components” as a category of Could view “independent components” as a category of software architecturessoftware architectures
Pipes and filtersPipes and filters• UnixUnix
Parallel communicating processesParallel communicating processes• Java threadsJava threads
Client-serverClient-server• World-wide web;World-wide web;
• CORBA – a middle layer that provides a common data busCORBA – a middle layer that provides a common data bus Event systemsEvent systems
• Java event model and Java BeansJava event model and Java Beans
Lecture 1 - OverviewLecture 1 - Overview
ContentsContents Software EngineeringSoftware Engineering Components as architectureComponents as architecture What is a software component?What is a software component? InterfacesInterfaces Software as a “metaproduct”Software as a “metaproduct”
What is a Software What is a Software Component?Component?
““Components are units of deployment”Components are units of deployment”- Clemens SzyperskiClemens Szyperski
Drivers for CBDDrivers for CBD
The development of the WWW and The development of the WWW and InternetInternet Systems of loosely coordinated servicesSystems of loosely coordinated services
Object-oriented design techniques and Object-oriented design techniques and languageslanguages
Move from Mainframe to client-server Move from Mainframe to client-server based computingbased computing
Rapid pace of technological changeRapid pace of technological change Economic necessity of maximising reuseEconomic necessity of maximising reuse
Are Components New?Are Components New?
SubroutinesSubroutines Turing, 1949, Turing, 1949, Checking a Large RoutineChecking a Large Routine
Structured ProgrammingStructured Programming Dijkstra, 1968Dijkstra, 1968
LibrariesLibraries NAG, 1971NAG, 1971
Information HidingInformation Hiding Parnas, 1972Parnas, 1972
Software ComponentsSoftware Components
Components are for compositionComponents are for composition (In principle) already exisiting “things” can (In principle) already exisiting “things” can
be be reusedreused by rearranging them to make a by rearranging them to make a new compositenew composite
So components are about reuseSo components are about reuse This drives many of the engineering This drives many of the engineering
requirements for software componentsrequirements for software components
What is a component (2)?What is a component (2)?
A component makes its services available A component makes its services available through interfacesthrough interfaces
And interfaces are of certain types or And interfaces are of certain types or categoriescategories
Revised DefinitionRevised Definition
A software component is a unit of A software component is a unit of composition with contractually specified composition with contractually specified interfaces and explicit context interfaces and explicit context dependencies only.dependencies only.
A software component can be deployed A software component can be deployed independently and is subject to independently and is subject to composition by third parties.composition by third parties.
1996 European Conference on Object-Oriented 1996 European Conference on Object-Oriented ProgrammingProgramming
Lecture 1 - OverviewLecture 1 - Overview
ContentsContents Software EngineeringSoftware Engineering Components as architectureComponents as architecture What is a software component?What is a software component? InterfacesInterfaces Software as a “metaproduct”Software as a “metaproduct”
Connector DesignConnector Design
:Button:Button
:Button:Button
:Motor:Motor :Meter:Meter
pressed
pressed
start
stop
speed
value
Connector DesignConnector Design
:Button:Button
:Button:Button
:Motor:Motor
:Meter:Meter
pressed
pressed
start
stopspeed
value
:OR:OR:Threshold:Threshold
a
b
a b
a > b
a < b
:Multiplier:Multiplier
:Selector{1, 10, 100}
:Selector{1, 10, 100}
a b
a x b
5:int5:int
a
b
Lessons from electronics kitLessons from electronics kit
Families of products from kits of componentsFamilies of products from kits of components Design of a component infrastuctureDesign of a component infrastucture
Basic technology - e.g. do components interact via Basic technology - e.g. do components interact via procedure calls or remote method invocations?procedure calls or remote method invocations?
Component designComponent design Components must conform to the component Components must conform to the component
infrastructureinfrastructure
Product buildingProduct building
Infrastructure:Infrastructure:
Do pluggable connectors mean common Do pluggable connectors mean common data types across all components?data types across all components?
No!No! Local usage may not fit a common typeLocal usage may not fit a common type
Answer: EncapsulationAnswer: Encapsulation No direct access to the data of any No direct access to the data of any
component from outsidecomponent from outside All communication should be a request All communication should be a request
defined in an interfacedefined in an interface
Revised DefinitionRevised Definition
A software component is a unit of A software component is a unit of composition with contractually specified composition with contractually specified interfaces and explicit context interfaces and explicit context dependencies only.dependencies only.
A software component can be deployed A software component can be deployed independently and is subject to independently and is subject to composition by third parties.composition by third parties.
1996 European Conference on Object-Oriented 1996 European Conference on Object-Oriented ProgrammingProgramming
Independent DeploymentIndependent Deployment
EncapsulationEncapsulation Cannot be partially deployedCannot be partially deployed Must have clear specifications of what it Must have clear specifications of what it
requiresrequires, as well as what it provides, as well as what it provides Must have well-defined interfacesMust have well-defined interfaces
InterfacesInterfaces
Interfaces allow the clients of a component Interfaces allow the clients of a component to access the services provided by a to access the services provided by a componentcomponent
Different interfaces will normally provide Different interfaces will normally provide access to different servicesaccess to different services
Each interface specification could be Each interface specification could be viewed as a viewed as a contractcontract between the between the component and a clientcomponent and a client
Explicit context dependenciesExplicit context dependencies
Components must also specify their needsComponents must also specify their needs i.e. the context of composition and i.e. the context of composition and
deploymentdeployment This means bothThis means both
The component’s requires interfaces, andThe component’s requires interfaces, and The component world it is prepared forThe component world it is prepared for
• (CORBA, COM, Java…)(CORBA, COM, Java…)
Component SpecificationComponent Specification
Provides InterfacesProvides Interfaces The services a component can offer to a clientThe services a component can offer to a client
Requires InterfacesRequires Interfaces The services required by a component to help The services required by a component to help
it deliver its promisesit deliver its promises Context of UseContext of Use
The “world” the component lives inThe “world” the component lives in
Lecture 1 - OverviewLecture 1 - Overview
ContentsContents Software EngineeringSoftware Engineering Components as architectureComponents as architecture What is a software component?What is a software component? InterfacesInterfaces Software as a “metaproduct”Software as a “metaproduct”
Software ICs?Software ICs?
PageAcquisition
PageStore
The nature of softwareThe nature of software
““Delivery of software means delivering the Delivery of software means delivering the blueprints for products”blueprints for products”
Clemens SzyperskiClemens Szyperski When software is installed on a computer, When software is installed on a computer,
an instance of the product is instantiatedan instance of the product is instantiated The computer can instantiate the product The computer can instantiate the product
one or more timesone or more times Better to view software as a “metaproduct”Better to view software as a “metaproduct”
Plans vs. InstancesPlans vs. Instances
Plans can be parameterisedPlans can be parameterised Plans can be applied recursivelyPlans can be applied recursively Plans can be scaledPlans can be scaled Plans can be instantiated any number of Plans can be instantiated any number of
timestimes
SummarySummary
We have:We have: Seen some of the drivers behind the Seen some of the drivers behind the
introduction of component-based software introduction of component-based software engineeringengineering
Explored some definitions of software Explored some definitions of software componentscomponents
Identified the importance of specifying Identified the importance of specifying requires and provides interfacesrequires and provides interfaces
Lecture 1 (Part 2) - Lecture 1 (Part 2) - Software ArchitectureSoftware Architecture
ContentsContents Why is this interesting?Why is this interesting? What is Software Architecture?What is Software Architecture? Why is Software Architecture Important?Why is Software Architecture Important? Architectural Views and FrameworksArchitectural Views and Frameworks Architecture-Based DevelopmentArchitecture-Based Development Summing UpSumming Up
Why Study Architecture?Why Study Architecture?
The choice of Architecture determines The choice of Architecture determines many of the qualities of a software systemmany of the qualities of a software system
Architecture is the blueprint for component Architecture is the blueprint for component integrationintegration
Defines the Defines the contextcontext in which a class of in which a class of components may be usedcomponents may be used
Software Architecture is?Software Architecture is?
Software architecture is about Software architecture is about structural structural propertiesproperties::
ComponentsComponents InterrelationshipsInterrelationships PrinciplesPrinciples GuidelinesGuidelines
It is one of the earliest stages in software It is one of the earliest stages in software system designsystem design
AQUAAQUA
DARWINDARWIN
CLASSICCLASSIC CARBONCARBON COCOACOCOA JAVAJAVA
QUARTZQUARTZ OPENGLOPENGL QUICKTIMEQUICKTIME
Mac OS X Component Mac OS X Component ArchitectureArchitecture
Mac OS X Component Mac OS X Component ArchitectureArchitecture
AQUAAQUA
BSD SUBSYSTEM
MACH KERNEL
BSD SUBSYSTEM
MACH KERNEL
CLASSICCLASSIC CARBONCARBON COCOACOCOA JAVAJAVA
QUARTZQUARTZ OPENGLOPENGL QUICKTIMEQUICKTIME
IMAGING LAYERIMAGING LAYER
Mac OS X Component Mac OS X Component ArchitectureArchitecture
AQUAAQUA
BSD SUBSYSTEM
MACH KERNEL
BSD SUBSYSTEM
MACH KERNEL
CLASSICCLASSIC CARBONCARBON COCOACOCOA JAVAJAVA
QUARTZQUARTZ OPENGLOPENGL QUICKTIMEQUICKTIME
API LAYERAPI LAYER
Mac OS X Component Mac OS X Component ArchitectureArchitecture
AQUAAQUA
BSD SUBSYSTEM
MACH KERNEL
BSD SUBSYSTEM
MACH KERNEL
CLASSICCLASSIC CARBONCARBON COCOACOCOA JAVAJAVA
QUARTZQUARTZ OPENGLOPENGL QUICKTIMEQUICKTIME
USER INTERFACE LAYERUSER INTERFACE LAYER
Structural Issues?Structural Issues?
Gross organisation and global control Gross organisation and global control structurestructure
Protocols for communication, Protocols for communication, synchronisation and data accesssynchronisation and data access
Assignment of functionality to design Assignment of functionality to design elementselements
Physical distributionPhysical distribution Composition of design elementsComposition of design elements Scaling and performanceScaling and performance
Why is it important?Why is it important?
““If a project has not achieved a system If a project has not achieved a system architecture, including its rationale, the architecture, including its rationale, the project should not proceed to full-scale project should not proceed to full-scale system development. Specifying the system development. Specifying the architecture as a deliverable enables its architecture as a deliverable enables its use throughout the development and use throughout the development and maintenance process.”maintenance process.” Barry Boehm, Invited talk, Barry Boehm, Invited talk, First International First International
Workshop on Architecture for Software Workshop on Architecture for Software SystemsSystems
Three Basic Reasons:Three Basic Reasons:
Mutual communicationMutual communication A common high-level abstraction that can be used by all the A common high-level abstraction that can be used by all the
system’s stakeholderssystem’s stakeholders
Early design decisionsEarly design decisions Ones that will be important throughout the lifecycle Ones that will be important throughout the lifecycle
(development, service and maintenance)(development, service and maintenance)
Transferable abstraction of the systemTransferable abstraction of the system Relatively small, intellectually graspable model of the systemRelatively small, intellectually graspable model of the system
Transferable ModelTransferable Model
Reuse at the architectural level for systems with Reuse at the architectural level for systems with similar requirementssimilar requirements Entire product lines can share a common architectureEntire product lines can share a common architecture
Facilitates use of externally-developed Facilitates use of externally-developed componentscomponents Architecture constrains how components interact with Architecture constrains how components interact with
their environmenttheir environment How they receive and relinquish controlHow they receive and relinquish control The data they work with and produceThe data they work with and produce The protocols they use for communication and The protocols they use for communication and
resource sharingresource sharing
The Need for Multiple ViewsThe Need for Multiple Views
As well as functionality, we need to reason about As well as functionality, we need to reason about physical distribution, process communication and physical distribution, process communication and synchronisation …synchronisation …
May need different views to reflect the concerns of May need different views to reflect the concerns of different stakeholdersdifferent stakeholders
The structure represented in a viewThe structure represented in a view May or may not exist at runtimeMay or may not exist at runtime May describe the product, the process of building the product, or May describe the product, the process of building the product, or
the process of using the productthe process of using the product
Some Representative ViewsSome Representative Views
Conceptual (Logical) ViewConceptual (Logical) View Abstract representation of the functional Abstract representation of the functional
requirements: block diagrams, class diagramsrequirements: block diagrams, class diagrams Module (Development) ViewModule (Development) View
Organisation of modules, components, subsystems Organisation of modules, components, subsystems (e.g. layered architecture)(e.g. layered architecture)
Process (Coordination) ViewProcess (Coordination) View Runtime behaviour: concurrency, synchronisationRuntime behaviour: concurrency, synchronisation
The Physical ViewThe Physical View Mapping of software onto hardwareMapping of software onto hardware
Summary of ViewsSummary of Views
Conceptual
End Users- functionality
Module
Programmers- software management
Process
System Integrators- performance- scalability- throughput
Physical
System engineers- system topology- delivery- installation- telecommunication
Summing UpSumming Up
Component-based software engineering is Component-based software engineering is a highly structured way of workinga highly structured way of working
Software architecture concerns the Software architecture concerns the structural properties of a systemstructural properties of a system
______________________________________________________________________ Getting the software architecture right is a Getting the software architecture right is a
critical success factor in component-based critical success factor in component-based software engineeringsoftware engineering
Lecture 1 Part 3 - Lecture 1 Part 3 - Object-Orientation & UMLObject-Orientation & UML
ContentsContents OverviewOverview ClassifiersClassifiers Static ModellingStatic Modelling Dynamic BehaviourDynamic Behaviour Summing UpSumming Up
Unified Modelling LanguageUnified Modelling Language
Visual modelling languageVisual modelling language SpecifySpecify VisualiseVisualise ConstructConstruct DocumentDocument
UML can be used to capture information about:UML can be used to capture information about: Static structureStatic structure Dynamic behaviourDynamic behaviour Environmental aspectsEnvironmental aspects Organisational aspectsOrganisational aspects
OverviewOverview
height: Real age: Real
Person
Male_Person Female_Person
Static ViewStatic View
LockedAvailable Sold
timed out
lock
unlock
buy
Behavioural View: Single ObjectBehavioural View: Single Objectcustomer credit servicevendor
request item
show availability
select item
demand payment
insert card
charge card
Dynamic behaviour: communication patternsDynamic behaviour: communication patterns
CreditCardCharges
ItemSeller
ManagerInterface
ItemDB
SalesServer
CustomerInterface
Client
ServiceInterface
SalesTerminal
1
*
1
*
Deployment ViewDeployment View
Lecture 1 Part 4 - Lecture 1 Part 4 - Two Real-World ProjectsTwo Real-World Projects
A Talk in Four PartsA Talk in Four Parts
ProloguePrologue Requirements Modeling for Families of Requirements Modeling for Families of
Complex SystemsComplex Systems The Koala Component Model for The Koala Component Model for
Consumer Electronics SoftwareConsumer Electronics Software EpilogueEpilogue
Context: Medical imaging: X-Context: Medical imaging: X-RayRay
Cardio/Vascular
UniversalRadiographyandFluoroscopy
Radiography
Surgery
Documents: Example modelDocuments: Example model
XrayBeamToDetectorPosition
SourceImageDistance
Detector
CircleShutter
DiameterSpeed
XRayBeam
ShapeIntensitySpectrum
Exposable
RectangleShutter
HeightWidthXSpeedYSpeed
Tube
VoltageCurrent
11
Generates
Shutter
Detector
Shapes
Object
Shapes
XRaySource
1
0..*
1
0..*
11
Documents: Example use Documents: Example use casecase
Use case CloseCircleShutter:Use case CloseCircleShutter:
When the CloseShuttersEvent is received from the When the CloseShuttersEvent is received from the
ClinicalUser, then the ClinicalUser, then the DiameterDiameter of the of the ObjectObject
CircleShutterCircleShutter is decreased with a fixed is decreased with a fixed SpeedSpeed, until , until
either the StopShuttersEvent or the OpenShuttersEvent either the StopShuttersEvent or the OpenShuttersEvent
is received.is received.
ConclusionConclusion
We learned:We learned: Early construction of a requirements object model Early construction of a requirements object model
provides an explicit, shared map of concepts.provides an explicit, shared map of concepts. Developing use cases and object model hand in hand Developing use cases and object model hand in hand
leads to precise use cases and a complete model.leads to precise use cases and a complete model. Overlapping groups allow many participants and parallel Overlapping groups allow many participants and parallel
work, while maintaining consistency.work, while maintaining consistency. Not the individual technique counts, but the way they fit Not the individual technique counts, but the way they fit
together.together.
Lecture 1 Part 5 - Lecture 1 Part 5 - Object-Orientation & JavaObject-Orientation & Java
ContentsContents Getting StartedGetting Started A Little Bit of SyntaxA Little Bit of Syntax Differences between C and JavaDifferences between C and Java Object-Oriented Programming in JavaObject-Oriented Programming in Java
Defining a ClassDefining a Class
Account
numberbalance
credit_accountdebit_account
{membersfields
methods
public class Account {
public int number; public double balance;
public void credit(double x) {// do some sums } public void debit(double y) {// do checking then sums }}
““Circle” ExampleCircle” Example
Circle
radius
circumferencearea
public class Circle {
}
public double radius;
public double circumference() { return 2 * PI * radius;}public double area() { return PI * radius * radius;}
public static final double PI = 3.14159;
The “Circle” classThe “Circle” class
public class Circle {
// A class field public static final double PI= 3.14159; // A useful constant // A class method: just compute a value based on the arguments public static double radiansToDegrees(double rads) { return rads * 180 / PI; } // An instance field public double r; // The radius of the circle
// Two instance methods: they operate on the instance fields // of an object public double area() { // Compute the area of the circle return PI * r * r; } public double circumference() { // Compute the circumference return 2 * PI * r; }}
Lecture 1 Part 6 - Lecture 1 Part 6 - InterfacesInterfaces
ContentsContents Interfaces as ContractsInterfaces as Contracts Future ProofingFuture Proofing Non-functional requirementsNon-functional requirements Are we done?Are we done?
Interfaces as contractsInterfaces as contracts
Can view an interface specification as a Can view an interface specification as a “contract” between the client and a “contract” between the client and a providerprovider
So the interface specification must state:So the interface specification must state: What the client needs to doWhat the client needs to do What a provider can rely onWhat a provider can rely on What a provider must promise in returnWhat a provider must promise in return What the client can rely onWhat the client can rely on
Pre- and Post-ConditionsPre- and Post-Conditions
Pre-conditions:Pre-conditions: What the client must establish before calling What the client must establish before calling
the operationthe operation The provider can rely on this condition being The provider can rely on this condition being
true whenever the operation is calledtrue whenever the operation is called Post-conditions:Post-conditions:
What the provider must establish before What the provider must establish before returning to the clientreturning to the client
The client can rely on this condition being true The client can rely on this condition being true whenever the call to the operation returnswhenever the call to the operation returns
ExampleExample
public interface Directory { public void addEntry(String name, File file); // pre name != “” and file != null // post File file = map.get(name)}
Associate pre- and post-conditions to every method in the interface
Are we done?Are we done?
Interfaces act as contracts between clients Interfaces act as contracts between clients and providersand providers
Suggest you think about:Suggest you think about: Pre-conditionsPre-conditions Post-conditionsPost-conditions Leads-to conditionsLeads-to conditions Non-functional requirementsNon-functional requirements
As that it?As that it?
Pauls Pictures Pauls Documents Pauls Sums Pauls Homework
ProblemsProblems
Pauls Pictures Pauls Documents Pauls Sums Pauls Homework Pauls ToDo Lists
My DocumentsReportsPapersPresentations
Client
Window LibraryWindow Library
File SystemCalls
But I need totell you
something!
Slide Shows
I’m in chargehere, guys!
CallbacksCallbacks
Callbacks are used in procedural libraries when they Callbacks are used in procedural libraries when they need to handle asynchronous eventsneed to handle asynchronous events
The alternative is for the client to continuously poll the The alternative is for the client to continuously poll the library for eventslibrary for events
This is inefficient, especially if a large number of library This is inefficient, especially if a large number of library components are registered with a clientcomponents are registered with a client
But the use of callback means a client may observe But the use of callback means a client may observe “intermediate” states of a library“intermediate” states of a library
““Classically” a library’s operations would run to completion Classically” a library’s operations would run to completion before returning controlbefore returning control
EventsEvents
An abstraction of Callback that is An abstraction of Callback that is applicable to “federations” of interacting applicable to “federations” of interacting componentscomponents
The firing of an event is a way of one The firing of an event is a way of one object telling one or more other recipients object telling one or more other recipients that something interesting has happenedthat something interesting has happened The sender The sender firesfires an event an event A recipient is called a A recipient is called a listenerlistener and and handleshandles the the
eventevent
Java Event ModelJava Event Model
Event SourceEvent Source
Event ListenerEvent Listener
Register Event Listener
Fire Event
EventObject
EventObject
Grand SummaryGrand Summary
Software components are not newSoftware components are not new The recent surge of interest in them is driven by The recent surge of interest in them is driven by
the need to increase software the need to increase software reusereuse But designing software for reuse has always But designing software for reuse has always
needed additional careneeded additional care This is no different for software componentsThis is no different for software components Good engineering practice is even more Good engineering practice is even more
importantimportant