Software Maintenance is the process of modifying a software product after it has been

delivered to the customer. The main purpose of software maintenance is to modify and
update software application after delivery to correct faults and to improve performance.
Need for Maintenance –
Software Maintenance must be performed in order to:
 Correct faults.
 Improve the design.
 Implement enhancements.
 Interface with other systems.
 Accommodate programs so that different hardware, software, system features,
and telecommunications facilities can be used.
 Migrate legacy software.
 Retire software.

Categories of Software Maintenance –

Maintenance can be divided into the following:
1. Corrective maintenance:
Corrective maintenance of a software product may be essential either to rectify
some bugs observed while the system is in use, or to enhance the performance of
the system.
2. Adaptive maintenance:
This includes modifications and updations when the customers need the product to
run on new platforms, on new operating systems, or when they need the product to
interface with new hardware and software.
3. Perfective maintenance:
A software product needs maintenance to support the new features that the users
want or to change different types of functionalities of the system according to the
customer demands.
4. Preventive maintenance:
This type of maintenance includes modifications and updations to prevent future
problems of the software. It goals to attend problems, which are not significant at
this moment but may cause serious issues in future.

Assignment 2

3. Object-oriented metrics describe aspects of object-oriented programming. Object oriented Metrics

support the main concepts of the object-oriented paradigm and the consequent emphasis on reuse, that
are believed to be responsible for the increasing in software quality and development productivity.

Types of OO Metrics:
1• CK Metrics

• Proposed by Chidamber and Kemerer

• class-based metrics

2• LK Metrics

• Proposed by Lorenz and Kidd

• class-based and operation-based

3 • MOOD Metrics

• Proposed by Harrison, Counsell, and Nithi

• class-based

CK Metrics

CK metrics in 1991, Chidamber and Kemerer proposed a first version of these metrics and later the
definition of some of them were improved and presented in 1994. The six metrics can be summarized as
in Table 1.
2.1 CK metrics
In 1991, Chidamber and
Kemerer[1] proposed a
first version of these
metrics and later the
definition of some of
them were improved and
presented in 1994[2]. The
six metrics can be
summarised as in Table 1.
Table1: CK Metrics
Metric Name Definition
WMC
(Weighted
Method Per
Class)
Sum of Complexities of local
methods
of a class.
DIT (Depth of
Inheritance)
The depth of a class within the
inheritance hierarchy is the
maximum
number of steps from the class
node to
the root of the tree and is
measured by
the number of ancestor classes.
NOC (Number
of Children)
A count of the number of direct
children
of a given class.
CBO (Coupling
Between
Objects)
This metric is a count of the
number of
other classes to which the
current class
is coupled, via non-inheritance-
related
couples. Two classes are
coupled when
the methods of one class use
metho
2.1 CK metrics
In 1991, Chidamber and
Kemerer[1] proposed a
first version of these
metrics and later the
definition of some of
them were improved and
presented in 1994[2]. The
six metrics can be
summarised as in Table 1.
Table1: CK Metrics
Metric Name Definition
WMC
(Weighted
Method Per
Class)
Sum of Complexities of local
methods
of a class.
DIT (Depth of
Inheritance)
The depth of a class within the
inheritance hierarchy is the
maximum
number of steps from the class
node to
the root of the tree and is
measured by
the number of ancestor classes.
NOC (Number
of Children)
A count of the number of direct
children
of a given class.
CBO (Coupling
Between
Objects)
This metric is a count of the
number of
other classes to which the
current class
is coupled, via non-inheritance-
related
couples. Two classes are
coupled when
the methods of one class use
metho
Objective of CK metrics were defined to measure design complexity in relation to their impact on
external quality attributes such as maintainability, reusability, etc.

https://www.aivosto.com/project/help/pm-oo-ck.html

https://www.slideserve.com/jayden/course-notes-set-12-object-oriented-metrics-powerpoint-ppt-
presentation

https://www.researchgate.net/publication/236616349_An_Overview_of_Various_Object_Oriented_Me
trics
The original suite has later been amended by RFC´, LCOM2, LCOM3 and LCOM4 by other authors.
 5. https://www.tutorialspoint.com/software_engineering/case_tools_overview.htm

23  CASE Tools Computer Aided Software Engineering

It refers to the collection of software programs that are designed to automate
the development cycleThe implementation of new systems requires many
different complex tasks to be organised and completed correctly and
efficientlyInformation generated has to be kept in synchronisationThe use of
CASE tools eases the task of coordinating these activates from analysis to
implementation

24  Computer-Aided Software Engineering (CASE), in the field of

Software Engineering is the scientific application of a set of toolsand methods to
a software system which is meant to result inhigh-quality, defect-free, and
maintainable software products.It also refers to methods for the development
ofinformation systems together with automated tools that can beused in the
software development process

25  Types of CASE Tools Basic categories of CASE tools are available:

Diagramming tools that represent data models according to system
specifications.Screen and Report Generators for creating system
specifications.Data Dictionaries that contain a history of changes made to a
systemCode Generators to be able to generate code from data Diagrams
themselves.Documentation generators that make the code more readable.

26  Development of CASESine the early days of writing software there has been
a need for automated tools to help the software developerAs computer became
more powerful ad the software that ran on them grew larger and more complex,
power tools with increasing functionality were required

27  Categories of CASE Tools

CASE tools can be divided into two main groupsThose that deal with the first
three parts of the system development life cycle (preliminary investigation,
analysis, and design) and are referred to as Front-End CASE Tools or Upper CASE
ToolsThose that deal mainly with the implementation, testing and installation
are referred to as Back-End CASE Tools or Lower CASE Tools

28  Upper CASE ToolsThese are basically general-purpose analysis and design

specification toolsDuring the initial stages of system development, analysts have
to determine system requirements and analyse this information to design the
most effective systemComputerised CASE tools allow for changes to be made
automatically, very quickly and accuratelyData Dictionaries are data processing
systems products that are specifically designed to hold, maintain and organise
informationThey have facilities for producing a variety of reportsThey allow
developers to be more productiveThe goal of a CASE tool is to refine the analysis
and design stages to allow automated production of code, around 75%

29  Data DictionariesA data dictionary is an automated tool for collecting and

organising detailed information about system componentsA data dictionaries
main facility is to document data elements, records, programs, files, users
etcThey also have the facility to cross-reference all system components and
contain details of:Systems environmentAudit
trailsReportsFormsFunctionsProcesses

30  Lower CASE ToolsThese focus on the architecture of the system and its
implementation and maintenanceThese tools are effective in helping with the
generation of the program code and are referred to as Code GeneratorsA code
generator is a tool that enables automatic generation of code from the analysis
and design specificationsGenerating code this way ensures that all code is
produced with identical naming conventions

31  Code GeneratorsCode generators produce a high quality of code that is easy

to maintain and is portableThey are able to interact with Upper CASE tools to aid
in the development of code

32  Document GeneratorsA further enhancement to CASE tools is document

generatorsA document generator is a CASE tool that generates technical
documentation from source code commentsThe comments that are produced
conform to a standard format

33  Object-Oriented CASECASE tools are well supported in object-oriented

programming systems (OOPS)Earlier problems with OOPS focussed on models
created for software development systems and their different notationsThis was
overcome by the use of UML, Unified Modelling Language, which is a new
standard for producing diagrams and chartsAll current CASE tools have now
adopted UML for specifying, visualising and constructing software systems

34  UML CASE tools offer automatic code generation from the UML diagram
This tool produces a framework for the code which contains objects and classes.
An Executable Prototype is producedThis is an executable source code program
obtained directly from UMLOne of the main features in UML is Reverse
Engineering where existing source code is reversed engineered into a set of UML
diagrams

35  RUP Rational Unified Process

In conjunction with UML developers also employ RUPThis is a development
process to deliver best practices during each stage of a projectUsing RUP risks
are lowered during all stages
36  Advantages of CASE Increase Speed
CASE tools provide automation and reduce the time to complete tasksIncreased
AccuracyCASE tools can provide on-going debugging and error checking which is
vital for early defect removalReduced Costs and MaintenanceOverall system
quality improves using CASE. There is also better documentation so the net
effort and cost involved is reducedBetter DocumentationUsing CASE tools vast
amounts of documentation are produced. An important aspect is CASE
Repository, this is a developers database with information relating to the
projects stored. It can be regularly updatedBetter CommunicationInformation
generated from one tool can be passed to another, allowing for important
information to be passed efficiently and effectively

37  Limitations Of CASE Tools

Although CASE tools are becoming more popular user can besubject to some
limitations:ChoiceOver 1000 CASE tools exist and choosing one is difficult, a
major project in itselfCostsCASE tools are not cheap. Hardware, software,
training and consulting are all factors in the total cost equationTrainingUsers
need time to learn the technology. A CASE consulting industry has evolved to
support uses of CASE tools

1.What is Object Oriented Analysis (OOA)?

Object Oriented Analysis (OOA) is process of discovery where a development
team understands and models the requirements of the system. In OOA
requirements are organized as objects. It integrates all the process and data.
But in others or traditional structural analysis both process and data are
considered independently/separately. They use flow chart/structure charts
for process and ER diagrams for data.
But in OOA some advance models are used. The common models used in OOA
are: Use cases, Object models. Use cases describe pictures or overview for
standard domain functions that the system must achieved. Object models
describe the names, class relations, operations, and properties of the main
objects. User-interface prototypes can also be created for better understanding.

Object Oriented Analysis (OOA) begins by looking at the problem domain (the
area of expertise or application that needs to analyze in order to solve a
problem). Its aim is to produce a conceptual model of the information that exists
in the area being analyzed. For the analysis there are a variety of sources. It can
be a formal document, a written requirements statement, interviews with
stakeholders/other interested parties, other methods, etc. The final result of
object-oriented analysis will appear in the form of a conceptual model that
describes what the system is functionally required to do.

Functionalities of OOA
The core activities in OOA are given bellow:
 o Find the objects
o Organize the objects by creating object model diagram
o Explain how the objects communicates with each other.
o Set the characteristic or behavior of the objects
o Set the internal of the objects
Advantages of OOA
The OOA provides better performance. Some common advantages of OOA are
given bellow:
o Its focuses on data rather than the procedures as in Structured Analysis
o The objectives of encapsulation and data hiding help the developer to
develop the systems that cannot be tampered by other parts of the system
o It allows effective software complexity management by the virtue of
modularity
o It can be upgraded from small to large system easily.

2. What is Object Oriented Design?

Object Oriented Design (OOD) serves as part of the object-oriented programming (OOP) process of
lifestyle. It is mainly the process of using an object methodology to design a computing system or
application. This technique enables the implementation of a software based on the concepts of objects.
Additionally, it is a concept that forces programmers to plan out their code in order to have a better
flowing program.
The origins of Object-Oriented Design (OOD) is debated, but the first languages that supported it
included Simula and SmallTalk. The term did not become popular until Grady Booch wrote the first
paper titled Object-Oriented Design, in 1982. The chief objective of this type of software design is to
define the classes and their relationships, which are needed to build a system that meets the
requirements contained in the Software Requirement Specifications.
Moreover, it is the discipline of defining the objects and their interactions to solve a problem that was
identified and documented during the Object-Oriented Analysis (OOA). In short, Object Oriented Design
(OOD) is a method of design encompassing the process of object-oriented decomposition and a notation
for depicting both logical and physical models of the system under design.
The other characteristics of Object-Oriented Design are as follow:
 Objects are abstractions of the real-world or system entities and manage themselves.
 The objects are independent and in an encapsulated state and representation information.
 System functionality is expressed in terms of object services.
 Shared data areas are eliminated.
 Communication between objects is through message passing.
 The objects may be distributed and may execute sequentially or in parallel.
Advantages of Object-Oriented Design:
The discussion above has elaborated on several advantages of Object-Oriented Design (OOD). From
enabling the implementation of a software based on the concepts of objects and deleting the shared
data areas to distributing and executing the object sequentially or in parallel, the benefits of this
approach of software design are numerous. Hence, provided here some of the other advantages of
using Object Oriented Design (OOD).
  Easier to maintain objects.
 Objects may be understood as stand-alone entities.
 Objects are appropriate reusable components.
 For some systems, there may be an obvious mapping from real entities to system objects.

 Concepts of Object-Oriented Design:

These concepts are defined in detail below:
Encapsulation: This is a tight coupling or association of data structure with the methods or functions
that act on the data. This is basically known as a class, or object (object is often the implementation of a
class).
Data Protection: The ability to protect some components of the object from external entities. This is
realized by language keywords to enable a variable to be declared as private or protected to the owning
class.
Inheritance: This is the ability of a class to extend or override the functionality of another class. This so-
called child class has a whole section that is the parent class and then it has its own set of functions and
data.
Interface: A definition of functions or methods, and their signature that are available for use as well as
to manipulate a given instance of an object.
Polymorphism: This is the ability to define different functions or classes as having the same name, but
taking different data type.

4.WHAT IS OBJECT-ORIENTED PROGRAMMING PARADIGM? THE OBJECT-ORIENTED PARADIGM

ALLOWS FOR INTERACTION BETWEEN OBJECTS I.E. THE SENDING OF MESSAGES TO OBJECTS, EACH OF
THESE OBJECTS IS IDENTIFIED BY AN IDENTITY. THE STATE DESCRIBES THE OBJECT IN TERMS OF
MEMBER VARIABLES AND BEHAVIOUR DESCRIBES THE OBJECT IN TERMS OF THE METHODS THAT CAN
BE USED.
BRIEF HISTORY
OBJECT ORIENTED PARADIGM WAS DEVELOPED IN 1960 BY RESEARCHERS AT THE NORWEGIAN
COMPUTING CENTER AS A RESULT OF SIMULA (SIMULATION OF REAL SYSTEMS). THE FIRST PURE OOPL:
SMALLTALK WAS DEVELOPED IN 1970 BY ALAN KAY AND HIS RESEARCHERS AT XEROX PARK. IN
ACCORDANCE WITH KAY’S DEVELOPMENT OF THE FIRST OOPL BJARNE STROUSTRUP EXTENDED THE C
PROGRAM, C++ THAT USED THE OBJECT-ORIENTED CONCEPT.
OBJECT ORIENTED PARADIGM: -
OBJECT ORIENTED PARADIGM CHANGES THE MAIN FOCUS FROM CODE TO DATA. IT MODELS REAL-
WORLD OBJECTS. THE UNIT OF ABSTRACTION IS THE OBJECT WHICH CONTAINS BOTH STATES I.E.
INFORMATION (VALUES) AND BEHAVIOUR (METHODS AND PROCEDURES). MOST OF THE OBJECT-
ORIENTED PROGRAMS ARE SIMILAR THE CHANGE IS IN HOW WE THINK ABOUT PROBLEM SOLVING
INSTEAD OF THE STYLE OF PROGRAMMING.
Elements of OOP: -
• Objects
• Classes
• Encapsulation
• Data Abstraction
• Inheritance
• Polymorphism
• Dynamic Binding
• Message Passing

Code for Abstraction

#include <iostream>
using namespace std;
class AbstractionExample {
private:
int num;
   char ch;

public:
void setMyValues(int n, char c) {
num = n; ch = c;
}
void getMyValues() {
cout<<"Numbers is: "<<num<< endl;
cout<<"Char is: "<<ch<<endl;
}
};
int main () {
AbstractionExample obj;
obj.setMyValues(100, 'X');
obj.setMyValues();
return 0;
}

/* By making these data members private, they have become

* hidden them from outside world.
* These data members are not accessible outside
* the class. The only way to set and get them
* values are through the public functions.
*/

Code for Encapsulation

#include<iostream>

using namespace std;

class Encapsulation

{
private:
// data hidden from outside world
int x;

public:
// function to set value of
// variable x
 void set(int a)
{
x =a;
}

// function to return value of

// variable x
int get()
{
return x;
}
};

// main function
int main()
{
Encapsulation obj;

obj.set(5);

cout<<obj.get();
return 0;
}

In the above program the variable x is made private. This variable can be accessed and
manipulated only using the functions get() and set() which are present inside the class. Thus,
we can say that here, the variable x and the functions get() and set() are binded together which
is nothing but encapsulation.

assignment-3

assignment-4

assignment-5
Forward engineering and Reverse engineering are part of the re-engineering
process and closely related. The crucial difference between the forward engineering
and reverse engineering is that forward engineering employs the change in the
subject system during restructuring. Conversely, reverse engineering whole sole
purpose is to examine the system to obtain its more abstract design.

Key Differences Between Forward Engineering and

Reverse Engineering
1. Forward engineering begins with the system specification and includes
the design and implementation of the developing system. On the
contrary, the initial step in reverse engineering starts with the existing
system and the development technique for the replacement is based on
interpretation.
2. It is always certain to generate a by-product of forward engineering
but in the case of reverse engineering, several ideas are generated
about the requirement not necessarily generate a product.
3. Forward engineering is prescriptive in nature where the developers
need to follow particular rules for the proper results. On the other hand,
reverse engineering is adaptive where the engineer has to discover
what the developer actually did.
4. Forward engineering consumes more time as compared to the reverse
engineering.
 5. The final product of forward engineering must be complete and exact.
As against, reverse engineering model can be imperfect, retrieved
partial information is still useful.
Conclusion

The forward engineering involves the modification in the subject system

while reverse engineering just analyses the system. Furthermore, these are
the components of the re-engineering process.

Ques:3 Software Re-Engineering is the examination and alteration of a system to

reconstitute it in a new form. The principles of Re-Engineering when applied to the
software development process is called software re-engineering. It affects positively at
software cost, quality, service to the customer and speed of delivery. In Software Re-
engineering, we are improving the software to make it more efficient and effective.
Re-Engineering cost factors:
 The quality of the software to be re-engineered.
 The tool support availability for engineering.
 Extent of the data conversion which is required.
 The availability of expert staff for Re-engineering.

Software Re-Engineering Activities:

1. Inventory Analysis:
Every software organisation should have an inventory of all the applications.
 Inventory can be nothing more than a spreadsheet model containing information
that provides a detailed description of every active application.
 By sorting this information according to business criticality, longevity, current
maintainability and other local important criteria, candidates for re-engineering
appear.
 Resource can then be allocated to candidate application for re-engineering work.
2. Document reconstructing:
Documentation of a system either explains how it operate or how to use it.
 Documentation must be updated.
 It may not be necessary to fully document an application.
 The system is business critical and must be fully re-documented.
3. Reverse Engineering:
Reverse engineering is a process of design recovery. Reverse engineering tools
extracts data, architectural and procedural design information from an existing program.
4. Code Reconstructing:
 To accomplish code reconstructing, the source code is analyzed using a
reconstructing tool. Violations of structured programming construct are noted and
code is then reconstructed.
 The resultant restructured code is reviewed and tested to ensure that no
anomalies have been introduced.
5. Data Restructuring:
 Data restructuring begins with the reverse engineering activity.
 Current data architecture is dissecred, and necessary data models are defined.
 Data objects and attributes are identified, and existing data structure are
reviewed for quality.
6. Forward Engineering:
Forward Engineering also called as renovation or reclamation not only for recovers
design information from existing software but uses this information to alter or
reconstitute the existing system in an effort to improve its overall quality.

Ques:1 https://www.informit.com/articles/article.aspx?p=23692&seqNum=6

Ques:4 file:///C:/Users/sweta%20umrao/Downloads/Documents/2006267758.pdf
Ques:2