Software Project Management and Finance

(21CSE151)

Module 2
Chapter-2
Design and Implementation
By,
Dr. Chaitra M
Topics covered

 Object-oriented design using the UML

 Design patterns
 Implementation issues
 Open source development

Chapter 2 Design and Implementation 2

Design patterns

Design patterns are solutions to general problems that software

developers faced during software development.
A design pattern is a general repeatable solution to a commonly
occurring problem in software design.
Patterns are a way of reusing the knowledge and experience of other
designers.

Chapter 2 Design and Implementation 33

Design patterns

 A design pattern is a way of reusing abstract knowledge

about a problem and its solution.
 A pattern is a description of the problem and the essence
of its solution.
 It should be sufficiently abstract to be reused in different
settings.
 Pattern descriptions usually make use of object-oriented
characteristics such as inheritance and polymorphism.

Chapter 2 Design and Implementation 34

 Pattern elements

 Name
 A meaningful (reference to the pattern) pattern identifier.
 Problem description.
 explains when the pattern may be applied.
 Solution description.
 Not a concrete design but a template for a design solution that can be
instantiated in different ways. This is expressed graphically and shows the
relationships between the objects and object classes in the solution.
 Consequences
 This can help designers understand whether or not a pattern can be used
in a particular situation.

Chapter 2 Design and Implementation 35

The Observer pattern

 Name
 Observer.
 Description
 Separates the display of object state from the object itself.
 Problem description
 Used when multiple displays of state are needed.
 Solution description
 (design solution) See slide with UML description.
 Consequences
 Optimisations to enhance display performance are impractical.

Chapter 2 Design and Implementation 36

The Observer pattern (1)

Pattern Observer
name
Description Separates the display of the state of an object from the object itself and
allows alternative displays to be provided. When the object state
changes, all displays are automatically notified and updated to reflect the
change.
Problem In many situations, you have to provide multiple displays of state
description information, such as a graphical display and a tabular display. Not all of
these may be known when the information is specified. All alternative
presentations should support interaction and, when the state is changed,
all displays must be updated.
This pattern may be used in all situations where more than one
display format for state information is required and where it is not
necessary for the object that maintains the state information to know
about the specific display formats used.

Chapter 2 Design and Implementation 37

 The Observer pattern (2)

Pattern name Observer

Solution This involves two abstract objects, Subject and Observer, and two concrete objects,
description ConcreteSubject and ConcreteObject, which inherit the attributes of the related
abstract objects.
The abstract objects include general operations that are applicable in all situations.
The state to be displayed is maintained in ConcreteSubject, which inherits operations
from Subject allowing it to add and remove Observers (each observer corresponds to a
display) and to issue a notification when the state has changed.

The ConcreteObserver maintains a copy of the state of ConcreteSubject and

implements the Update() interface of Observer that allows these copies to be kept in
step. The ConcreteObserver automatically displays the state and reflects changes
whenever the state is updated.

Consequences The subject only knows the abstract Observer and does not know details of the
concrete class. Therefore there is minimal coupling between these objects. Because of
this lack of knowledge, optimizations that enhance display performance are
impractical. Changes to the subject may cause a set of linked updates to observers to
be generated, some of which may not be necessary.

Chapter 2 Design and Implementation 38

Multiple displays using the Observer pattern

Shows two graphical presentations of the same data set.

Chapter 2 Design and Implementation 39

An association is a relationship between two classes, indicated by a line:

Chapter 2 Design and Implementation 40

 shows a class diagram for a car factory.

Chapter 2 Design and Implementation 41

The diagram shows a UML class diagram with three classes.

Chapter 2 Design and Implementation 42

Observe Pattern Example

Chapter 2 Design and Implementation 43

A UML model of the Observer pattern

Chapter 2 Design and Implementation 44

Design problems

 To use patterns in your design, you need to recognize that any design
problem you are facing may have an associated pattern that can be applied.
 Tell several objects that the state of some other object has changed
(Observer pattern).

 Tidy up the interfaces to a number of related objects that have often

been developed incrementally (Façade pattern).
Facade pattern hides the complexities of the system and provides an
interface to the client using which the client can access the system.

 Provide a standard way of accessing the elements in a collection,

irrespective of how that collection is implemented (Iterator pattern).

 Allow for the possibility of extending the functionality of an existing class

at run-time (Decorator pattern).
Chapter 2 Design and Implementation 45
Implementation issues

 Focus here is not on programming, although this is

obviously important, but on other implementation issues
that are often not covered in programming texts:
 Reuse Most modern software is constructed by reusing existing
components or systems. When you are developing software, you
should make as much use as possible of existing code.
 Configuration management During the development process,
you have to keep track of the many different versions of each
software component in a configuration management system.
 Host-target development Production software does not usually
execute on the same computer as the software development
environment. Rather, you develop it on one computer (the host
system) and execute it on a separate computer (the target
system).
Chapter 2 Design and Implementation 46
Reuse

 From the 1960s to the 1990s, most new software was

developed from scratch, by writing all code in a high-
level programming language.
 The only significant reuse or software was the reuse of functions
and objects in programming language libraries.
 Costs and schedule pressure (shortness of working time)
mean that this approach became increasingly unviable
(not feasible), especially for commercial and Internet-
based systems.
 An approach to development based around the reuse of
existing software emerged and is now generally used for
business and scientific software.
Chapter 2 Design and Implementation 47
Reuse levels

Software reuse is possible at a number of different levels:

 The abstraction level
 At this level, you don’t reuse software directly but use knowledge
of successful abstractions in the design of your software.
 The object level
 At this level, you directly reuse objects from a library rather than
writing the code yourself.
 The component level
 Components are collections of objects and object classes that
you reuse in application systems.
 The system level
 At this level, you reuse entire application systems.
Chapter 2 Design and Implementation 48
 Reuse costs

By reusing existing software, you can develop new systems more quickly, with fewer
development risks and also lower costs.
 The costs of the time spent in looking for software to reuse
and assessing whether or not it meets your needs.
 Where applicable, the costs of buying the reusable software.
For large off-the-shelf systems, these costs can be very
high.
 The costs of adapting and configuring the reusable software
components or systems to reflect the requirements of the
system that you are developing.
 The costs of integrating reusable software elements with
each other (if you are using software from different sources)
and with the new code that you have developed.
Chapter 2 Design and Implementation 49
Configuration management

That tracks and monitors changes to a software systems

Goal: to minimize the mistakes.

 Configuration management is the name given to the

general process of managing a changing software
system.
 The aim of configuration management is to support the
system integration process so that all developers can
access the project code and documents in a controlled
way, find out what changes have been made, and
compile and link components to create a system.
 See also Chapter 25.

Chapter 2 Design and Implementation 50

Chapter 2 Design and Implementation 51
 Configuration management activities

 Version management, where support is provided to keep track of

the different versions of software components. Version
management systems include facilities to coordinate
development by several programmers.
 System integration, where support is provided to help developers
define what versions of components are used to create each
version of a system. This description is then used to build a
system automatically by compiling and linking the required
components.
 Problem tracking, where support is provided to allow users to
report bugs and other problems, and to allow all developers to
see who is working on these problems and when they are fixed.
track the different software component versions
Chapter 2 Design and Implementation 52
 Host-target development

• Most software is developed on one

computer (the host), but runs on a separate
machine (the target).
• More generally, we can talk about a
development platform and an execution
platform.
A platform is more than just hardware.
It includes the installed operating system
plus other supporting software such as a
database management system or, for
development platforms, an interactive
development environment.
• Development platform usually has different
installed software than execution platform;
these platforms may have different
architectures. Chapter 2 Design and Implementation 53
 Development platform tools

A software development platform should provide a range of tools to support software

engineering processes. These may include

 An integrated compiler and syntax-directed editing

system that allows you to create, edit and compile code.
 A language debugging system.
 Graphical editing tools, such as tools to edit UML
models.
 Testing tools, such as Junit that can automatically run a
set of tests on a new version of a program.
 Project support tools that help you organize the code for
different development projects.
Chapter 2 Design and Implementation 54
Integrated development environments (IDEs)

Software development tools are often grouped to

create an integrated development environment
(IDE).

An IDE is a set of software tools that supports

different aspects of software development, within
some common framework and user interface.

IDEs are created to support development in a

specific programming language such as Java.
The language IDE may be developed specially, or may be an instantiation of
a general-purpose IDE, with specific language-support tools.

Chapter 2 Design and Implementation 55

Chapter 2 Design and Implementation 56
Chapter 2 Design and Implementation 57
 Component/system deployment factors

 The hardware and software requirements of a component: If a component

is designed for a specific hardware architecture, or relies on some other
software system, it must obviously be deployed on a platform that
provides the required hardware and software support.
 The availability requirements of the system: High availability systems may
require components to be deployed on more than one platform. This
means that, in the event of platform failure, an alternative
implementation of the component is available.
 Component communications: If there is a high level of communications
traffic between components, it usually makes sense to deploy them on the
same platform or on platforms that are physically close to one other. This
reduces the delay between the time a message is sent by one component
and received by another.

Chapter 2 Design and Implementation 58

Key points

 When developing software, you should always consider the

possibility of reusing existing software, either as components,
services or complete systems.
 Configuration management is the process of managing changes to
an evolving software system. It is essential when a team of people
are cooperating to develop software.
 Most software development is host-target development. You use an
IDE on a host machine to develop the software, which is transferred
to a target machine for execution.
 Open source development involves making the source code of a
system publicly available. This means that many people can
propose changes and improvements to the software.

Chapter 2 Design and Implementation 70