18 Design with Components

R. Baskaran

DESIGN WITH COMPONENTS

Design with reuse designs and develops a system from reusable software components. Reusing software components allows achieving better products at low cost and time.

LEARNING OBJECTIVES

• To explain the benefits of software reuse

• To discuss several different ways to implement software reuse

• To describe the development of software product lines.

REUSE

Design Reuse is the building of software from reusable components. In most engineering disciplines, systems are designed by composing existing components that have been used in other systems. To achieve better software, more quickly and at lower cost, we need to adopt a design process that is based on systematic reuse.

REUSE-BASED SOFTWARE ENGINEERING

Reused based software engineering can be categorized as the following:

· Application system reuse

· Component reuse

· Function reuse

Application System Reuse

The whole of an application system may be reused either by incorporating it without change into other systems (COTS reuse) or by developing application families. Widely practised as software systems are implemented as application families and COTS reuse is becoming increasingly common.

Component Reuse

Components of an application from sub-systems to single objects may be reused. Component reuse is seen as the key to effective and widespread reuse through component based software engineering. Component reuse must allow easy access and retrieval to the components, the component size must be suitable and the functionalities must be easy to comprehend.

Function Reuse

Software components that implement a single well-defined function may be reused. Function reuse is common in some application domains (e.g. engineering) where domain-specific libraries of reusable functions have been established.

BENEFITS OF REUSE

· Increased reliability – Components exercised in working systems are tried and tested under real conditions

· Reduced process risk -Less uncertainty in development costs.

· Effective use of specialists – The components are reused instead of application experts develop components instead of repeating the same on multiple projects.

· Standards compliance – Embed standards in reusable components (e.g. menu format).

· Accelerated development – Avoid original development and hence speed-up production which may reduce testing time as well.

REQUIREMENTS FOR DESIGN WITH REUSE

The requirements for design with reuse comprises of the following:

· It must be possible to find appropriate reusable components

· The re-user of the component must be confident that the components will be reliable and will behave as specified.

· The components must be documented so that they can be understood and, where appropriate, modified.

REUSE PROBLEMS

The challenges encountered during reusing of components are as follows:

· Increased maintenance costs – If source code of components is not available, then other parts for modification must be engineered around the components which are inflexible

· Not-invented-here syndrome – Some developers resist reuse due to matter of trust, and question of creativity

· Lack of tool support

· Maintaining a component library as an effective library for reuse can be difficult and expensive

· Finding and adapting reusable components

GENERATOR-BASED REUSE

Program generators involve the reuse of standard patterns and algorithms. These are embedded in the generator and parameterised by user commands from which a program is then automatically generated. Generator-based reuse is possible when domain abstractions and their mapping to executable code can be identified. A domain specific language is used to compose and control these abstractions.

Types of Program Generator

· Application generators for business data processing

· Parser and lexical analyser generators for language processing

· Code generators in CASE tools

REUSE THROUGH PROGRAM GENERATION

Reuse through program generation involves obtaining a well defined application description which contains the details of the application. The application domain knowledge is gathered, the description and knowledge are fed into the program generator which automatically generates the program which has access to the database.

COMPONENT-BASED DEVELOPMENT

Component-based software engineering (CBSE) is an approach to software development that relies on reuse. Components are more abstract than object classes and can be considered to be stand-alone service providers. Components provide a service without regard to where the component is executing or its programming language. Components can range in size from simple functions to entire application systems and are independent – very loosely coupled. Components are encapsulated to wrap functionalities. The components are obtained from the repositories which are composed to develop a component based system

COMPONENT INTERFACES

Component interface provides the interaction between components of a system. A component encompasses two functionalities in terms of interface:

• Provides interface – It defines the services that are provided by the component to other components

• Requires interface – It defines the services that specifies what services must be made available for the component to execute as specified.

Example: Printing Services Component

Requires – GetPDFile – to get printer description file for a printer type, and PrinterInt – to transfer commands to a specific printer
Provides – Print, GetOueue, Remove, Transfer, Register and Unregister.

COMPONENTS – DIFFERENT LEVELS OF ABSTRACTIONS

Components posses different levels of abstraction as follows:

• Functional abstraction– The component implements a single function such as a mathematical function

• Casual groupings – The component is a collection of loosely related entities that might be data declarations, functions, etc.

• Data abstractions– The component represents a data abstraction or class in an object- oriented language

• Cluster abstractions – The component is a group of related classes that work together (sometimes called a framework)

• System abstraction – The component is an entire self-contained system. Provides interface is the so-called API (application programming interface)

CBSE PROCESSES

The system requirements are modified to reflect the components that are available. CBSE usually involves a prototyping or an incremental development process with components being ‘glued together’ using a scripting language. The process involves designing the system architecture. Based on the architecture the components are specified, the suitable components that can be reused are determined and are incorporated in the architecture for the development of component based software development.

DEVELOPMENT WITH REUSE

The development with reuse methodology involves establishing a well defined outline of the system requirements. The requirements are analysed and the components that can be reused are determined and selected. Based on the selected components the requirements are modified and the architectural system is well established. The reusable components are determined and the components are specified based on the reusable components that are suitable for development of the system. The specified components are later incorporated in the development of the system.

CBSE PROBLEMS

The challenges that are encountered during component based software development are as follows:

· Component incompatibilities may mean that cost and schedule savings are less then expected.

· Finding and understanding components.

· Managing evolution as requirements change in situations where it may be impossible to change the system components.

APPLICATION FRAMEWORKS

Frameworks are a sub-system design made up of a collection of abstract and concrete classes and the interfaces between them. The sub-system is implemented by adding components to fill in parts of the design and by instantiating the abstract classes in the framework. Frameworks are moderately large entities that can be reused. The framework classes include:

· System infrastructure frameworks.

· Middleware integration frameworks.

· Enterprise application frameworks.

System Infrastructure Frameworks

System infrastructure framework supports the development of system infrastructures such as communications, user interfaces and compilers. Best developed of these three is particularly for GUI.

Middleware Integration Frameworks

Standards and classes that support component communication and information exchange encompass middleware integration framework. Examples – CORBA, COM, DCOM, JavaBeans.

Enterprise Application Frameworks

Enterprise Application Frameworks supports the development of specific types of application such as telecommunications or financial systems.

Extending Frameworks

Frameworks are generic and are extended to create a more specific application or sub-system. Extending the framework involves

· Adding concrete classes that inherit operations from abstract classes in the framework.

· Adding methods that are called in response to events that are recognised by the framework (call backs).

MODEL-VIEW CONTROLLER

Model-View Controller provides a system infrastructure framework for GUI design. It allows multiple presentations of an object and separate interactions with these presentations. MVC framework involves the instantiation of a number of patterns.

The controller possesses the application logic which process the users request and gets appropriate response. View provides the visual design and model comprises of the database, sometimes these can be xml or even text files.

COTS PRODUCT REUSE

COT is the acronym for Commercial Off-The-Shelf systems. COTS systems are usually complete application systems that offer an API (Application Programming Interface). Building large systems by integrating COTS systems is now a viable development strategy for some types of system such as E-commerce systems.

Component Reusability

Component reusability should reflect stable domain abstractions such as fundamental concepts in the application domain that change slowly – e.g. bank accounts, univ students. It should hide state representation and be as independent as possible. Component reusability should publish exceptions through the component interface; different applications will have different requirements for exception handling and the applications handle them rather than trying to handle them in the component.

Reusability Enhancement

· Name generalisation – Names in a component may be modified so that they are not a direct reflection of a specific application entity.

· Operation generalisation- Operations may be added to provide extra functionality and application specific operations may be removed

· Exception generalisation- Application specific exceptions are removed and exception management added to increase the robustness of the component

· Component certification – Component is certified as reusable

Web Links

htthttps://www.design-reuse.com/
https://www.techopedia.com/definition/15203/design-reuse
https://www.mentor.com/products/fpga/design-reuse

Supporting & Reference Materials

Roger S. Pressman, “Software Engineering: A Practitioner’s Approach”, Fifth Edition, McGraw Hill, 2001.
Pankaj Jalote, “An Integrated Approach to Software Engineering”, Second Edition, Springer Verlag, 1997.
Ian Sommerville, “Software Engineering”, Sixth Edition, Addison Wesley, 2000.