Pragati Enginneringcollege

Department of Computer Science and Engineering

Course
notes for
Object Oriented Analysis & Design using UML

III/IISemester(R16)
 Object Oriented Analysis and Design using UML

UNIT -1
SYLLABUS

 Introduction
 The Structure of Complexsystems
 The Inherent Complexity ofSoftware
 Attributes of ComplexSystem
 Organized and DisorganizedComplexity
 Bringing Order toChaos
 Designing Complex Systems
 Evolution of ObjectModel
 Foundation of ObjectModel
 Elements of Object Model
 Applying the ObjectModel.
 Chapter 1
Complexity
Systems: Systems are constructed by interconnecting components (Boundaries, Environments,
Characters, Emergent Properties), which may well be systems in their own right. The larger the
number of these components and relationships between them, higher will be the complexity of
the overallsystem.

Software Systems: Software systems are not any different from other systems with respect to
these characteristics. Thus, they are also embedded within some operational environment, and
perform operations which are clearly defined and distinguished from the operations of other
systems in this environment. They also have properties which emerge from the interactions of
their components and/or the interactions of themselves with other systems in their environment.
A system that embodies one or more software subsystems which contribute to or control a
significant part of its overall behavior is what we call a software intensive system. As examples
of complex software-intensive systems, we may consider stock and production control systems,
aviation systems, rail systems, banking systems, health care systems and soon.

Complexity: Complexity depends on the number of the components embedded in them as well
as the relationships and the interactions between these components whichcarry;
 Impossible for humans to comprehendfully
 Difficult to document and test
 Potentially inconsistent or incomplete
 Subject to change
 No fundamental laws to explain phenomena andapproaches

The structure of Complex Systems

Examples of Complex Systems: The structure of personal computer, plants and animals, matter,
social institutions are some examples of complex system.
The structure of a Personal

Computer: A personal computer is a device of moderate complexity. Major elements are CPU,
monitor, keyboard and some secondary storage devices. CPU encompasses primary memory, an
ALU, and a bus to which peripheral devices are attached. An ALU may be divided into registers
which are constructed from NAND gates, inverters and so on. All are the hierarchical nature of a
complexsystem.
The structure of Plants: Plants are complex multicellular organism which are composed of
cells which is turn encompasses elements such as chloroplasts, nucleus, and so on. For example,
at the highest level of abstraction, roots are responsible for absorbing water and minerals from
the soil. Roots interact with stems, which transport these raw materials up to the leaves. The
leaves in turn use water and minerals provided by stems to produce food through photosynthesis.
The structure of Animals: Animals exhibit a multicultural hierarchical structure in which
collection of cells form tissues, tissues work together as organs, clusters of organs define systems
(such as the digestive system) and so on.
The structure of Matter: Nuclear physicists are concerned with a structural hierarchy of matter.
 Atoms are made up of electrons, protons and neutrons. Elements and elementary particles but
protons, neutrons and other particles are formed from more basic components called quarks,
which eventually formed from pro-quarks.

The structure of Social institutions: In social institutions, group of people join together to accomplish tasks
that cannot be done by made of divisions which in turn contain branches which in turn encompass local offices and so on.

The Inherent Complexity of Software

The Properties of Complex and Simple Software Systems: Software may involve elements of
great complexity which is of different kind.
Some software systems are simple.
 These are the largely forgettable applications that are specified, constructed, maintained,
and used by the same person, usually the amateur programmer or the professional
developer working inisolation.
 Such systems tend to have a very limited purpose and a very short lifespan.
 We can afford to throw them away and replace them with entirely new software rather
than attempt to reuse them, repair them, or extend their functionality, Such applications
are generally more tedious than difficult to develop; consequently, learning how to design
them does not interestus.
Some software systems are complex.
 The applications that exhibit a very rich set of behaviors, as, for example, in reactive
systems that drive or are driven by events in the physical world, and for which time and
space are scarce resources; applications that maintain the integrity of hundreds of
thousands of records of information while allowing concurrent updates and queries; and
systems for the command and control of real-world entities, such as the routing of air or railwaytraffic.
 Software systems such as world of industrial strength software tend to have a long life
span, and over time, many users come to depend upon their properfunctioning.
 The frameworks that simplify the creation of domain-specific applications, and programs
that mimic some aspect of humanintelligence.
 Although such applications are generally products of research and development they are
no less complex, for they are the means and artifacts of incremental and exploratory
development.

Why Software is inherently Complex

The complexity of software is an essential property not an accidental one. The inherent
complexity derives from four elements; the complexity of the problem domain, the difficultly of
managing the developmental process, the flexibility possible through software and the problems
of characterizing the behavior of discrete systems.
1. The complexity of the problem domain
 Complex requirements
 Decay of system
The first reason has to do with the relationship between the application domains for which
software systems are being constructed and the people who develop them. Often, although
software developers have the knowledge and skills required to develop software they usually
lack detailed knowledge of the application domain of such systems. This affects their ability to
understand and express accurately the requirements for the system to be built which come from
the particular domain. Note, that these requirements are usually themselves subject to change.
They evolve during the construction of the system as well as after its delivery and thereby they
impose a need for a continuous evolution of the system. Complexity is often increased asa
result of trying to preserve the investments made in legacy applications. In such cases, the

components which address new requirements have to be integrated with existing legacy
applications. This results into interoperability problems caused by the heterogeneity of the
different components which introduce new complexities.
Consider the requirement for the electronic systems of a multi-engine aircraft, a cellular phone
switching system or a cautious (traditional) robot. The row functionality of such systems is
difficult enough to comprehend. External complexity usually springs from the impedance
mismatch that exists between the users of a system and its developers. Users may have only
vague ideas of what they want in a software system. Users and developers have different
perspectives on the nature of the problem and make different assumptions regarding the nature of
the system. A further complication is that the requirement of a software system is often change
during its development. Once system is installed, the process helps developers master the
problem domain, enabling them to ask better questions that illuminate the done existing system
every time its requirements change because a large software system is a capital investment. It is
software maintenance when we correct errors, evolution when we respond to changing
environments and preservations, when we continue to use extraordinary means to keep an
ancient and decaying piece of software inoperation.
The Difficulty of Managing the Development Process
 Managementproblems
 Need of simplicity
The second reason is the complexity of the software development process. Complex software
intensive systems cannot be developed by single individuals. They require teams of developers.
This adds extra overhead to the process since the developers have to communicate with each
other about the intermediate artifacts they produce and make them interoperable with each other.
This complexity often gets even more
difficult to handle if the teams do not work in one location but are geographically dispersed. In
such situations, the management of these processes becomes an important subtask on its own and
they need to be kept as simple as possible.
None person can understand the system whose size is measured in hundreds of thousands, or
even millions of lines of code. Even if we decompose our implementation in meaningful ways,
we still end up with hundreds and sometimes even thousand modules. The amount of work
demands that we use a team of developers and there are always significant challenges associated
with team development more developers means more complex communication and hence more
difficult coordination.

2. The flexibility possible through software

 Software is flexible and expressive and thus encourages highly demanding
requirements,whichinturnleadtocompleximplementationswhicharedifficult
 to assess
The third reason is the danger of flexibility. Flexibility leads to an attitude where developers
develop system components themselves rather than purchasing them from somewhere else.
Unlike other industrial sectors, the production depth of the software industry is very large. The
construction or automobile industries largely rely on highly specialized suppliers providing parts.
The developers in these industries just produce the design, the part specifications and assemble
the parts delivered. The software development is different: most of the software companies
develop every single component from scratch. Flexibility also triggers more demanding
requirements which make products even more complicated.
Software offers the ultimate flexibility. It is highly unusual for a construction firm to build an on
site steel mill to forge (create with hammer) custom girders (beams) for a new building.
Construction industry has standards for quality of row materials, few such standards exist in the
software industry.

3. The problem of characterizing the behavior of discrete systems

 Numerous possible states
 Difficult to express all states
The final reason for complexity according to Booch is related to the difficulty in describing the
behavior of software systems. Humans are capable of describing the static structure and
properties of complex systems if they are properly decomposed, but have problems in describing
their behavior. This is because to describe
Behavior, it is not sufficient to list the properties of the system. It is also necessary to describe
the sequence of the values that these properties take over time.
Within a large application, there may be hundreds or even thousands of variables well as more
than one thread of control. The entire collection of these variables as well as their current values
and the current address within the system constitute the present state of the system with discrete
states. Discrete systems by their very nature have a finite numbers of possible states.

The Consequences of Unrestrained Complexity

The more complex the system, the more open it is to total breakdown. Rarely would a builder
think about adding a new sub-basement to an existing 100-story building; to do so would be very
costly and would undoubtedly invite failure. Amazingly, users of software systems rarely think
twice about asking for equivalent changes. Besides, they argue, it is only a simple matter of
programming.

Our failure to master the complexity of software results in projects that are late, over budget, and
deficient in their stated requirements. We often call this condition the software crisis, but frankly,
a malady that has carried on this long must be called normal. Sadly, this crisis translates into the
squandering of human resources - a most precious commodity - as well as a considerable loss of
opportunities. There are simply not enough good developers around to create all the new
software that users need. Furthermore, a significant number of the developmental personnel in
any given organization must often be dedicated to the maintenance or preservation of geriatric
software. Given the indirect as well as the direct contribution of software to the economic base of
most industrialized countries, and considering the ways in which software can amplify the
powers of the individual, it is unacceptable to allow this situation tocontinue.
ATTRIBUTES OFCOMPLEX SYSTEM

The five Attributes of a complex system: There are five attribute common to all complex
systems. They are as follows:
1. Hierarchical and interacting subsystems
Frequently, complexity takes the form of a hierarchy, whereby a complex system is
composed of interrelated subsystems that have in turn their own subsystems and so on,
until some lowest level of elementary components is reached.
2. Arbitrary determination of primitive components
The choice of what components in a system are primitive is relatively arbitrary and is
largely up to the
discretion of the observer of the system class structure and the object structure are not
completely
independent each object in object structure represents a specific instance of some class.
3. Stronger intra-component than inter-component link
Intra-component linkages are generally stronger than inter-component linkages. This fact
has the involving the high frequency dynamics of the components-involving the internal
structure of the components – from the low frequency dynamic involving interaction
amongcomponents.
4. Combine and arrange common rearranging subsystems
Hierarchic systems are usually composed of only a few different kinds of subsystems in
various combinations and arrangements. In other words, complex systems have common
patterns. These patterns may involve the reuse of small components such as the cells found
in both plants or animals, or of larger structures, such as vascular systems, also found in
both plants and animals.
5. Evolution from simple to complex systems
A complex system that works is invariably bound to have evolved from a simple system
that worked ……….. A complex system designed from scratch never works and can't be
patched up to make it work. You have to start over, beginning with a working simple
system.
Booch has identified five properties that architectures of complex software systems have in
common.

Firstly, every complex system is decomposed into a hierarchy of subsystems. This

decomposition is essential in order to keep the complexity of the overall system manageable.
These subsystems, however, are not isolated from each other, but interact with eachother.

Very often subsystems are decomposed again into subsystems, which are decomposed and so on.
The way how this decomposition is done and when it is stopped, i.e. which components are
considered primitive, is rather arbitrary and subject to the architects decision.
The decomposition should be chosen, such that most of the coupling is between components that
lie in the same subsystem and only a loose coupling exists between components of different
subsystem. This is partly motivated by the fact that often different individuals are in charge with
the creation and maintenance of subsystems and every additional link to other subsystems does
imply an higher communication and coordination overhead.

Certain design patterns re-appear in every single subsystem. Examples are patterns for iterating
over collections of elements, or patterns for the creation of object instances and the like.

The development of the complete system should be done in slices so that there is an increasing
number of
subsystems that work together. This facilitates the provision of feedback about the overall
architecture.

Organized and Disorganized Complexity

Simplifying Complex Systems
 Usefulness of abstractions common to similar activities
e.g. driving different kinds of motor vehicle
 Multiple orthogonalhierarchies
e.g. structure and control system
 Prominent hierarchies in object-orientation
“ class structure”
“ object structure ”
e. g. engine types, engine in a specific car
One mechanism to simplify concerns in order to make them more manageable is to identify and
understand abstractions common to similar objects or activities. We can use a car as an example
(which are considerable complex systems). Understanding common abstractions in this particular
example would, for instance, involve the insight that clutch, accelerator and brakes facilitate the
use of a wide range of devices, namely transport vehicles depending on transmission of power
from engine to wheels).
Another principle to understand complex systems is the separation of concerns leading to
multiple hierarchies that are orthogonal to each other. In the car example, this could be, for
instance, the distinction between physical structure of the car (chassis, body, engine), functions
the car performs (forward, back, turn) and control systems the car has (manual, mechanical, and
electrical). In object-orientation, the class structure and the object structure relationship is the
simplest form of related hierarchy. It forms a canonical representation for object oriented
analysis.
The canonical form of a complex system – the discovery of common abstractions and
mechanisms greatly facilitates are standing of complex system. For example, if a pilot already
knows how to fly a given aircraft, it is easier to know how to fly a similar one. May different
hierarchies are present within the complex system. For example an aircraft may be

studied by decomposing it into its propulsion system. Flight control system and so on the
decomposition represent a structural or "part of" hierarchy. The complex system also includes an
"Is A" hierarchy. These hierodules for class structure and object structure combining the concept
of the class and object structure together with the five attributes of complex system, we find that
virtually all complex system take on the same (canonical) form as shown in figure. There are two
orthogonal hierarchies of system, its class structure and the object structure.

Figure 1.1 : Canonical form of a complex system

The figure 1.1 represents the relationship between two different hierarchies: a hierarchy of
objects and a hierarchy of classes. The class structure defines the 'is-a' hierarchy, identifying the
commonalities between different classes at different levels of abstractions. Hence class C4 is also
a class C1 and therefore has every single property that C1 has. C4, however, may have more
specific properties that C1 does not have; hence the distinction between C1 and C4. The object
structure defines the 'part-of' representation. This identifies the composition of an object from
component objects, like a car is composed from wheels, a steering wheel, a chassis and an
engine. The two hierarchies are not entirely orthogonal as objects are instances of certain classes.
The relationship between these two hierarchies is shown by identifying the instance-of
relationship as well. The objects in component D8 are instances of C6 and C7 As suggested by
the diagram, there are many more objects then there are classes. The point in identifying classes
is therefore to have a vehicle to describe only once all properties that all instances of the class
have.

Approaching a

SolutionHampered by
humanlimitations
 dealing withcomplexities
 memory
 communications
When we devise a methodology for the analysis and design of complex systems, we need to bear
in mind the limitations of human beings, who will be the main acting agents, especially during
early phases. Unlike computers, human beings are rather limited in dealing with complex
problems and any method need to bear that in mind and give as much support as possible.
Human beings are able to understand and remember fairly complex diagrams, though linear
notations expressing the same concepts are not dealt with so easily. This is why many methods
rely on diagramming techniques as a basis. The human mind is also rather limited. Miller
revealed in 1956 that humans can only remember 7 plus or minus one item at once. Methods
should therefore encourage its users to bear these limitations in mind and not deploy overly
complex diagrams.
The analysis process is a communication intensive process where the analyst has to have
intensive communications with the stakeholders who hold the domain knowledge. Also the
design process is a communication intensive process, since the different agents involved in the
design need to agree on decompositions of the system into different hierarchies that are
consistent with each other.

The Limitations of the human capacity for dealing with complexity: Object model is the
organized complexity of software. As we begin to analyze a complex software system, we find
many parts that must interact in a multitude of intricate ways with little commonality among
either the parts or their interactions. This is an example of disorganized complexity. In complex
system, we find many parts that mustinteract in a multitude of intricate ways with little
commonality among either the parts or their intricate. This is an example in an air traffic control
system, we must deal with states of different aircraft at once, and involving such it is absolutely
impossible for a single person to keep track of all these details at once.

Bringing Order to chaos

Principles that will provide basis for development

 Abstraction
 Hierarchy
 Decomposition

The Role of Abstraction : Abstraction is an exceptionally powerful technique for dealing with
complexity. Unable to master the entirely of a complex object, we choose to ignore its
inessential details, dealing instead with the generalized, idealized model of the object. For
example, when studying about how photosynthesis works in a plant, we can focus upon the
chemical reactions in certain cells in a leaf and ignore all other parts such as roots and stems.
Objects are abstractions of entities in the real world.
In general abstraction assists people's understanding by grouping, generalizing and chunking
information.
Object-orientation attempts to deploy abstraction. The common properties of similar objects are
defined in an abstract way in terms of a class. Properties that different classes have in common
are identified in more abstract classes and then an ‘is-a’ relationship defines the inheritance
between theseclasses.
The role of Hierarchy: Identifying the hierarchies within a complex software system makes
understanding of the system very simple. The object structure is important because it illustrates
how different objects collaborate with one another through pattern of interaction (called
mechanisms). By classifying objects into groups of related abstractions (for example, kinds of
plant cells versus animal cells, we come to explicitly distinguish the common and distinct
properties of different objects, which helps to master their inherent complexity.
Different hierarchies support the recognition of higher and lower orders. A class high in the ‘is-a’
hierarchy is a rather abstract concept and a class that is a leaf represents a fairly concrete
concept. The ‘is-a’ hierarchy also identifies concepts, such as attributes or operations, that are
common to a number of classes and instances thereof. Similarly, an object that is up in the part-
of hierarchy represents a rather coarse-grained and complex objects, assembled from a number of
objects, while objects that are leafs are rather fine grained. But note that there are many other
forms of patterns which are nonhierarchical: interactions, ‘relationships’.

The role of Decomposition: Decomposition is important techniques for copying with

complexity based on the idea of divide and conquer. In dividing a problem into a sub problem
the problem becomes less complex and easier to overlook and to deal with. Repeatedly dividing
a problem will eventually lead to sub problems that are small enough so that they can be
conquered. After all the sub problems have been conquered and solutions to them have been
found, the solutions need to be composed in order to obtain the solution of the whole problem.
The history of computing has seen two forms of decomposition, process-oriented (Algorithmic)
and object-oriented decomposition.

Algorithmic (Process Oriented) Decomposition: In Algorithmic decomposition, each module

in the system denotes a major step in some overall process.

Figure 1.2: Algorithmic decomposition

Object oriented decomposition: Objects are identified as Master file and check sum which
derive directly from the vocabulary of the problem as shown in figure. We know the world as a
set of autonomous agents that collaborate to perform some higher level behavior. Get formatted
update thus does not exist as an independent algorithm; rather it is an operation associated with
the object file of updates. Calling this operation creates another object, update to card. In this
manner, each object in our solution embodies its own unique behavior .Each hierarchy in layered
with the more abstract classes and objects built upon more primitive ones especially among the
parts of the object structure, object in the real world. Here decomposition is based on objects and
not algorithms.

Figure 1.3: Object oriented decomposition

Algorithmic versus object oriented decomposition: The algorithmic view highlighst the
ordering of events and the object oriented view emphasizes the agents that either cause action or
are the subjects upon which these operations act. We must start decomposing a system either by
algorithms or by objects then use the resulting structure as the framework for expressing the
other perspective generally object oriented view is applied because this approach is better at
helping us organize the inherent complexity of software systems. object oriented algorithm has a
number of advantages over algorithmic decomposition. Object oriented decomposition yields
smaller systems through the reuse of common mechanisms, thus providing an important
economy of expression and are also more resident to change and thus better able to involve over
time and it also reduces risks of building complex software systems. Object oriented
decomposition also directly addresses the inherent complexity of software by helping us make
intelligent decisions regarding the separation of concerns in a large state space.
Process-oriented decompositions divide a complex process, function or task into simpler sub
processes until they are simple enough to be dealt with. The solutions of these sub functions then
need to be executed in certain sequential or parallel orders in order to obtain a solution to the
complex process. Object-oriented decomposition aims at identifying individual autonomous
objects that encapsulate both a state and a certain behavior. Then communication among these
objects leads to the desired solutions.

Although both solutions help dealing with complexity we have reasons to believe that an object-
oriented decomposition is favorable because, the object-oriented approach provides for a
semantically richer framework that leads to decompositions that are more closely related to
entities from the real world. Moreover, the identification of abstractions supports (more abstract)
solutions to be reused and the object-oriented approach supports the evolution of systems better
as those concepts that are more likely to change can be hidden within theobjects.
 On Designing Complex Systems
Engineering as a Science and an Art: Every engineering discipline involves elements of both
science and art. The programming challenge is a large scale exercise in applied abstraction and
thus requires the abilities of the formal mathematician blended with the attribute of the
competent engine

eer. The role of the engineer as artist is particularly challenging when the task is to design an
entirely new system.
The meaning of Design: In every engineering discipline, design encompasses the discipline
approach we use to invent a solution for some problem, thus providing a path from requirements
to implementation. The purpose of design is to construct a system that.
1. Satisfies a given (perhaps) informal functional specification
2. Conforms to limitations of the target medium
3. Meets implicit or explicit requirements on performance and resource usage
4. Satisfies implicit or explicit design criteria on the form of the artifact
5. Satisfies restrictions on the design process itself, such as its length or cost, or the available
for doing the design.
According to Stroustrup, the purpose of design is to create a clean and relatively simple internal
structure, sometimes also called as architecture. A design is the end product of the design
process.
The Importance of Model Building: The buildings of models have a broad acceptance among
all engineering disciplines largely because model building appeals to the principles of
decomposition, abstraction and hierarchy. Each model within a design describes a specific aspect
of the system under consideration. Models give us the opportunity to fail under controlled
conditions. We evaluate each model under both expected and unusual situations and then after

them when they fail to behave as we expect or desire. More than one kind of model is used on
order to express all the subtleties of a complex system.
The Elements of Software design Methods: Design of complex software system involves an
incremental and iterative process. Each method includes the following:
1. Notation: The language for expressing each model.
2. Process: The activities leading to the orderly construction of the system's mode.
3. Tools: The artifacts that eliminate the medium of model building and enforce rules about
the models
Themselves, so that errors and inconsistencies can be exposed.

|
 The models of Object Oriented Development: The models of object oriented analysis and
design reflect the importance of explicitly capturing both the class and object hierarchies of the
system under design. These models also over the spectrum of the important design decisions that
we must consider in developing a complex system and so encourage us to craft implementations
that embody the five attributes of well formed complex systems.
s

Figure 1.4: Models of object oriented development

Booch presents a model of object-oriented development that identifies several relevant

perspectives. The classes and objects that form the system are identified in a logical model. For
this logical model, again two different perspectives have to be considered. A static perspective
identifies the structure of classes and objects, their properties and the relationships classes and
objects participate in. A dynamic model identifies the dynamic behavior of classes and objects,
the different valid states they can be in and the transitions between these states.

Besides the logical model, also a physical model needs to be identified. This is usually done later
in the system's lifecycle. The module architecture identifies how classes are kept in separately
compliable modules and the process architecture identifies how objects are distributed at run-
time over different operating system processes and identifies the relationships between those.
Again for this physical model a static perspective is defined that considers the structure of
module and process architecture and a dynamic perspective identifies process and object
activation strategies and inter-process communication. Object-orientation has not, however,
emerged fully formed. In fact it has developed over a long period, and continues to change.

|
nt4
 The Object Model
The elements of the object oriented technology collectively known as the object model. The
object model encompasses the principles of abstraction, encapsulation, modularity, hierarchy,
typing, concurrency and persistency. The object model brought together these elements in a
synergistic way.

The Evolution of the object Model

- The shift in focus from programming-in-the-small to programming-in-the-large.
- The evolution of high-order programminglanguages.
- New industrial strength software systems are larger and more complex than their
predecessors.
- Development of more expressive programming languages advances the decomposition,
abstraction and hierarchy.
- Wegner has classified some of more popular programming languages in generations
according to the language features.

The generation of programming languages

1. First generation languages (1954 –1958)
- Used for specific & engineering application.
- Generally consists of mathematical expressions.
- For example: FORTRAN I, ALGOL 58, Flowmatic, IPLVetc.
2. Second generation languages (1959 –1961)
- Emphasized on algorithmic abstraction.
- FORTRAN II - having features of subroutines, separate compilation
- ALGOL 60 - having features of block structure, datatype
- COBOL - having features of data, descriptions, filehanding
- LISP - List processing, pointers, garbagecollection
3. Third generation languages (1962 –1970)
- Supports data abstraction.
- PL/1 – FORTRAN + ALGOL +COBOL
- ALGOL 68 – Rigorous successor to ALGOL60
- Pascal – Simple successor to ALGOL 60
- Simula - Classes, dataabstraction
4. The generation gap (1970 –1980)
- C – Efficient, smallexecutables
- FORTRAN 77 – ANSIstandardization
5. Object Oriented Boom (1980 –1990)
- Smalltalk 80 – Pure object orientedlanguage
- C++ - Derived from C andSimula
- Ada83 – Strong typing; heavy Pascalinfluence
- Eiffel - Derived from Ada and Simula
6. Emergence of Frameworks (1990 –today)
 - Visual Basic – Eased development of the graphical user interface (GUI) for
windowsapplications
- Java – Successor to Oak; designed forportability
- Python – Object oriented scriptinglanguage
- J2EE – Java based framework for enterprise computing
- .NET – Microsoft’s object basedframework
- Visual C# - Java competitor for the Microsoft .NETframework
- Visual Basic .NET – VB for Microsoft .NETframework

Topology of first and early second generation programming languages

- Topology means basic physical building blocks of the language & how those parts can be
connected.
- Arrows indicate dependency of subprograms on variousdata.
- Error in one part of program effect across the rest ofsystem.

Fig 2.1: The Topology of First- and Early Second-Generation Programming Languages

Topology of late second and early third generation programming languages

Software abstraction becomes procedural abstraction; subprograms as an obstruction mechanism
and three important consequences:
- Languages invented that supported parameter passingmechanism
- Foundations of structured programming werelaid.
- Structured design method emerged using subprograms as basic physicalblocks.
Fig 2.2: The Topology of Late Second- and Early Third-Generation Programming Languages

The topology of late third generation programming languages

- Larger project means larger team, so need to develop different parts of same program
independently, i.e. compliedmodule.
- Support modularstructure.

Fig 2.3: The Topology of Late Third-Generation Programming Languages

Topology of object and object oriented programming language

Two methods for complexity of problems
(i) Data driven design method emerged for dataabstraction.
(ii) Theories regarding the concept of a type appeared
- Many languages such as Smalltalk, C++, Ada, Java weredeveloped.
- Physical building block in these languages is module which represents logical collection of
classes and objects instead of subprograms.
- Suppose procedures and functions are verbs and pieces of data are nouns,then
- Procedure oriented program is organized around verbs and object oriented program is
organized aroundnouns.
 Data and operations are united in such a way that the fundamental logical building blocks of our
systems are no longer algorithms, but are classes and objects.
- In large application system, classes, objects and modules essential yet insufficient means of
abstraction.

Fig 2.4: The Topology of Small- to Moderate-Sized Applications Using Object-Based and
Object-Oriented Programming Languages

Fig 2.5: The Topology of Large Applications Using Object-Based and Object-Oriented
Programming Languages
Foundations of the object model
In structured design method, build complex system using algorithm as their fundamental building
block. An object oriented programming language, class and object as basic building block.
Following events have contributed to the evolution of object-oriented concepts:
 Advances in computer architecture, including capability systems and hardware support
for operating systems concepts
 Advances in programming languages, as demonstrated in Simula, Smalltalk, CLU, and
Ada.
 Advances in programming methodology, including modularization and information hiding.
We would add to this list three more contributions to the foundation of the object model:
 Advances in database models
 Research in artificial intelligence
 Advances in philosophy and cognitive science

OOA (Object Oriented analysis)

During software requirement phase, requirement analysis and object analysis, it is a method of
analysis that examines requirements from the perspective of classes and objects as related to
problem domain. Object oriented analysis emphasizes the building of real-world model using the
object oriented view of the world.

OOD (Object oriented design)

During user requirement phase, OOD involves understanding of the application domain and
build an object model. Identify objects; it is methods of design showing process of object
oriented decomposition. Object oriented design is a method of design encompassing the process
of object oriented decomposition and a notation for depicting both logical and physical as well as
static and dynamic models of the system under design.

OOP (Object oriented programming)

During system implementation phase, t is a method of implementation in which programs are
organized as cooperative collection of objects, each of which represents an instance of some
class and whose classes are all members of a hierarchy of classes united in inheritance
relationships. Object oriented programming satisfies the following requirements:
- It supports objects that are data abstractions with an interface of named operations and a
hidden local state.
- Objects have associated type(class).
- Classes may inherit attributes from super type to subtype.

Elements of Object Model

Kinds of Programming Paradigms: According to Jenkins and Glasgow, most programmers
work in one language and use only one programming style. They have not been exposed to
alternate ways of thinking about a problem. Programming style is a way of organizing programs
on the basis of some conceptual model of programming and an appropriate language to make
programs written in the style clear.
There are five main kinds of programming styles:
 1. Procedure oriented – Algorithms for design of computation
2. Object oriented – classes and objects
3. Logic oriented – Goals, often expressed in a predicate calculus
4. Rules oriented – If then rules for design of knowledgebase
5. Constraint orient – Invariant relationships.
Each requires a different mindset, a different way of thinking about the problem. Object model is
the conceptual frame work for all things of object oriented.
There are four major elements of object model. They are:
1. Abstraction
2. Encapsulation
3. Modularity
4. Hierarchy
There are three minor elements which are useful but not essential part of object model. Minor
elements of object model are:
1. Typing
2. Concurrency
3. Persistence
Abstraction
Abstraction is defined as a simplified description or specification of a system that emphasizes
some of the system details or properties while suppressing others. A good abstraction is one that
emphasizes details that are significant to the reader or user and suppresses details that are, not so
significant, immaterial.
An abstraction denotes the essential characteristics of an object that distinguishes it from all
other kinds of objects and thus provides crisply defined conceptual boundaries on the perspective
of the viewer. An abstraction focuses on the outside view of an object, Abstraction focuses up on
the essential characteristics of some object, relative to the perspective of the viewer. From the
most to the least useful, these kinds of abstraction includefollowing.
- Entity abstraction: An object that represents a useful model of a problem domain or
solution domain entity.
- Action abstraction: An object that provides a generalized set of operations all of which
program the same kind of function.
- Virtual machine abstractions: An object that groups together operations that are used by
some superior level of control, or operations that all use some junior set ofoperations.
- Coincidental abstraction: An object that packages a set of operations that have no relation
to each other.
Abstraction: Temperature Sensor

Important Characteristics:

temperature

location
Figure 2.6: Abstraction of a Temperature Sensor
 Encapsulation
The act of grouping data and operations into a single object.
Private
Clas
Public
Information PublicInterface
andoperations
Private Representation
Encapsulation

Class heater
Information hiding
{ Public:

heater (location):

~ heater ( ):

voidturnon ( );

void turnoff ( );

Boolean ison () const

private:

Abstraction: Heater

Important Characteristics:

location

Status

Figure 2.7: Abstraction of a Heater

Modularity
The act of partitioning a program into individual components is called modularity. It is reusable
component which reduces complexity to some degree. Although partitioning a program is
helpful for this reason, a more powerful justification for partitioning a program is that it creates a
number of well-defined, documented boundaries within the program. These boundaries, or
interfaces, are invaluable in the comprehension of the program. In some languages, such as
Smalltalk, there is no concept of a module, so the class forms the only physical unit of
decomposition. Java has packages that contain classes. In many other languages, including
Object Pascal, C++, and Ada, the module is a separate language construct and therefore warrants
a separate set of design decisions. In these languages, classes and objects form the logical
structure of a system; we place these abstractions in modules to produce the system’s physical
architecture. Modularization consists of dividing a program into modules which can be compiled
separately, but which have connections with other modules. Modularity is the property of a
system that has been decomposed into a set of cohesive and loosely coupledmodules.

- modules canbecompiledseparately. modulesin C++ are nothing more than separately

compiled files, generally called headerfiles.
- Interface of module are files with .h extensions & implementations are placed in fileswith
.c or .cppsuffix.
- Modules are units in pascal and package body specification inada.
- modules Serve as physical containers in which classes and objects are declared like gates in
IC ofcomputer.
- Group logically related classes and objects in the samemodule.
- E.g. consider an application that runs on a distributed set of processors and uses a message
passing mechanism to coordinate their activities.
- A poor design is to define each message class in its own module; so difficult for users to find
the classes they need. Sometimes modularization is worse than no modulation atall.
- Developer must balance: desire to encapsulate abstractions and need to make certain
abstractions visible to othermodules.
- Principles of abstract sion, encapsulation and modularity are synergistic (having
common effect)

Example ofmodularity
Let’s look at modularity in the Hydroponics Gardening System. Suppose we decide to use a
commercially available workstation where the user can control the system’s operation. At this
workstation, an operator could create new growing plans, modify old ones, and follow the
progress of currently active ones. Since one

of our key abstractions here is that of a growing plan, we might therefore create a module whose
purpose is to collect all of the classes associated with individual growing plans (e.g.,
FruitGrowingPlan, GrainGrowingPlan). The implementations of these GrowingPlan classes
would appear in the implementation of this module. We might also define a module whose
purpose is to collect all of the code associated with all user interface functions.
Hierarchy
Hierarchy is a ranking or ordering of abstractions Encapsulation hides company inside new of
abstraction and modularity logically related abstraction & thus a set of abstractions form
hierarchy. Hierarchies in complex system are its class structure (the "is a" hierarchy) and its
object structure (the "part of" hierarchy).

Examples of Hierarchy: Single Inheritance

Inheritance defines a relationship among classes. Where one classes shares structure or behaviors
defined in one (single in heritance) or more class (multiple inheritance) & thus represents a
hierarchy of abstractions in which a subclass inherits from one or more super classes. Consider
the different kinds of growing plans we might use in the Hydroponics Gardening System. An
earlier section described our abstraction of a very generalized growing plan. Different kinds of
crops, however, demand specialized growing plans. For example, the growing plan for all fruits
is generally the same but is quite different from the plan for all vegetables, or for all floral crops.
Because of this clustering of abstractions, it is reasonable to define a standard fruitgrowing plan
that encapsulates the behavior common to all fruits, such as the knowledge of when to pollinate
or when to harvest the fruit. We can assert that FruitGrowingPlan “is a” kind ofGrowingPlan.

FruitGrowingPlan GrowingPlan
Is a

Fig 2.8: Class having one superclass (Single Inheritance)

In this case, FruitGrowingPlan is more specialized, and GrowingPlan is more general. The same
could be said for GrainGrowingPlan or VegetableGrowingPlan, that is, GrainGrowingPlan “is a”
kind of GrowingPlan, and VegetableGrowingPlan “is a” kind of GrowingPlan. Here,
GrowingPlan is the more general superclass, and the others are specialized subclasses.

As we evolve our inheritance hierarchy, the structure and behavior that are common for different
classes will tend to migrate to common superclasses. This is why we often speak of inheritance
as being a generalization/specialization hierarchy. Superclasses represent generalized
abstractions, and subclasses represent specializations in which fields and methods from the
superclass are added, modified, or evenhidden.
Examples of Hierarchy: Multiple Inheritance

Figure 2.9: The Rose Class, Which Inherits from Multiple Superclasses (Multiple Inheritance)

Figure 2.10: The Repeated Inheritance

Repeated inheritance occurs when two or more peer superclasses share a common superclass.

Hierarchy: Aggregation

Whereas these “is a” hierarchies denote generalization/specialization relationships, “part of”

hierarchies describe aggregation relationships. For example, consider the abstraction of a garden.
We can contend that a garden consists of a collection of plants together with a growing plan. In
other words, plants are “part of” the garden, and the growing plan is “part of” the garden. This
“part of” relationship is known as aggregation.
Aggregation raises the issue of ownership. Our abstraction of a garden permits different plants to
be raised in a garden over time, but replacing a plant does not change the identity of the garden
as a whole, nor does removing a garden necessarily destroy all of its plants (they are likely just
transplanted). In other words, the lifetime of a garden and its plants are independent. In contrast,
we have decided that a GrowingPlan object is intrinsically associated with a Garden object and
does not exist independently. Therefore, when we create an instance of Garden, we also create an
instance of GrowingPlan; when we destroy the Garden object, we in turn destroy the
GrowingPlaninstance.

Typing
A type is a precise characterization of structural or behavioral properties which a collection of
entities share. Type and class are used interchangeably class implements a type. Typing is the
enforcement of the class of an object. Such that object of different types may not be
interchanged. Typing implements abstractions to enforce design decisions. E.g. multiplying temp
by a unit of force does not make serve but multiplying mass by force does. So this is strong
typing. Example of strong and weak typing: In strong type, type conformance is strictly
enforced. Operations can notbe called upon an object unless the exact signature of that operation
is defined in the object's class or superclasses.

A given programming language may be strongly typed, weakly typed, or even untyped, yet still
be called object-oriented. A strongly typed language is one in which all expressions defined in
super class are guaranteed to be type consistent. When we divide distance by time, we expect
some value denoting speed, not weight. Similarly, dividing a unit of force by temperature doesn’t
make sense, but dividing force by mass does. These are both examples of strong typing, wherein
the rules of our domain prescribe and enforce certain legal combinations ofabstractions.

Benefits of Strongly typed languages:

 Without type checking, program can crash at runtime
 Type declaration help to documentprogram
 Most compilers can generate more efficient object code if types aredeclared.

Examples of Typing: Static and Dynamic Typing

Static typing (static binding/early binding) refers to the time when names are bound to types i.e.
types of all variables are fixed at the time of compilation. Dynamic binding (late binding) means
that types of all variables and expressions are not known until run time. Dynamic building
(object pascal, C++) small talk(untyped).

Polymorphism is a condition that exists when the features of dynamic typing and inheritance
interact. Polymorphism represents a concept in type theory in which a single name (such as a
variable declaration) may denote objects of many different classes that are related by some
common superclass. The opposite of polymorphism is monomorphism, which is found in all
languages that are both strongly and statically typed.

Concurrency
OO-programming focuses upon data abstraction, encapsulation and inheritance concurrency
focuses upon process abstraction and synchronization. Each object may represent a separate
thread of actual (a process abstraction). Such objects are called active. In a system based on an
object oriented design, we can conceptualize the word as consisting of a set of cooperative
objects, some of which are active (serve as centers of independent activity). Thus concurrency is
the property that distinguishes an active object from one that is not active. For example: If two
active objects try to send messages to a third object, we must be certain to use some means of
mutual exclusion, so that the state of object being acted upon is not computed when both active
objects try to update their state simultaneously. In the preserve of concurrency, it is not enough
simply to define the methods are preserved in the presence of multiple thread of control.

Examples of Concurrency

Let’s consider a sensor named ActiveTemperatureSensor, whose behavior requires periodically

sensing the current temperature and then notifying the client whenever the temperature changes a
certain number of degrees from a given setpoint. We do not explain how the class implements
this behavior. That fact is a secret of the implementation, but it is clear that some form of
concurrency isrequired.

There are three approaches to concurrency in object oriented design

 Concurrency is an intrinsic feature of languages. Concurrency is termed as task in ada,
and class process in small talk. class process is used as super classes of all active objects.
wemay create an active object that runs some process concurrently with all other active
objects.
 We may use a class library that implements some form of light weight process AT & T
task library for C++ provides the classes’ sched, Timer, Task and others. Concurrency
appears through the use of these standardclasses.
 Use of interrupts to give the illusion of concurrency use of hardware timer in active
Temperature sensor periodically interrupts the application during which time all the
sensor read the current temperature, then invoke their callback functions asnecessary.

Persistence
Persistence is the property of an object through which its existence transcends time and or space
objects continues to exist after its creator ceases to exist and/or the object's location
moves from the address space in which it was created. An object in software takes up
some amount of space and exists for a particular amount of time. Object persistence
encompasses thefollowings.
 Transient results in expressionevaluation
 Local variables in procedureactivations
  Global variables where exists is different from their scope
 Data that exists between executions of a program
Data that exists between various versions of the
program
 Data that outlines the Program.
Traditional Programming Languages usually address only the first three kind of object
persistence. Persistence of last three kinds is typically the domain of database technology.
Introducing the concept of persistence to the object model gives rise to object oriented databases.
In practice, such databases build upon some database models (Hierarchical, network relational).
Database queries and operations are completed through the programmer abstraction of an object
oriented interface. Persistence deals with more than just the lifetime of data. In object oriented
databases, not only does the state of an object persist, but its class must also transcend only
individual program, so that every program interprets this saved state in the same way.
In most systems, an object once created, consumes the same physical memory until it classes to
exist. However, for systems that execute upon a distributed set of processors, we must sometimes
be concerned with persistence across space. In such systems, it is useful to think of objects that
can move from space to space.

Applying the Object Model

Benefits of the Object Model: Object model introduces several new elements which are
advantageous over traditional method of structured programming. The significant benefits are:
 Use of object model helps us to exploit the expressive power of object based and object
oriented programming languages. Without the application of elements of object model,
more powerful feature of languages such as C++, object pascal, ada are either ignored or
greatlymisused.
 Use of object model encourages the reuse of software and entire designs, which results in
the creation of reusable applicationframework.
 Use of object model produces systems that are built upon stable intermediate forms,
which are more resilent tochange.
 Object model appears to the working of human cognition, many people who have no idea
how a computer /works find the idea of object oriented systems quitenatural.
Application of Object Model
OOA & Design may be in only method which can be employed to attack the complexity inherent
in large systems. Some of the applications of the object model are as follows:
- Air trafficcontrol
- Animation
- Business or insurancesoftware
- Business DataProcessing
- CAD
- Databases
- ExpertSystems
- OfficeAutomation
- Robotics
- Telecommunication
- Telemetry Systemetc.