Date post: | 28-Dec-2015 |
Category: |
Documents |
Upload: | kerry-gray |
View: | 231 times |
Download: | 5 times |
Component-based software engineering
Component definition
What is a Component?
We can find several definitions of a component in literature, however everyone agrees that a component is a piece of software.
Component everywhere Concerns and goals are similar in many engineering
disciplines• Precise assembly of reusable, well-documented, quality
and trusted parts
For them components are well established• Civil engineering -> house prefab, …• Chemical engineering-> proteins, …• Electronic engineering-> circuit,…• Industrial engineering -> cars, …
Example: the automobile
Car assembly was a costly, tedious and slow process
Henry Ford life’s goal:• Produce cars for the masses by building them
faster Ford’s method
• The assembly line (1914)• Idea by reversing the process of beef- trolleys:
butchers removed cuts from the carcass passed by until nothing remained.
Component-based development
Component-based software engineering (CBSE) is an approach to software development that relies on software reuse.
It emerged from the failure of object-oriented development to support effective reuse.
Single object classes are too detailed and specific.
Components are more abstract than object classes and can be considered to be stand-alone service providers.
Reusable Component Example
Linked list of elements where each element maintains a pointer to the next element in the list.
Objects and Components
Pfister and Szyperski• View a component as a collection of objects,
in which the objects co-operate with each other, and are intertwined tightly.
D'Souza and Wills • Assert that if a class were packaged together
with the explicitly defined interfaces which it requires and implements, then this class would be a component.
Objects and Components Continued
Components have a more extensive set of intercommunication mechanisms than objects which usually use the messaging mechanism.
Components are often larger units of granularity than objects, and have complex actions at their interfaces.
Component definitions Councill and Heinmann:
• A software component is a software element that conforms to a component model and can be independently deployed and composed without modification according to a composition standard.
Szyperski:• A software component is a unit of composition
with contractually specified interfaces and explicit context dependencies only. A software component can be deployed independently and is subject to composition by third-parties.
What is not a component
The requirement for independence rules out• Type declarations• C macros• C++ templates• Smalltalk blocks
What could be a component
Procedures Libraries Classes (not objects) Modules Web browsers’ plug-ins
Examples NASA software
• 25 software product ranged from 3000 to 112000 lines of source code
• 7188 components classified into 4 classes• Component used without changes• Components reused with slight revisions less than
25%• Components reused with major revisions • Components reused with developing rom scratch
Case study Document editor
• Create new document• Open, save, and print document• Cut selected text from document• Change font and style of text• Change formatting of text• Check spelling• ……
CBSE and design principles Apart from the benefits of reuse, CBSE is
based on sound software engineering design principles:• Components are independent so do not
interfere with each other;• Component implementations are hidden;• Communication is through well-defined
interfaces;• Component platforms are shared and
reduce development costs.• Components are language-independent.
Describing a Component
To be able to describe a component completely the component should consist of the following elements: • A set of interfaces provided to, or
required from the environment.
• An executable code, which can be coupled to the code of other components via interfaces.
Interfaces
A component interface define mean to connect a component
In a component based application providers and clients are ignorant of each other
A component can have multiple interfaces• To offer multiple services (possibly with
overlapping functionalities)• To allow for multiple versions to live together
Component interfaces
Provides interface
• Defines the services that are provided by the
component to other components (deployment
environment).
Requires interface
• Defines the needs that specifies what services
must be made available for the component to
execute as specified.
Component interfaces
A data collector component
Provides interfaceRequires interface
Data collector
addSensorremoveSensorstartSensor
stopSensor
testSensor
listAllreport
initialise
sensorManagement
sensorData
Indirect interface An indirect interface uses a technique called dispatch
which can lead to involvement of a third party which might be unknown to both client and the provider
Text services class
Word processing comp. Grammar checking comp.
Word processor class Grammar checker class
Text services component
Checker interface
Has-aHas-a Has-a Implements
Contracts A more accurate specification of a component's
behavior can be achieved through contracts. A contract is comprised of:
• The Invariant, the global constraints which the component will maintain;
• The Pre-condition, the constraints which need to be met by the client;
• The Post-condition, the constraints which the component promises to establish in return.
How can we write a contract Hoare triples {Pre} operation {Post}
• Partial correctness• Total correctness
Temporal logic• Progress (leads-to, eventually)• Safety (Invariants, always)• Fairness (eventually always)
With time and space bounds• Average cases• Together with platform-dependent measurments
Informally, in precise but plain English• Several interpretations can be found• Analogy with real-world laws
Formal description of photo library
Software Frameworks CBSE means that we build software by
"putting pieces together". Frameworks provide the context in which the pieces can be used.
A framework may be seen as:• A reusable design of a system, • A skeleton of an application which can be
customized by an application developer.
Component Frameworks
While frameworks in general describe a typical and reusable situation at a model level,
a component framework describes a “circuit-board” with empty slots into which components can be inserted to create a working instance.
Coordination Services (transactions, persistence..)
ComponentFramework
Frameworks and Contracts
Frameworks and Contracts• Frameworks focus on the overall
properties of component compositions. • Contracts give specifications for
relationships between concrete components.
These specifications may be different for components within one composition.
Patterns Patterns define recurring solutions to
recurring problems capturing non-obvious solutions, not just abstract principles or strategies.
• The solutions should be proven to solve the problem rather than being theories.
• Patterns describe relationships between deeper system structures and mechanism.
• A component, as a reusable entity, can be seen as a realization of some design pattern.
Three Categories of Patterns Patterns can be classified into three major
categories:
• Architectural Patterns, capture the overall structure and organization of a software system.
• Design Patterns, refine the structure and the behavior of the subsystems as well as the components of a software system, and the relationships which exist between them.
• Idioms, are low-level patterns which are dependent on the chosen paradigm and the programming language used.
Design Patterns
Design patterns are widely used in the process of designing component-based systems in which the reusable units must be identified.
By using design patterns, it is easier to recognize those reusable parts and either find them in the form of pre-existing components, or develop them as reusable units.
Component models A component model is a definition of
standards for component implementation, documentation and deployment.
The component model specifies how interfaces should be defined and the elements that should be included in an interface definition.
Examples of component models• EJB model (Enterprise Java Beans)• COM+ model• Corba Component Model
Component Technologies Corba - Common Object Requesting Broker
Architecture• Map the IDL language to your native language
Microsoft’s COM• Binary Type System• Metadata• Interface or contract based – the unit of reuse.
• Resort to IUnknown interface
• Runtime-loading – allows copy and paste of objects. Enterprise JavaBeans .NET Remoting
Elements of a component model
Component model
InterfacesUsage
informationDeployment
and use
Interfacedefinition
Specificinterfaces
Composition
Namingconvention
Meta-dataaccess
Customisation
Packaging
Documentation
Evolutionsupport
The CBSE process
Identify candidatecomponents
Outlinesystem
requirements
Modifyrequirements
according to discoveredcomponents
Identify candidatecomponents
Architecturaldesign
Composecomponents tocreate system
The component identification process
Componentselection
Componentsearch
Componentvalidation
Component identification issues Trust. You need to be able to trust the supplier of
a component. At best, an untrusted component may not operate as advertised; at worst, it can breach your security.
Requirements. Different groups of components will satisfy different requirements.
Validation. • The component specification may not be detailed
enough to allow comprehensive tests to be developed.
• Components may have unwanted functionality. How can you test this so it will not interfere with your application?
Component composition
The process of assembling components to create a system.
Composition involves integrating components with each other and with the component infrastructure.
Types of composition Sequential composition where the composed
components are executed in sequence. This involves composing the provides interfaces of each component.
Hierarchical composition where one component calls on the services of another. The provides interface of one component is composed with the requires interface of another.
Additive composition where the interfaces of two components are put together to create a new component.
Types of composition
(a)
A A
B B
A B
(b) (c)
Incompatible components
addressFinder
phoneDatabase (string command)string location(string pn)
string owner (string pn)
string propertyType (string pn)
mapper
mapDB (string command)displayMap (string postCode, scale)
printMap (string postCode, scale)
Adaptor components
Address the problem of component incompatibility by reconciling the interfaces of the components that are composed.
An addressFinder and a mapper component may be composed through an adaptor that strips the postal code from an address and passes this to the mapper component.
Composition through an adaptor The component postCodeStripper is the adaptor
that facilitates the sequential composition of addressFinder and mapper components.
Adaptor for data collector
Data collector
addSensorremoveSensorstartSensor
stopSensortestSensor
listAllreportinitialise
sensorManagement
sensorData
Adaptersensor
start
getdata
stop
Photo library composition
PhotoLibrary
adaptorImage
Manager
getImage
UserInterface
getCatalogEntry
addItem
retrieve
catEntry
Photo library Case study the Photo Library component states that:
• There must not be a photograph in the library with the same identifier as the photograph to be entered;
• The library must exist - assume that creating a library adds a single item to it;
• Each new entry increases the size of the library by 1;• If you retrieve using the same identifier then you get
back the photo that you added;• If you look up the catalogue using that identifier, then
you get back the catalogue entry that you made.
Formal description of photo library
Reusable Component Example
Linked list of elements where each element maintains a pointer to the next element in the list.
Class Templates Many C++ programs use common data structures
like stacks, queues and lists. A program may require a queue of customers and a
queue of messages. One could easily implement a queue of customers, then take the existing code and implement a queue of messages.
It seems to make more sense to implement a queue that can contain any arbitrary type.
Class Templates How does one do that? The answer is to use type
parameterization, more commonly referred to as templates.
C++ templates allow one to implement a generic Queue<T> template that has a type parameter T.
T can be replaced with actual types Once the changes are implemented in the template
Queue<T>, they are immediately reflected in the classes Queue<Customers>, Queue<Messages>, and Queue<Orders>.
C++ Class Templates
C++ provides two kinds of templates: class templates and function templates.
Use function templates to write generic functions that can be used with arbitrary types.
For example, one can write searching and sorting routines which can be used with any arbitrary type.
C++ Class Templatestemplate <class T>
class Stack {
public:
Stack(int = 10) ;
~Stack() { delete [] stackPtr ; }
int push(const T&);
int pop(T&) ;
int isEmpty()const { return top == -1 ; }
int isFull() const { return top == size - 1 ; }
private:
int size ; // number of elements on Stack.
int top ;
T* stackPtr ; } ;
C++ Function Templates
#include <iostream>
using namespace std ; //max returns the maximum of the two elements
template <class T>
T max(T a, T b)
{ return a > b ? a : b ; }
C++ Linked List
template <class elem> class List{public:
List(); // Automatic constructor~List(); // Automatic destructor// Basic list operationselem Head (error_indic &Err) ; int Length ( ) ;List <elem> Tail (error_indic &Err) ;// Equality operationsfriend List <elem> operator == (List <elem> L1, List <elem> L2) ;friend List <elem> Equivalent (List <elem> L1, List <elem> L2) ;// Constructor operations for linked listvoid Append (elem E, error_indic &Err) ;
void Add (elem E, error_indic &Err) ; void Add_before (elem E, error_indic &Err) ; void Add_after (elem E, error_indic &Err) ; void Replace (elem E, error_indic &Err) ; void Clear (error_indic &Err ) ; void Prune (error_indic &Err ) ; void Prune_to (elem E, error_indic &Err ) ; void Prune_from (elem E, error_indic &Err ) ; void Remove (elem E, error_indic &Err ) ; void Remove_before (elem E, error_indic &Err ) ; void Remove_after (elem E, error_indic &Err ) ;
C++ Linked List
// I/O functionsvoid Print(error_indic &Err) ;
void Write_list(char* filename, error_indic &Err) ; void Read_list(char* filename, error_indic &Err) ;private:
typedef struct Linkedlist { elem val; Linkedlist* next; } Linkedlist;
Linkedlist* Listhead ; // (Internal) Pointer to start of list};
template <class elem> class Iterator { friend class List <elem> ;public: Iterator () ; ~Iterator () ; void Create (List <elem> L, error_indic &Err) ; void Go_next (error_indic &Err) ; elem Eval (error_indic &Err) ; boolean At_end () ;private: Linkedlist* iter ;} ;
C# components
The most commonly used components in .NET are the visual controls that you add to Windows Forms such as the Button Control (Windows Forms), ComboBox Control (Windows Forms), and so on.
Non-visual components include the Timer Control, SerialPort, and ServiceController among others.
What defines a component?
What defines a component?• Properties, methods, events
• Design-time and runtime information
• Integrated help and documentation
AP 08/01
public class Button: Controlpublic class Button: Control{{ private string caption;private string caption;
public string Caption {public string Caption { get {get { return caption;return caption; }} set {set { caption = value;caption = value; Repaint();Repaint(); }} }}}}
Properties Properties are “smart fields”
• Natural syntax, accessors, inlining
Button b = new Button();Button b = new Button();b.Caption = "OK";b.Caption = "OK";String s = b.Caption;String s = b.Caption;
AP 08/01
Indexers Indexers are “smart arrays”
• Can be overloaded
public class ListBox: Control{ private string[] items;
public string this[int index]{ get { return items[index]; } set { items[index] = value; Repaint(); } }}
ListBox listBox = new ListBox();ListBox listBox = new ListBox();listBox[0] = "hello";listBox[0] = "hello";Console.WriteLine(listBox[0]);Console.WriteLine(listBox[0]);
AP 08/01
Events Efficient, type-safe and customizable
• Built on delegates
public class MyForm: Form { public MyForm() { Button okButton = new Button(...);
okButton.Click += new EventHandler(OkButtonClick); }
void OkButtonClick(…) { ShowMessage("You clicked OK"); }}
Events
Events enable a class or object to notify other classes or objects when something of interest occurs
The class that sends (or raises) the event is called the publisherand the classes that receive (or handle) the event are called subscribers.
Projects
http://www.fuka.info.waseda.ac.jp/Project/CBSE/metrics.html
http://www.fuka.info.waseda.ac.jp/Project/CBSE/fukabeans/