--- title: "OO design cycle vs conventional cycle" subject: "Object Oriented Analysis and Design" chapter: 1 key: "semester_6/object_oriented_analysis_and_design:oo-design-cycle-vs-conventional" source: https://www.bctengineer.com/q/semester_6/object_oriented_analysis_and_design/oo-design-cycle-vs-conventional site: BCT Engineering --- # OO design cycle vs conventional cycle Object Oriented Analysis and Design · Chapter 1: Object Oriented Fundamentals - Asked in: 2070 Magh, 7 marks - Video: [Function Oriented vs Object Oriented Design Approach | Software Design Approaches](https://www.youtube.com/watch?v=bTv3qCtSR5c) — Gate Smashers - Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14 - Page: https://www.bctengineer.com/q/semester_6/object_oriented_analysis_and_design/oo-design-cycle-vs-conventional - Whole chapter: https://www.bctengineer.com/md/semester_6/object_oriented_analysis_and_design/chapter-1 ## Question What are the main differences of OO based design cycle to other conventional design cycle? Explain with relevant example. ## 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. ## Answer 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 | ```text 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. ## Check yourself The answer's key points as multiple-choice questions, with the correct option and why. 1. How does the flow of the OO cycle differ from the conventional cycle? A. OO is linear; conventional is iterative B. Conventional is linear (requirements, design, code, test); OO is iterative and incremental C. Both are identical D. OO skips testing Answer: B. The conventional cycle is sequential waterfall; OO repeats the activities in iterations. (Key point: Flow of cycle) 2. Why is the OO transition between phases called seamless? A. Because DFDs are converted to structure charts B. Because the same objects and classes carry through analysis, design and code C. Because no design is required D. Because testing is done once Answer: B. Conventional methods need translation (DFD to structure chart); OO keeps the same classes throughout. (Key point: Seamless transition) 3. When are risk and testing handled in the OO cycle? A. Risk found late; testing at the end B. Risk found early; testing in every iteration C. Risk is ignored; testing is optional D. Risk found late; testing in every iteration Answer: B. Each iteration delivers a tested part, exposing risk early. (Key point: Risk and testing) 4. In the library example, how does the first OO iteration proceed? A. It delivers every feature at once B. It delivers 'Issue Book' completely, and the next adds 'Return Book' and fines C. It only draws a DFD D. It designs files and tables separately first Answer: B. Use cases are delivered incrementally using the classes Book, Member and Loan. (Key point: Library example) ## Related in Object Oriented Analysis and Design - [Exception handling: OO vs conventional](https://www.bctengineer.com/question.md?key=semester_6%2Fobject_oriented_analysis_and_design%3Aexception-error-handling-oo-vs-conventional) — Object Oriented Analysis and Design, chapter 4 - [Pattern based design and benefits](https://www.bctengineer.com/question.md?key=semester_6%2Fobject_oriented_analysis_and_design%3Apattern-based-design-benefits) — Object Oriented Analysis and Design, chapter 3 ## Related in other subjects - [GFS vs other file systems](https://www.bctengineer.com/question.md?key=semester_8%2Fbig_data_technologies%3Agfs-differ-other-fs) — Big Data Technologies, chapter 2 - [Conventional vs non-conventional sources with schematic](https://www.bctengineer.com/question.md?key=semester_4%2Fpower_system_analysis_i%3Aconventional-vs-nonconventional-sources-schematic) — Power System Analysis I, chapter 1 - [Design main transmission pipes PQ and QR](https://www.bctengineer.com/question.md?key=semester_5%2Fwater_supply_engineering%3Apd-c70o) — Water Supply Engineering, chapter 7 - [Conventional design of mat foundation](https://www.bctengineer.com/question.md?key=semester_5%2Ffoundation_engineering%3Amat-conventional-design) — Foundation Engineering, chapter 7, asked 3×