What do you mean by the Optimization of design?

Discuss the design

optimization with suitable examples using diagrams.

AKTU 2012-13, Marks 05

Answer
Design Optimization
The analysis model captures the logical information about the
system, while the design model adds details to support efficient
information access. Before a design is implemented, it should be
optimized so as to make the implementation more efficient. The aim
of optimization is to minimize the cost in terms of time, space, and
other metrics.
However, design optimization should not be excess, as ease of
implementation, maintainability, and extensibility are also important
concerns. It is often seen that a perfectly optimized design is more
efficient but less readable and reusable. So the designer must strike
a balance between the two.
The various things that may be done for design optimization are −

• Add redundant associations

• Omit non-usable associations
• Optimization of algorithms
• Save derived attributes to avoid re-computation of complex
expressions
Addition of Redundant Associations
During design optimization, it is checked if deriving new
associations can reduce access costs. Though these redundant
associations may not add any information, they may increase the
efficiency of the overall model.
Omission of Non-Usable Associations
Presence of too many associations may render a system
indecipherable and hence reduce the overall efficiency of the
system. So, during optimization, all non-usable associations are
removed.
Optimization of Algorithms
In object-oriented systems, optimization of data structure and
algorithms are done in a collaborative manner. Once the class design
is in place, the operations and the algorithms need to be optimized.
Optimization of algorithms is obtained by −

• Rearrangement of the order of computational tasks

• Reversal of execution order of loops from that laid down in the
functional model
• Removal of dead paths within the algorithm
Saving and Storing of Derived Attributes
Derived attributes are those attributes whose values are computed
as a function of other attributes (base attributes). Re-computation
of the values of derived attributes every time they are needed is a
time–consuming procedure. To avoid this, the values can be
computed and stored in their computed forms.
However, this may pose update anomalies, i.e., a change in the values
of base attributes with no corresponding change in the values of the
derived attributes. To avoid this, the following steps are taken −

• With each update of the base attribute value, the derived

attribute is also re-computed.
• All the derived attributes are re-computed and updated
periodically in a group rather than after each update.
Describe the structured analysis and structured design approach with
an example.

AKTU 2012-13, marks 10

Answer
Structured Analysis and Structured Design (SA/SD) is diagrammatic
notation which is design to help people understand the system. The
basic goal of SA/SD is to improve quality and reduce the risk of
System failure. It establishes concrete management specification
and documentation. It focuses on solidity, pliability and
maintainability of system.
Basically the approach of SA/SD is based on the Data Flow Diagram. It
is easy to understand SA/SD but it focuses on well defined system
boundary whereas JSD approach is too complex and does not have
any graphical representation.
SA/SD is combined known as SAD and it mainly focuses on following
3 points:

1. System
2. Process
3. Technology

SA/SD involves 2 phases:

1. Analysis Phase: It uses Data Flow Diagram, Data Dictionary,

State Transition diagram and ER diagram.
2. Design Phase: It uses Structure Chart and Pseudo Code.

Ques 16 Compare the OMT methodology with SA/SD methodology.

Explain with suitable example.

AKTU 2014-15, Marks 10

Answer
Answer:

Sr.
SA/SD OMT
No.
It manages a system around It manages system around
1
procedures. real world objects.

More importance is on
More importance is on functional
2 object model and less on
model and less on object model.
functional model.
 Dominance order is functional, Dominance order is object,
3
dynamic and object. dynamic and functional.

It is much advanced
4 It is a historical approach.
approach.

It clearly marks the system

System boundries can be
boundaries across which software
easily extending by adding
5 procedures should communicate
new objects,
with real world. It is difficult to
relationships.
extend boundries.

Decomposition of process to sub- Decompsition is based on

process is not standardized. objects so different
6
Different people provide different people provide similar
decomposition. decomposition.

Reusability of components across Reusablity of components

7 projects is less as compared to in across projects is more as
OMT. compared to SA/AD.

Not easily modifiable and Easily modifiable and

8
extensible. extensible.

Used when functions are more Used when data is more

9
important than data. important than functions.

Difficult to merge programming It better integrates data

code organized about functions with programming code as
10
while database is organized around database is organized
data. around data.

How do you map the object-oriented concepts using non object-

oriented languages? Explain with an example.
AKTU 2010-11, 2011-12, Marks 05

Answer
Implementing an object-oriented concept in a non-object oriented
language requires the following steps :
1. Translate classes into data structures :
i. Each class is implemented as a single contiguous block of
attributes. Each attribute contains a variable. Now an object has
state and identity and is subject to side effects.
ii. A variable that identifies an object must therefore be
implemented as a sharable reference.
2. Pass arguments to methods :
i. Every method has at least one argument. In a non-object-oriented
language, the argument must be made explicit.
ii. Methods can contain additional objects as arguments. In passing
an object as an argument to a method, a reference to the object
must be passed if the value of the object can be updated within the
method.
3. Allocate storage for objects :
i. Objects can be allocated statically, dynamically or on a stack.
ii. Most temporary and intermediate objects are implemented as
stack-based variables.
iii. Dynamically allocated objects are used when there number is not
known at compile time.
iv. A general object can be implemented as a data structure allocated
on request at run time from a heap.
4 Implement inheritance in data structures :Following ways are use to
implement data structure for inheritance in non object oriented
programming language

• Avoid it.
• Flatten the class hierarchy.
• Break out separate objects.
5 Implement method resolution : Method resolution is one. main
features of an object-oriented language that is lacking in a
non object-oriented language. Method resolution can be
implemented in a following ways

• Avoid it.
• Resolve methods at compile time.
• Resolve methods at run time.
6. Implement associations : Implementing associations in a non
oriented language can be done by :
 • Mapping them into pointers.
• Implementing them directly as association container objects.
7. Deal with concurrency :

• Most languages do not explicitly support concurrency.

• Concurrency is usually needed only when more than one
external event occurs, and the behaviour of the program
depends on their timing.
8. Encapsulate internal details of classes :

• Object-oriented languages provide constructs to encapsulate

implementation.
• Some of this encapsulation is lost when object-oriented
concepts translated into a non-object-oriented language, but
we can still take advantage of the encapsulation facilities
provided by language
Describe implementation of inheritance with example.

AKTU 2012-13, Marks 05

Answer
Inheritance is an important pillar of OOP(Object Oriented
Programming). It is the mechanism in java by which one class is allow
to inherit the features(fields and methods) of another class.
Important terminology:

• Super Class: The class whose features are inherited is known

as super class(or a base class or a parent class).
• Sub Class: The class that inherits the other class is known as
sub class(or a derived class, extended class, or child class). The
subclass can add its own fields and methods in addition to the
superclass fields and methods.
• Reusability: Inheritance supports the concept of “reusability”,
i.e. when we want to create a new class and there is already a
class that includes some of the code that we want, we can
 derive our new class from the existing class. By doing this, we
are reusing the fields and methods of the existing class.
Types of Inheritance

There are Various types of inheritance in Java:

Single Inheritance:
In Single Inheritance one class extends another class (one class
only).

In above diagram, Class B extends only Class A. Class A is a super

class and Class B is a Sub-class.
Multiple Inheritance:
In Multiple Inheritance, one class extending more than one class.
Java does not support multiple inheritance.
As per above diagram, Class C extends Class A and Class B both.
Multilevel Inheritance:
In Multilevel Inheritance, one class can inherit from a derived class.
Hence, the derived class becomes the base class for the new class.
As per shown in diagram Class C is subclass of B and B is a of
subclass Class A.
Hierarchical Inheritance:
In Hierarchical Inheritance, one class is inherited by many sub
classes.
As per above example, Class B, C, and D inherit the same class A.
Hybrid Inheritance:
Hybrid inheritance is a combination of Single and Multiple
inheritance.

As per above example, all the public and protected members of Class
A are inherited into Class D, first via Class B and secondly via Class C.
Note: Java doesn't support hybrid/Multiple inheritence
Describe the various features object-oriented languages. Compare any
two object-oriented languages.

AKTU 2010-11, Marks 05

Answer
Features of object-oriented languages:

1. Classes
2. Objects
3. Data Abstraction
4. Encapsulation
5. Inheritance
 6. Polymorphism

Class

Class represents a real world entity which acts as a blueprint for all
the objects.
We can create as many objects as we need using Class.
Example:
We create a class for “ Student ” entity as below
Student.java
Class Student{
String id;
int age;
String course;
void enroll(){
System.out.println(“Student enrolled”);
}}
Above definition of class contains 3 fields: id,age and course and
also it contains behavior or a method called “ enroll ”.
Object

Object Oriented Programming system(OOPS) is designed based on

the concept of “Object”. It contains both variables (used for holding
the data) and methods(used for defining the behaviors).
We can create any number of objects using this class and all those
objects will get the same fields and behavior.
Student s1 = new Student();
Now we have created 3 objects s1,s2 and s3 for the same class “
Student ”.We can create as many objects as required in the same way.
We can set the value for each field of an object as below,
s1.id=123;
s2.age=18;
s3.course=”computers”;
Abstraction

Abstraction is a process where you show only “relevant” data and

“hide” unnecessary details of an object from the user.
For example, when you login to your bank account online, you enter
your user_id and password and press login, what happens when you
press login, how the input data sent to server, how it gets verified is
all abstracted away from the you.
We can achieve “ abstraction ” in Java using 2 ways
Encapsulation

• Encapsulation is the process of binding object state(fields) and

behaviors(methods) together in a single entity called “Class”.
• Since it wraps both fields and methods in a class, it will be
secured from the outside access.
• We can restrict the access to the members of a class using
access modifiers such as private,protected and public
keywords.
• When we create a class in Java, it means we are doing
encapsulation.
• Encapsulation helps us to achieve the re-usability of code
without compromising the security.
Inheritance

• One class inherits or acquires the properties of another class.

• Inheritance provides the idea of reusability of code and each
sub class defines only those features that are unique to it, rest
of the features can be inherited from the parent class.

1. Inheritance is a process of defining a new class based on an

existing class by extending its common data members and
methods.
2. It allows us to reuse of code, it improves reusability in your java
application.
3. The parent class is called the base class or super class. The child
class that extends the base class is called the derived class
or sub class or child class.
To inherit a class we use extends keyword. Here class A is child class
and class B is parent class.
class A extends B{
}
Polymorphism

• It is the concept where an object behaves differently in

different situations.
• Since the object takes multiple forms, it is called
Polymorphism.
• In java, we can achieve it using method overloading and
method overriding.
• There are 2 types of Polymorphism available in Java,
Method overloading
In this case, which method to call will be decided at the compile time
itself based on number or type of the parameters. Static/Compile
Time polymorphism is an example for method overloading.
Method overriding
In this case, which method to call will be decided at the run time time
based on what object is actually pointed by the reference variable.
Explain each of the following term with in reference to object-oriented
programming style with an example

(i) Reusability

(ii) Robustness

(iii) Extensibility

(iv) Abstraction

AKTU 2010- 11,Marks 05 ,2011-12, Marks 10

Answer

(i)Reusability:
Reusable software reduces design, coding, and testing cost by
amortizing effort over several designs. Reducing the amount of code
also simplifies understanding, which increases the likelihood that
the code is correct. Reuse is possible in conventional languages, but
object-oriented languages greatly enhance the possibility of code
reuse.
(ii)Robustness
A method is robust if it does not fail even if it receives improper
parameters. Robustness against internal bugs may be traded off
against efficiency. Robustness against user errors should never be
sacrificed.
Protect against errors. The software should protect itself against
incorrect user input. Incorrect user input should never cause a
crash. Any method that accepts user input must validate input that
could cause trouble.
Optimize after the program runs. Avoid optimizing more of the
program than you have to, as optimization compromises
extensibility, reusability, and understandability. If methods are
properly encapsulated, they can be replaced with optimized
versions without affecting the rest of the program.
Validate arguments. External operations, those available to users of
the class, must rigorously check their arguments to prevent failure.
But internal methods may assume their arguments are valid for
efficiency reasons. Public methods must take more care to check
the validity of arguments because external users are more likely to
violate restrictions on arguments Internal, or private, methods can
often assume preconditions since the implementor has tighter
control and can rely on the public methods that call them for error
checking.
Avoid predefined limits. When possible use dynamic memory
allocation to create data structures that do not have predefined
limits.
(iii)Extensibility:
Extensibility is a system design principle where the implementation
takes future growth into consideration. It is a systemic measure of
the ability to extend a system and the level of effort required to
implement the extension. Extensions can be through the addition of
new functionality or through modification of existing functionality.
The central theme is to provide for change typically enhancements
while minimizing impact to existing system functions.
(iv)Abstraction:
The goal of abstraction is to isolate those aspects that are important
for some purpose and suppress those aspects that are unimportant.
Abstraction must always be for some purpose, because the purpose
determines what is, and is not, important. Many different
abstractions of the same thing are possible, depending on the
purpose for which they are made.

Ques 24 Compare abstraction and encapsulation.

AKTU 2015-16, Marks 05

Answer
KEY DIFFERENCE

• Abstraction shows only useful data by providing the most

necessary details whereas Encapsulation wraps code and data
for necessary information.
• Abstraction is focused mainly on what should be done while
Encapsulation is focused on how it should be done.
• Abstraction hides complexity by giving you a more abstract
picture while Encapsulation hides internal working so that you
can change it later.
• Abstraction helps you to partition the program into many
independent portions whereas Encapsulation is easy to change
with new requirements.
 • Abstraction solves problem at design level while Encapsulation
solves problem at implementation level.
• Abstraction hides the irrelevant details found in the code
whereas Encapsulation helps developers to organize the entire
code easily.
Difference between Abstraction and Encapsulation:
Abstraction Encapsulation
Abstraction is the process or
While encapsulation is the process or
method of gaining the
method to contain the information.
information.

In abstraction, problems are

While in encapsulation, problems are
solved at the design or interface
solved at the implementation level.
level.

Whereas encapsulation is a method to

Abstraction is the method of
hide the data in a single entity or unit
hiding the unwanted
along with a method to protect
information.
information from outside.

We can implement abstraction Whereas encapsulation can be

using abstract class and implemented using by access modifier
interfaces. i.e. private, protected and public.

In abstraction, implementation
While in encapsulation, the data is hidden
complexities are hidden using
using methods of getters and setters.
abstract classes and interfaces.

The objects that help to perform Whereas the objects that result in
abstraction are encapsulated. encapsulation need not be abstracted.

What are the three models in OMT? How is the Object-Oriented

Analysis and design attached with OMT? Explain with an example.

AKTU 2013-14, Marks 10

Answer
Object Modeling Technique’s Models:
There are three main types of models that has been proposed by
OMT:

1. Object Model:
Object Model encompasses the principles of abstraction,
encapsulation, modularity, hierarchy, typing, concurrency and
persistence. Object Model basically emphasizes on
the object and class. Main concepts related with Object Model
are classes and their association with attributes. Predefined
relationships in object model are aggregation and
generalization (multiple inheritance).
2. Dynamic Model:
Dynamic Model involves states, events and state diagram
(transition diagram) on the model. Main concepts related with
Dynamic Model are states, transition between states and
events to trigger the transitions. Predefined relationships in
object model are aggregation (concurrency) and
generalization.
3. Functional Model:
Functional Model focuses on the how data is flowing, where
data is stored and different processes. Main concepts involved
in Functional Model are data, data flow, data store, process and
actors. Functional Model in OMT describes the whole processes
and actions with the help of data flow diagram (DFD).

Ques 6 Describe the relation of functional model, object model and

dynamic model. What is the relationship and difference between OOA
and OOD.

AKTU 2014-15, Marks 10

Answer:
Object Model

1. It represents the static structure of the application.

2. It specifies to whom it happens to.
3. Operations in an object model corresponds to events in
dynamic model and functions in functional model.
 4. It is represented using class diagrams.

Dynamic Model

1. It represents the essential behavior of the application.

2. It specifies when it happens.
3. Dynamic model describes the control structure of the objects.
It defines decisions which are dependents of object values and
which can cause action to change object values and invoke
their functions.
4. It is represented using state diagrams.

Functional Model

1. It represents what the application does and not how it does.

2. It specifies what happens.
3. It describes functions to be invoked by operations in object
model and actions in dynamic models.
4. It is represented using data flow diagrams.
What do you mean by multiple inheritances? Explain it with example.
Can you implement multiple inheritances in java?

AKTU 2010-11, Marks 05

Answer
When one class extends more than one classes then this is
called multiple inheritance. For example: Class C extends class A and B
then this type of inheritance is known as multiple inheritance. Java
doesn’t allow multiple inheritance. In this article, we will discuss why
java doesn’t allow multiple inheritance and how we can use
interfaces instead of classes to achieve the same purpose.

Why Java doesn’t support multiple inheritance?

C++ , Common lisp and few other languages supports multiple

inheritance while java doesn’t support it. Java doesn’t allow multiple
inheritance to avoid the ambiguity caused by it. One of the example of
such problem is the diamond problem that occurs in multiple
inheritance.
What is diamond problem?
We will discuss this problem with the help of the diagram below:
which shows multiple inheritance as Class D extends both classes B
& C. Now lets assume we have a method in class A and class B & C
overrides that method in their own way. Wait!! here the problem
comes – Because D is extending both B & C so if D wants to use the
same method which method would be called (the overridden method
of B or the overridden method of C). Ambiguity. That’s the main
reason why Java doesn’t support multiple inheritance.

Describe physical packaging with example.

AKTU 2010-11, Marks 2.5

Answer
Programs are made of discrete physical units that can be edited,
compiled, imported, or otherwise manipulated. In C and Fortran the
units are source files; In Ada, it is packages. In object oriented
languages, there are various degrees of packaging. In any large
project, careful partitioning of an implementation into packages is
important to permit different persons to cooperatively work on a
program.
Packaging include issues:
. Hiding internal information from outside view
. Coherence of entities
. Constructing physical modules.
Notation − Graphically, a package is represented by a tabbed folder. A
package is generally drawn with only its name. However it may have
additional details about the contents of the package. See the
following figures.

Ques 11 What are the different aspects of packaging?

Answer
The different aspects of packaging are −

• Hiding Internal Information from Outside View − It allows a class

to be viewed as a “black box” and permits class implementation
to be changed without requiring any clients of the class to
modify code.
• Coherence of Elements − An element, such as a class, an
operation, or a module, is coherent if it is organized on a
consistent plan and all its parts are intrinsically related so that
they serve a common goal.
• Construction of Physical Modules − The following guidelines help
while constructing physical modules −
o Classes in a module should represent similar things or
components in the same composite object.
o Closely connected classes should be in the same module.
o Unconnected or weakly connected classes should be
placed in separate modules.
o Modules should have good cohesion, i.e., high cooperation
among its components.
 o A module should have low coupling with other modules,
i.e., interaction or interdependence between modules
should be minimum.

What do you mean by documentation? What are the various

considerations in documentation designing? Explain.

AKTU 2011-12, Marks 05

Answer
In computer hardware and software product development,
documentation is the information that describes the product to its
users. It consists of the product technical manuals and online
information (including online versions of the technical manuals and
help facility descriptions). The term is also sometimes used to mean
the source information about the product contained in design
documents, detailed code comments, white papers, and blackboard
session notes.
Documentation is an essential part of any software development
process that records the procedure of making the software. The
design decisions need to be documented for any non–trivial
software system for transmitting the design to others.
Usage Areas
Though a secondary product, a good documentation is
indispensable, particularly in the following areas −

• In designing software that is being developed by a number of

developers
• In iterative software development strategies
• In developing subsequent versions of a software project
• For evaluating a software
• For finding conditions and areas of testing
• For maintenance of the software.
Contents
A beneficial documentation should essentially include the following
contents −

• High–level system architecture − Process diagrams and module

diagrams
• Key abstractions and mechanisms − Class diagrams and object
diagrams.
• Scenarios that illustrate the behavior of the main aspects −
Behavioural diagrams
Features
The features of a good documentation are −

• Concise and at the same time, unambiguous, consistent, and

complete
• Traceable to the system’s requirement specifications
• Well-structured
• Diagrammatic instead of descriptive
Write a short note on Object-Oriented Analysis and Object-Oriented
Design.

Answer:
Object Oriented Analysis (OOA):
Object Oriented Analysis (OOA) is the first technical activity
performed as part of object oriented software engineering. OOA
introduces new concepts to investigate a problem. It is based in a
set of basic principles, which are as follows-

1. The information domain is modeled.

2. Behavior is represented.
3. Function is described.
4. Data, functional, and behavioral models are divided to uncover
greater detail.
5. Early models represent the essence of the problem, while later
ones provide implementation
details.
The above notes principles form the foundation for the OOA
approach.
Object Oriented Design (OOD):
An analysis model created using object oriented analysis is
transformed by object oriented design into a design model that
works as a plan for software creation. OOD results in a design having
several different levels of modularity i.e., The major system
components are partitioned into subsystems (a system level
“modular”), and data their manipulation operations are encapsulated
into objects (a modular form that is the building block of an OO
system.).
In addition, OOD must specify some data organization of attributes
and a procedural description of each operation.
Shows a design pyramid for object oriented systems. It is having the
following four layers.

Ques 2 Write a short note on Object Design.

Answer
In the object-oriented design method, the system is viewed as a
collection of objects (i.e., entities). The state is distributed among
the objects, and each object handles its state data. For example, in a
Library Automation Software, each library representative may be a
separate object with its data and functions to operate on these data.
The tasks defined for one purpose cannot refer or change data of
other objects. Objects have their internal data which represent their
state. Similar objects create a class. In other words, each object is a
member of some class. Classes may inherit features from the
superclass.
The different terms related to object design are:

Objects: All entities involved in the solution design are known as

objects. For example, person, banks, company, and users are
considered as objects. Every entity has some attributes associated
with it and has some methods to perform on the attributes.
Classes: A class is a generalized description of an object. An object is
an instance of a class. A class defines all the attributes, which an
object can have and methods, which represents the functionality of
the object.
Messages: Objects communicate by message passing. Messages
consist of the integrity of the target object, the name of the
requested operation, and any other action needed to perform the
function. Messages are often implemented as procedure or function
calls.
Abstraction: In object-oriented design, complexity is handled using
abstraction. Abstraction is the removal of the irrelevant and the
amplification of the essentials.
Encapsulation: Encapsulation is also called an information hiding
concept. The data and operations are linked to a single unit.
Encapsulation not only bundles essential information of an object
together but also restricts access to the data and methods from the
outside world.
Inheritance: OOD allows similar classes to stack up in a hierarchical
manner where the lower or sub-classes can import, implement, and
re-use allowed variables and functions from their immediate
superclasses.This property of OOD is called an inheritance. This
makes it easier to define a specific class and to create generalized
classes from specific ones.
Polymorphism: OOD languages provide a mechanism where methods
performing similar tasks but vary in arguments, can be assigned the
same name. This is known as polymorphism, which allows a single
interface is performing functions for different types. Depending
upon how the service is invoked, the respective portion of the code
gets executed.

How can we design an algorithm? Explain.

Answer
Algorithm Design
The operations in the objects are defined using algorithms. An
algorithm is a stepwise procedure that solves the problem laid down
in an operation. Algorithms focus on how it is to be done.
There may be more than one algorithm corresponding to a given
operation. Once the alternative algorithms are identified, the
optimal algorithm is selected for the given problem domain. The
metrics for choosing the optimal algorithm are −

• Computational Complexity − Complexity determines the

efficiency of an algorithm in terms of computation time and
memory requirements.
• Flexibility − Flexibility determines whether the chosen
algorithm can be implemented suitably, without loss of
appropriateness in various environments.
• Understandability − This determines whether the chosen
algorithm is easy to understand and implement.
Optimization of Algorithms
In object-oriented systems, optimization of data structure and
algorithms are done in a collaborative manner. Once the class design
is in place, the operations and the algorithms need to be optimized.
Optimization of algorithms is obtained by −
Rearrangement of the order of computational tasks
Reversal of execution order of loops from that laid down in the
functional model
Removal of dead paths within the algorithm

Describe implementation of control in OOD.

Answer
Implementation of Control
The object designer may incorporate refinements in the strategy of
the state–chart model. In system design, a basic strategy for
realizing the dynamic model is made. During object design, this
strategy is aptly embellished for appropriate implementation.
The approaches for implementation of the dynamic model are −
 • Represent State as a Location within a Program − This is the
traditional procedure-driven approach whereby the location of
control defines the program state. A finite state machine can
be implemented as a program. A transition forms an input
statement, the main control path forms the sequence of
instructions, the branches form the conditions, and the
backward paths form the loops or iterations.
• State Machine Engine − This approach directly represents a
state machine through a state machine engine class. This class
executes the state machine through a set of transitions and
actions provided by the application.
• Control as Concurrent Tasks − In this approach, an object is
implemented as a task in the programming language or the
operating system. Here, an event is implemented as an inter-
task call. It preserves inherent concurrency of real objects.
Ques 9 What do you mean by object representation.

Answer
Object Representation
Once the classes are identified, they need to be represented using
object modelling techniques. This stage essentially involves
constructing UML diagrams.
There are two types of design models that need to be produced −

• Static Models − To describe the static structure of a system

using class diagrams and object diagrams.
• Dynamic Models − To describe the dynamic structure of a
system and show the interaction between classes using
interaction diagrams and state–chart diagrams.

Write a short note on Jackson structured development.

AKTU 2011-12, 2012-13, 2013-14, Marks 05

Answer
Jackson System Development (JSD) is a method of system
development that covers the software life cycle either directly or by
providing a framework into which more specialized techniques can
fit. JSD can start from the stage in a project when there is only a
general statement of requirements.
However many projects that have used JSD actually started slightly
later in the life cycle, doing the first steps largely from existing
documents rather than directly with the users.

Phases of JDS:
JSD has 3 phases:
Modelling Phase:
In the modelling phase of JSD the designer creates a collection of
entity structure diagrams and identifies the entities in the system,
the actions they perform, the attributes of the actions and time
ordering of the actions in the life of the entities.
Specification Phase:
This phase focuses on actually what is to be done? Previous phase
provides the basic for this phase. An sufficient model of a time-
ordered world must itself be time-ordered. Major goal is to map
progress in the real world on progress in the system that models it.

Implementation Phase:
In the implementation phase JSD determines how to obtain the
required functionality. Implementation way of the system is based
on transformation of specification into efficient set of processes.
The processes involved in it should be designed in such a manner
that it would be possible to run them on available software and
hardware.
JSD Steps:
Initially there were six steps when it was originally presented by
Jackson, they were as below:
 • Entity/action step
• Initial model step
• Interactive function step
• Information function step
• System timing step
• System implementation step

Describe passing arguments to method with example.

AKTU 2012-13, Marks 05

Answer
There are different ways in which parameter data can be passed into
and out of methods and functions. Let us assume that a function B() is
called from another function A(). In this case A is called the “caller
function” and B is called the “called function or callee function”. Also, the
arguments which A sends to B are called actual arguments and the
parameters of B are called formal arguments.

Types of parameters:
Formal Parameter : A variable and its type as they appear in the
prototype of the function or method.
Syntax:
function_name(datatype variable_name)

Actual Parameter : The variable or expression corresponding to a

formal parameter that appears in the function or method call in the
calling environment.
Syntax:
func_name(variable name(s));
Pass By Value: Changes made to formal parameter do not get
transmitted back to the caller. Any modifications to the formal
parameter variable inside the called function or method affect only
the separate storage location and will not be reflected in the actual
parameter in the calling environment. This method is also called
as call by value.
Java in fact is strictly call by value.

Call by reference(aliasing): Changes made to formal parameter do get

transmitted back to the caller through parameter passing. Any
changes to the formal parameter are reflected in the actual
parameter in the calling environment as formal parameter receives a
reference (or pointer) to the actual data. This method is also called
as call by reference. This method is efficient in both time and space.