Unit 2: Project planning and design
Software Engineering notes · PTU syllabus (BSIT503/BSBC401)
On this page
- Unit summary
- Decomposition techniques and software sizing
- Problem-based estimation
- Process-based estimation
- The COCOMO model
- Structured analysis principles and requirement analysis
- Data flow diagrams
- ER diagrams and the data dictionary
- Design objectives, principles and concepts
- Data, architectural and procedural design
- Architectural styles
- Object-oriented concepts
- Key terms
- Quick revision
- Important questions
Unit summary
Planning estimates how big and costly the software will be, analysis models what it must do, and design decides how. This unit covers decomposition and sizing, problem-based and process-based estimation, COCOMO, structured analysis, requirement analysis, DFDs, ER diagrams, the data dictionary, design objectives, principles and concepts, data, architectural and procedural design, and object-oriented concepts.
After this unit you can
- Estimate size, effort and cost
- Apply the COCOMO model
- Build analysis models with DFDs, ER diagrams and a data dictionary
- Apply design concepts and object-oriented concepts
PTU syllabus topics
- Decomposition techniques
- software sizing
- problem-based and process-based estimation
- COCOMO model
- structured analysis principles
- requirement analysis
- DFD
- ER diagrams
- data dictionary
- design objectives/principles/concepts
- data/architecture/procedural design
- object-oriented concepts
Topic 1
Decomposition techniques and software sizing
- Decomposition: dividing the problem (functions) or the process (tasks) into smaller pieces that can be estimated more accurately.
- Fuzzy logic sizing
- Classify the application by type and magnitude, then refine
- Function point sizing
- Estimate the information domain characteristics
- Standard component sizing
- Count standard components (screens, reports, modules)
- Change sizing
- Estimate changes to existing software
Example
Size estimation: a library system is decomposed into modules — catalogue (2 KLOC), issue/return (3 KLOC), members (1.5 KLOC) and reports (1 KLOC). The total estimated size is 7.5 KLOC, which drives effort and cost estimates.
Exam tip
Sizing approaches: LOC-based, function-point-based, fuzzy logic and standard component sizing.
Topic 2
Problem-based estimation
- Estimate LOC or FP for each decomposed function as optimistic (o), most likely (m) and pessimistic (p) values, then compute the expected value.
Expected size
S = (o + 4m + p) ÷ 6
Effort
Size ÷ productivity (LOC or FP per person-month)
Cost
Effort × labour rate
Example
A function estimated at o = 2,000, m = 3,000, p = 5,000 LOC: S = (2,000 + 12,000 + 5,000) ÷ 6 ≈ 3,167 LOC. At 500 LOC per person-month: about 6.3 person-months.
- Function points: FP = count total × (0.65 + 0.01 × ΣFi), where the count total weights inputs, outputs, inquiries, internal files and external interfaces, and Fi are 14 value adjustment factors (0–5).
Topic 3
Process-based estimation
- Decompose the process into framework activities (communication, planning, modelling, construction, deployment) for each software function, estimate effort for each cell of the function–activity table, and total the effort.
- Compare with the problem-based estimate; large differences mean the scope or data needs review.
Example
Estimating by process: for each function, the team estimates effort for analysis, design, coding and testing. Summing gives, say, 46 person-months. At ₹1.2 lakh per person-month, the estimated cost is about ₹55 lakh.
Exam tip
Estimate effort for each function and activity, then add them up.
Topic 4
The COCOMO model
| Technique | How it works |
|---|---|
| Lines of code (LOC) | Estimate size in KLOC, then effort per KLOC |
| Function points (FP) | Count inputs, outputs, inquiries, files and interfaces, weighted for complexity |
| COCOMO | Effort = a × (KLOC)ᵇ person-months; organic, semi-detached, embedded modes |
| Expert judgement / Delphi | Experts estimate independently, then converge |
| Story points (agile) | Relative size of user stories; planning poker |
Example
Basic COCOMO, organic mode: Effort = 2.4 × (KLOC)^1.05. For 10 KLOC, Effort ≈ 2.4 × 11.2 ≈ 27 person-months.
Organic
Small team, familiar, flexible requirements
E = 2.4 (KLOC)^1.05; D = 2.5 E^0.38
Semi-detached
Medium size, mixed experience
E = 3.0 (KLOC)^1.12; D = 2.5 E^0.35
Embedded
Tight hardware, software and operational constraints
E = 3.6 (KLOC)^1.20; D = 2.5 E^0.32
- Intermediate COCOMO multiplies effort by an effort adjustment factor from 15 cost drivers (reliability, complexity, analyst capability, tools); detailed COCOMO applies drivers phase-wise; COCOMO II uses object points, function points and LOC for modern projects.
Example
Organic project of 32 KLOC: E = 2.4 × 32^1.05 ≈ 91 person-months; D = 2.5 × 91^0.38 ≈ 14 months; average staff ≈ 91 ÷ 14 ≈ 6.5 persons.
Topic 5
Structured analysis principles and requirement analysis
- Information domain
- Represent and understand the data
- Functions
- Define what the software must do
- Behaviour
- Represent states and events
- Partitioning
- Divide models layer by layer
- Essence to implementation
- Move from essential to detailed information
- Requirement analysis tasks: problem recognition, evaluation and synthesis, modelling, specification (SRS) and review. Requirements are functional (what the system does) and non-functional (performance, security, usability).
Example
A data flow diagram: in a library system, the external entity 'Member' sends a 'book request' to the process 'Issue Book', which reads from the 'Books' data store and writes to the 'Issue Records' store.
Exam tip
DFD symbols: external entity (rectangle), process (circle), data store (open rectangle) and data flow (arrow).
Topic 6
Data flow diagrams
- DFD: models how data moves and is transformed; drawn top-down as a context diagram (level 0) refined into level 1 and level 2.
- External entity (rectangle)
- Producer or consumer outside the system
- Process (bubble)
- Transformation of data
- Data flow (arrow)
- Data in motion
- Data store (parallel lines)
- Data at rest
- Rules: every process has at least one input and output; data cannot flow directly between two entities or two stores; balance flows between levels; number processes 1.0, 1.1 and so on.
Example
Library context diagram: entities Member and Librarian exchange issue requests, return details and reports with the single process "Library Management System".
Topic 7
ER diagrams and the data dictionary
- ER diagram: models data objects (entities), their attributes and relationships with cardinality and modality (optional or mandatory).
- Data dictionary: an organised list of all data elements, with name, aliases, where used, content description and supplementary information.
- =
- is composed of
- +
- and
- [ a / b ]
- either a or b
- { }n
- n repetitions
- ( )
- optional data
- Text between asterisks
- comment
Example
telephone number = [local number / long-distance number]; local number = prefix + access number.
Topic 8
Design objectives, principles and concepts
Key design concepts are abstraction, modularity, information hiding, functional independence (high cohesion, low coupling), refinement and refactoring. Design quality guidelines: a design should implement all requirements, be readable and understandable, and give a complete picture of data, functions and behaviour.
- Abstraction
- Focus on essentials, hide detail
- Architecture
- Overall structure of components
- Modularity
- Divide software into separately named modules
- Information hiding
- Modules hide internal details
- Functional independence
- High cohesion, low coupling
- Refinement
- Step-wise elaboration of detail
Exam tip
High cohesion (each module does one thing well) and low coupling (modules depend little on each other) is the mark of good design.
- Traceable to the analysis model
- Every design element linked to requirements
- Do not reinvent the wheel
- Reuse patterns and components
- Minimise intellectual distance
- Structure mirrors the problem
- Uniformity and integration
- Consistent style and interfaces
- Accommodate change
- Easy to modify
- Degrade gently
- Handle errors and unusual input
- Design is not coding
- Higher abstraction than code
Example
Cohesion and coupling: a module that only calculates fees is highly cohesive. If it reads data directly from the exam module's internal variables, coupling is high — a change in the exam module could break the fee module.
Exam tip
Aim for high cohesion and low coupling.
Topic 9
Data, architectural and procedural design
Data design
Data structures and database design
ER diagram and data dictionary
Architectural design
Program structure — modules and their relationships
DFDs, through transform and transaction mapping
Interface design
How software communicates with users and other systems
DFDs and scenarios
Procedural (component-level) design
Algorithms of each module — flowcharts, pseudocode, decision tables
Process specifications
Example
Three levels in a payroll system: data design creates the Employee and Salary tables; architectural design splits the system into input, calculation and reporting modules; procedural design writes the step-by-step logic for calculating tax.
Exam tip
Data design → architectural design → interface design → procedural (component-level) design.
Topic 10
Architectural styles
Common styles include data-centred (a central repository), data-flow (pipes and filters), call-and-return (main program and subprograms), object-oriented, layered and client–server. Software architecture is the structure of a system: its components, their properties and relationships. Common styles: data-centred, data-flow (pipe and filter), call-and-return, layered, object-oriented and client-server. Data design turns the data model from analysis into data structures and database designs.
Example
Layered style: a web application has a presentation layer (web pages), a business logic layer (fee calculation) and a data layer (database). Each layer uses only the one below it, so the database can be changed without rewriting the pages.
Exam tip
Match styles with examples: compiler (pipes and filters), web apps (layered/client–server).
Topic 11
Object-oriented concepts
- Class and object
- Template and instance
- Attributes and operations
- Data and methods
- Encapsulation
- Data and operations packaged together
- Inheritance
- Subclasses reuse superclass features
- Polymorphism
- Same operation behaves differently by class
- Messages
- Objects request services from each other
- OO analysis and design model systems with classes, use cases and UML diagrams (class, use-case, sequence, activity, state).
Example
OO in a library system: Book is a class; each physical book is an object with attributes (title, author) and operations (issue, return). EBook inherits from Book, and the issue operation behaves differently for EBook (polymorphism).
Exam tip
Learn class, object, attribute, operation, message, encapsulation, inheritance and polymorphism.
Key terms
- Decomposition
- Dividing a problem or process into smaller parts for estimation
- Function point
- Measure of functionality delivered
- COCOMO
- Algorithmic cost model relating effort to size
- DFD
- Diagram of data movement through processes
- Data dictionary
- Repository describing all data elements
Quick revision
- Problem and process decomposition; sizing approaches.
- Expected value (o + 4m + p) ÷ 6; LOC and FP estimation.
- COCOMO modes and formulas; intermediate and COCOMO II.
- Analysis principles; DFD levels and rules; ER; data dictionary notation.
- Design principles and concepts; data, architectural, interface, procedural design; OO concepts.
Important exam questions
Practice questions written to the PTU exam pattern for this unit's syllabus: short answers (Section A style) and long answers (Sections B and C style).
Short-answer questions
- Q1.What is software sizing?
- Q2.Write the expected-value formula for estimation.
- Q3.Name the three modes of COCOMO.
- Q4.What is a context diagram?
- Q5.What does "=" mean in a data dictionary?
- Q6.Distinguish cohesion and coupling.
Long-answer questions
- Q1.Explain problem-based and process-based estimation.
- Q2.Explain the COCOMO model with an example.
- Q3.Explain structured analysis using DFD, ER diagram and data dictionary.
- Q4.Explain design concepts and the levels of design.
Stuck on this unit?
Message SBS on WhatsApp for help with Software Engineering, or to ask about studying B.Sc IT at Synetic.
