How does the flow of the OO cycle differ from the conventional cycle?

Conventional is linear (requirements, design, code, test); OO is iterative and incremental

OO is linear; conventional is iterative

Why is the OO transition between phases called seamless?

Because the same objects and classes carry through analysis, design and code

Because DFDs are converted to structure charts

When are risk and testing handled in the OO cycle?

Risk found early; testing in every iteration

Risk found late; testing at the end

Risk is ignored; testing is optional

Risk found late; testing in every iteration

In the library example, how does the first OO iteration proceed?

It delivers 'Issue Book' completely, and the next adds 'Return Book' and fines

It delivers every feature at once

It designs files and tables separately first

2070 Magh · 7 marks

OO design cycle vs conventional cycle

Short answer

Conventional design follows a linear, sequential process separating data and functions, with a gap between models. Object-oriented design is iterative and incremental, using the same objects across phases, giving seamless transition, higher reuse, early risk detection, and easier change. For example, library use cases map to classes that are refined iteratively.

What are the main differences of OO based design cycle to other conventional design cycle? Explain with relevant example.

The conventional (structured/waterfall) cycle is function oriented and sequential. The OO design cycle is object oriented, iterative and incremental, and the same classes carry through analysis, design and code.

Main differences

Point	Conventional cycle	OO cycle
Flow	Linear: requirements, design, code, test	Iterative and incremental
Basis	Functions and data flow	Objects and classes
Models	DFD, ERD, structure chart	Use case, class, sequence, state diagrams
Transition between phases	Big gap (DFD to structure chart needs translation)	Smooth: same objects in analysis, design and code ("seamless")
Data and process	Separated	Combined (encapsulation)
Change	Costly late in the cycle	Easier; feedback each iteration
Reuse	Little	High (inheritance, polymorphism, frameworks)
Risk	Found late	Found early
Testing	At the end	In every iteration

 Conventional:   Req -> Design -> Code -> Test -> Maintain

 OO (iterative):  +--------------------------+
                  v                          |
              Analysis -> Design -> Code -> Test
                  (use cases, classes, objects)

Example: Library system.

Conventional: DFD finds processes "issue book", "return book"; these are mapped to modules in a structure chart; then files/tables are designed separately.
OO: use cases "Issue Book" and "Return Book" are found; the domain classes Book, Member, Loan are identified; the same classes get methods in design (Loan.calculateFine()) and are coded directly as Java/C++ classes. The first iteration delivers "Issue Book" completely; the next adds "Return Book" and fines.

Thus OO design reduces the semantic gap between the problem and the solution and handles change better.

✓ Answer checked by Claude Opus 5.5 (high effort)

Exception handling: OO vs conventional · Object Oriented Analysis and Design, chapter 4
Pattern based design and benefits · Object Oriented Analysis and Design, chapter 3
GFS vs other file systems · Big Data Technologies, chapter 2
Conventional vs non-conventional sources with schematic · Power System Analysis I, chapter 1
Design main transmission pipes PQ and QR · Water Supply Engineering, chapter 7
Conventional design of mat foundation · Foundation Engineering, chapter 7 · asked 3×

All Object Oriented Analysis and Design chapter 1 questions →

OO design cycle vs conventional cycle

Main differences

Related questions