Software Engineering Cheatsheet

This cheatsheet provides a concentrated reference of essential software engineering concepts, formulas, and frameworks. Use it for quick revision before exams or interviews. Each section distills the most important points from its corresponding detailed chapter.

SDLC Phases Summary

Process Model Selection Guide

Waterfall: Stable requirements, small project, sequential phases, heavy documentation. Not suitable when requirements may change.

V-Model: Like Waterfall but test planning parallels development. Good for safety-critical systems requiring traceability between requirements and tests.

Iterative: Build complete system roughly, then refine through cycles. Good when core architecture is clear but details will evolve.

Incremental: Build and deliver in functional pieces. Good for early partial delivery and when requirements for different modules are at different maturity levels.

Spiral: Risk-driven with prototyping. Good for large, complex, high-risk projects. Each spiral cycle includes risk assessment.

Agile (Scrum): Short sprints (2-4 weeks), continuous feedback, adaptability. Best for evolving requirements, available customer, and cross-functional teams.

Prototype: Build disposable prototype to clarify requirements, then build actual system. Good when requirements are unclear or UI-heavy.

Requirements Engineering Key Points

Types: Functional (what the system does) vs. Non-functional (quality attributes: performance, security, usability, reliability).

Gathering Techniques: Interviews, questionnaires, observation, document analysis, brainstorming, prototyping, use case analysis.

SRS Contents: Introduction, overall description, specific requirements (functional, non-functional), interfaces, constraints, assumptions.

Validation Techniques: Requirements review, prototyping, test case generation, consistency analysis.

Key Principle: The cost of fixing a requirements error increases exponentially through later SDLC phases (1x at requirements, 5x at design, 10x at coding, 20x at testing, 100x after deployment).

Software Design Principles

SOLID Principles:

• Single Responsibility: One class, one reason to change
• Open/Closed: Open for extension, closed for modification
• Liskov Substitution: Subtypes must be substitutable for base types
• Interface Segregation: Many specific interfaces over one general interface
• Dependency Inversion: Depend on abstractions, not concretions

Cohesion (aim HIGH): How strongly related elements within a module are. Types from best to worst: Functional > Sequential > Communicational > Procedural > Temporal > Logical > Coincidental.

Coupling (aim LOW): How dependent modules are on each other. Types from best to worst: Data > Stamp > Control > External > Common > Content.

Design Patterns:

• Creational: Singleton, Factory, Builder, Prototype
• Structural: Adapter, Decorator, Facade, Proxy
• Behavioral: Observer, Strategy, Command, State

Architecture Styles

Testing Levels and Techniques

Testing Levels:

• Unit Testing: Individual functions/methods in isolation
• Integration Testing: Combined modules working together
• System Testing: Complete system against requirements
• Acceptance Testing: User validation of business needs

Black-Box Techniques: Equivalence partitioning, boundary value analysis, decision table testing, state transition testing.

White-Box Techniques: Statement coverage, branch coverage, path coverage, condition coverage.

Key Formula — Cyclomatic Complexity: V(G) = E - N + 2P (Edges minus Nodes plus 2 times connected components). Indicates minimum number of test paths needed.

Project Management Formulas

COCOMO Basic: Effort = a × (KLOC)^b, where a and b depend on project type:

• Organic: Effort = 2.4 × (KLOC)^1.05
• Semi-detached: Effort = 3.0 × (KLOC)^1.12
• Embedded: Effort = 3.6 × (KLOC)^1.20

Development Time: T = c × (Effort)^d

• Organic: T = 2.5 × (Effort)^0.38
• Semi-detached: T = 2.5 × (Effort)^0.35
• Embedded: T = 2.5 × (Effort)^0.32

Function Point Analysis: FP = UFC × CAF (Unadjusted Function Count × Complexity Adjustment Factor)

Defect Density: Total defects / Size (KLOC)

Defect Removal Efficiency: DRE = (Defects found before delivery) / (Total defects) × 100%

UML Diagram Quick Reference

Software Quality Metrics

• MTBF (Mean Time Between Failures): Average time system operates before failure
• MTTR (Mean Time To Repair): Average time to fix a failure
• Availability: MTBF / (MTBF + MTTR) × 100%
• Reliability: Probability of failure-free operation for specified time

Agile/Scrum Quick Reference

Roles: Product Owner (what to build), Scrum Master (process coach), Development Team (builders)

Events: Sprint Planning (what and how), Daily Scrum (15-min sync), Sprint Review (demo to stakeholders), Retrospective (process improvement)

Artifacts: Product Backlog (all requirements), Sprint Backlog (current sprint items), Increment (working software)

Velocity: Average story points per sprint (use last 3-5 sprints)

Configuration Management Essentials

Four Activities: Identification (naming/versioning), Control (change approval), Status Accounting (tracking state), Auditing (verifying correctness)

Git Workflow: clone → branch → edit → stage → commit → push → pull request → review → merge

Semantic Versioning: MAJOR.MINOR.PATCH (breaking.feature.fix)

Security Quick Reference

OWASP Top 3: Injection attacks, broken authentication, sensitive data exposure

Security Principles: Defense in depth, least privilege, fail securely, separation of duties, security by design

Authentication vs. Authorization: Authentication = who are you? (identity). Authorization = what can you do? (permissions).

Maintenance Types

Maintenance Cost: Typically 60-80% of total software lifecycle cost.