SDLC is a structured process for planning, creating, testing, and deploying an information system.
Example:
Building a Library Management System:
1. Planning: Understand the need for automation.
2. Analysis: Gather requirements (e.g., user logins, book issue).
3. Design: Create database structure, interface mockups.
4. Implementation: Code the system.
5. Testing: Run sample use cases.
6. Maintenance: Fix bugs, add features over time.
Identifying what users need from the system through interviews, observations, and document analysis.
Example:
For a hospital system, requirements may include:
- Patient record management
- Appointment scheduling
- Billing and prescriptions
Logical Design: Focuses on what the system will do (data flow, processes).
Physical Design: Focuses on how the system will be implemented (hardware, software, files).
Example:
Logical: Patient → Checkup → Bill generation
Physical: SQL database → Web interface → Hospital LAN server
Test Planning: Deciding how to test the system for errors, performance, and usability.
Implementation: Putting the system into use with proper installation and training.
Example:
Test Plan: Unit Test, Integration Test, User Acceptance Test
Implementation: Deploy system, train staff, monitor performance.
Evaluation ensures the system meets requirements. Communication, interviewing, and presentation skills are vital for gathering accurate requirements and presenting solutions.
Example:
Interviewing users helps identify missing features;
Presenting a system demo to stakeholders ensures feedback.
Group Dynamics: How team members interact to achieve goals.
Feasibility Analysis: Checks if a system is viable technically, economically, and operationally.
Example:
Feasibility study of an eCommerce platform:
- Technical: Can we build it with current tools?
- Economic: Will the benefits outweigh the costs?
- Operational: Will users adapt to the new system?
Example:
In a JAD session for a college system,
Admins, students, and developers meet to agree on features like marks entry, attendance tracking, etc.
Prototyping: Building a quick working model of the system to gather user feedback.
Database Design: Structuring data storage to ensure consistency, security, and efficiency.
Example:
Prototype: Build login and dashboard screens to show users.
Database: Tables for Students, Courses, Grades with foreign key relationships.
Metrics help evaluate how well the software meets user needs. Common metrics include:
Example:
If 100 defects are found in 10,000 LOC,
Defect Density = 100 / 10,000 = 0.01 or 1%
Applications can be:
Software Package Evaluation: Involves comparing features, cost, vendor support before purchasing.
Example:
For accounting, compare:
- Tally vs. Zoho Books
Based on cost, usability, support, integration options.
Data Flow Diagrams (DFD) are graphical tools used to represent the flow of data through a system. They help in understanding how data is processed, stored, and transferred.
Example:
Library Management System - Logical DFD (Level 0):
[Student] → (Request Book) → [Library System] → (Issue Book) → [Student]
Physical DFD may include:
- Barcode scanner hardware
- SQL database for book inventory
- Web server handling book issue logic
Both represent data flow, but with different purposes:
Example:
Logical DFD:
Process: "Process Order"
Input: Customer Order
Output: Order Confirmation
Physical DFD:
Process: "Process Order" implemented using:
- Web Form
- Order table in MySQL database
- Confirmation Email Server
Entity Relationship Diagrams (ERD) help in visualizing and designing the structure of a database. They model entities (objects), their attributes (properties), and relationships.
Example:
Student(ID, Name, Email)
Course(Code, Title, Credits)
Relationship: Student "enrolls in" Course
One Student → can enroll in many Courses (1:M)
One Course → can have many Students (M:M)
Logical ERDs represent the business requirements of the system in terms of entities and relationships, independent of the database software or implementation details.
Example:
Entities: Customer, Order
Attributes:
- Customer: ID, Name, Phone
- Order: OrderID, Date, Amount
Relationship: Customer "places" Order (1:M)
This logical view helps design a normalized and efficient database structure.
A Feasibility Study determines whether a proposed system is practical and achievable before development begins. It helps in decision-making and risk reduction.
Example:
A college plans to digitize student attendance.
Feasibility study checks:
- Availability of barcode scanners (Technical)
- Budget for software and hardware (Economic)
- Teachers' readiness to use it (Operational)
Cost Estimation predicts the resources and money required for the system. It includes development, training, testing, hardware, and maintenance costs.
Example:
Estimated Cost for Inventory System:
- Developer Salary: ₹1,00,000
- Server Hosting: ₹10,000
- Training Staff: ₹5,000
- Total: ₹1,15,000
Input Design ensures the system gets accurate and complete data from users. Input Controls prevent errors and fraud.
Example:
Login Form:
- Username: must be email format
- Password: must be at least 8 characters
- Submit button disabled until all fields are filled
Output Design focuses on presenting system results clearly. Output Controls ensure accuracy and security of output.
Example:
- Student result sheet: shows marks, grades, and GPA
- Only admin can export the results to PDF
File Design involves organizing files to store system data efficiently. Database Design structures data into tables, keys, and relationships.
Example:
Table: Students(StudentID, Name, DepartmentID)
Table: Departments(DepartmentID, Name)
→ One-to-many relationship between Departments and Students
Process Design defines how the system performs its functions – step-by-step instructions for data processing.
Example:
Online Shopping Cart:
1. Add Item → Update Quantity → Calculate Total → Checkout → Send Invoice
UI Design involves creating interfaces that are simple, efficient, and enjoyable to use.
Example:
Banking App Dashboard:
- Buttons: Transfer Money, View Balance
- Tooltips for icons, and real-time balance update after transaction
Prototyping is the process of building a quick working model of a system to understand and validate user requirements.
Example:
Create a clickable prototype for a hostel booking system:
- Students click “Book Room” → Select room type → Preview charges → Confirm
Software Constructors are tools and platforms used to build applications without writing full code manually.
Example:
Use Visual Studio to drag-and-drop UI components and auto-generate backend code for a Windows Form App.
Documentation provides details about system design, usage, and maintenance. It ensures knowledge transfer and future updates.
Example:
User Manual: "Click 'Submit' to save your form."
Technical Doc: "Function SaveData() commits the record to SQL Server."
Application development methodologies are structured approaches to planning, designing, developing, and deploying software systems. They ensure better quality, collaboration, and predictable results.
Example:
Banking Application
- IE: Analyze organizational data needs before system design.
- SSAD: Use DFDs to show customer login → balance inquiry → transaction.
- OOP: Class "Account" with attributes (balance) and methods (deposit, withdraw).
Data Modeling defines how data is structured, stored, and related in a system. It’s a blueprint for database design.
Example:
Entity: Student(ID, Name, CourseID)
Entity: Course(CourseID, Title)
Relationship: Student "enrolled in" Course (M:1)
Process Modeling describes how business processes operate within a system. It uses tools like DFDs, flowcharts, and activity diagrams.
Example:
Online Order Process:
- Customer places order → System checks inventory → Processes payment → Generates invoice → Updates stock.
UI Design: Focuses on creating an interface that is intuitive, efficient, and user-friendly.
Prototyping: Building an early sample/mockup of the system to collect feedback and refine requirements.
Example:
Online Fee Payment Portal Prototype:
- Homepage → Login Page → Dashboard → Pay Now → Payment Confirmation
Tested with students before building the full system.
CASE tools are software programs that help in automating the steps of software development such as analysis, design, and coding.
Example:
Using Visual Paradigm:
- Draw ERD and DFD
- Generate class diagrams
- Auto-generate Java code for classes
This reduces manual effort and improves accuracy.
OOAD is a methodology for analyzing and designing a system by visualizing it as a group of interacting objects, each defined by its class, attributes, and behaviors.
Example:
In a University System:
- Classes: Student, Professor, Course
- Behaviors: Student registers(), Professor assignsGrade()
OOA identifies classes; OOD defines relationships and interactions.
Object Modeling Technique by James Rumbaugh provides a structured method for modeling systems using three models:
Example:
Object Model → Class: Account (Attributes: balance, owner)
Dynamic Model → State: Active → Overdrawn → Closed
Functional Model → Input: Deposit → Process: Update → Output: New Balance
Object Modeling defines the objects, their classes, attributes, methods, and relationships in the system.
Example:
Class: Book
Attributes: title, author, ISBN
Methods: issue(), return(), checkAvailability()
Relationship: A Library has many Books (1:M)
Dynamic Modeling captures how objects behave and interact over time. It uses:
Example:
ATM Card State Diagram:
States → Inserted → Verified → Transaction Processing → Ejected
Transitions based on user actions and validations.
This approach merges traditional functional decomposition with object-oriented design. It ensures:
Example:
Class: Invoice
Function: calculateTotal() → Calls calculateTax(), applyDiscount()
All logic grouped logically inside the class → clean & reusable.
OOPS is the implementation of OOAD concepts using programming languages like Java, C++, or Python.
Example (Java):
class Animal {
void speak() { System.out.println("Sound"); }
}
class Dog extends Animal {
void speak() { System.out.println("Bark"); }
}
Polymorphism: Animal a = new Dog(); → a.speak() → Outputs "Bark"
Object-Oriented Databases store data as objects, similar to OOP languages. They support class hierarchies, methods, and complex data types.
Example:
Object: Student(Name, RollNo, Courses[])
Can be saved and retrieved as an object in OODB like db4o or ObjectDB
No need for SQL table conversion → seamless with OOP code
Software markets involve the development, distribution, and support of software products and services. They can be categorized as:
Example:
TCS and Infosys develop custom software for banks,
while Adobe sells packaged creative tools globally.
Project planning defines the roadmap for delivering the software within time and budget. It includes:
Example:
In a mobile app project:
- Scope: User login, chat, and notifications
- Resources: 2 developers, 1 designer, 2 months
- Plan: Week-by-week tasks scheduled
Size estimation measures how big the software is, and cost estimation predicts the budget required to develop it.
Example:
Estimated LOC = 5,000
Developer cost = ₹25/LOC → Total = ₹1,25,000
Add testing, documentation, buffer = Total ~ ₹1.5 lakhs
Scheduling involves defining a timeline for each task and milestone. Tools used:
Example:
Gantt Chart shows:
Week 1–2: Requirement gathering
Week 3–5: Design
Week 6–9: Coding
Week 10–11: Testing
Week 12: Deployment
Software Quality ensures the product is reliable, secure, and meets user needs. Productivity measures how efficiently a team delivers software.
Example:
- 10 defects in 2000 LOC → Defect Density = 5 per 1,000 LOC
- 1 developer delivers 500 LOC/week → Good productivity
ISO (International Organization for Standardization) provides global standards for quality management in software (e.g., ISO 9001).
Capability Maturity Model (CMM) helps organizations improve their software processes through 5 maturity levels:
Example:
A company at CMM Level 3 has defined coding standards and testing procedures.
At Level 5, it uses AI-based tools to optimize project delivery continuously.