Simplified, high-yield notes covering the core concepts from the CSIT-601 syllabus, with added context on how these concepts actually apply (or why they are obsolete) in the modern tech industry.
- Waterfall Model: A linear, sequential approach (Requirements → Design → Code → Test → Deploy).
Modern Reality: Almost completely abandoned in modern software. Only used in highly regulated hardware-adjacent fields (aerospace, medical devices) where requirements absolutely cannot change mid-flight.
- Spiral Model: A risk-driven, iterative framework iterating through prototypes.
Modern Reality: The core concept of "iterative risk assessment" lives on in Agile, but strictly following the Spiral model is rare today.
- Unified Process (UP): An architecture-centric, use-case driven process.
Modern Reality: Largely replaced by Agile/Scrum. Its heavy documentation requirements made it too slow for modern fast-paced startups and enterprises.
- Tracking and controlling changes in the software over its lifecycle.
Modern Reality: This is now simply called Version Control. Git (via GitHub, GitLab, Bitbucket) is the absolute industry standard. It is tightly coupled with CI/CD (Continuous Integration/Continuous Deployment) to automatically test and deploy code.
- Quantitative indication of system attributes.
Modern Reality: Instead of counting abstract errors per line of code, the industry focuses on DORA Metrics: Deployment Frequency, Lead Time for Changes, Change Failure Rate, and Time to Restore Service.
- LOC (Lines of Code) & FP (Function Point).
Modern Reality: LOC is never used. More code does not mean better or more complex work (often, deleting code is harder than writing it). Function Points are also practically dead outside of government contracts.
- COCOMO: Empirical model to estimate Effort, Cost, and Duration.
Modern Reality: Completely obsolete in everyday software engineering. Teams today do not use math formulas for project estimation. Instead, they use Agile Story Points (relative complexity sizing like Fibonacci numbers: 1, 2, 3, 5, 8) or T-shirt sizing (S, M, L, XL), and track team "Velocity".
- Feasibility Study & Formal Specifications.
Modern Reality: Formal mathematical specifications are extremely rare outside of mission-critical systems (e.g., NASA). Today, requirements are captured continuously as User Stories (
"As a [user], I want [action] so that [benefit]") managed in tools like Jira or Linear.
- Top-Down & Bottom-Up Design.
Modern Reality: Teams use both organically. However, modern architecture is heavily focused on Microservices and API-First Design rather than monolithic top-down planning.
- Modularity (High Cohesion, Low Coupling).
Modern Reality: Still 100% relevant. This is the exact philosophy behind Microservices and modern component-based frontend frameworks (React, Vue).
- Coding Standards & Code Review.
Modern Reality: Highly relevant, but automated. Coding standards are enforced by Linters (ESLint) and formatters (Prettier, Black) running automatically. Peer code review is enforced via Pull Requests (PRs) before code can ever reach production.
- White-Box vs Black-Box Testing.
- Unit → Integration → System → Acceptance.
Modern Reality: Testing is heavily automated. Teams write Unit Tests (Jest, PyTest) and automated End-to-End/UI Tests (Cypress, Playwright). QA is rarely a manual phase at the very end anymore; tests are run automatically on every single Git commit in a CI pipeline (Test-Driven Development).
Modern Reality: Agile won. Traditional (Waterfall) SDLC is virtually extinct in modern web, SaaS, and mobile app development. The ability to pivot and release software daily/weekly is required to survive today.
- Scrum: Employs fixed-length development cycles called Sprints (usually 2 weeks) with Daily Standups and Sprint Retrospectives.
Modern Reality: The most widely adopted framework in the industry today.
- Kanban: A visual workflow board (To Do → In Progress → Review → Done) that limits Work In Progress (WIP).
Modern Reality: Extremely popular for DevOps, support teams, or continuous-delivery teams where fixed 2-week sprints are too rigid.
- Extreme Programming (XP) & Lean: Focus on engineering excellence and eliminating waste.
Modern Reality: While not often adopted strictly by name, core XP practices like CI/CD, Code Reviews, and TDD are just considered "standard software engineering" today.