Software Development Lifecycle (SDLC) Quiz

Phases:
1. Requirement Analysis: Gathering user needs and analyzing system requirements.
2. Design: Creating architecture and design specifications.
3. Implementation: Writing and compiling the source code.
4. Testing: Verifying the software works as intended.
5. Deployment: Releasing the software for use.
6. Maintenance: Updating and fixing software post-deployment.
Models:
- Waterfall: Linear and sequential process.
- Iterative: Repeatedly refining and improving the software.
- Spiral: Combines iterative development with risk management.

Principles:
- Customer collaboration over contract negotiation.
- Responding to change over following a plan.
- Working software is delivered frequently.
- Continuous attention to technical excellence and good design.
Popular Frameworks:
- Scrum: Focus on sprints, roles (Scrum Master, Product Owner), and ceremonies (Daily Stand-ups, Sprint Reviews).
- Kanban: Visualizes work, limits work in progress, and optimizes flow.
- Extreme Programming (XP): Emphasizes technical practices like pair programming and test-driven development.

Purpose: Track changes, collaborate on code, and maintain history.
Types:
- Centralized VCS: Single server stores all versions (e.g., CVS, Subversion).
- Distributed VCS: Each user has a complete history on their local machine (e.g., Git, Mercurial).
Key Concepts:
- Branches: Divergent copies of the codebase for development.
- Merging: Combining changes from different branches.
- Commits: Recording changes with a message for history.

Types:
- Unit Testing: Tests individual components for correctness.
- Integration Testing: Checks interactions between combined components.
- System Testing: Validates the complete and integrated software system.
- Acceptance Testing: Confirms software meets business requirements.
Testing Approaches:
- Manual Testing: Human testers execute test cases.
- Automated Testing: Scripts and tools perform tests automatically.
Key Concepts:
- Test-Driven Development (TDD): Writing tests before code.
- Continuous Testing: Testing integrated code throughout the development process.

Definition: Standard solutions to common software design problems.
Categories:
- Creational Patterns: Deal with object creation (e.g., Singleton, Factory).
- Structural Patterns: Concerned with object composition (e.g., Adapter, Composite).
- Behavioral Patterns: Define how objects interact (e.g., Observer, Strategy).
Benefits:
- Promote code reusability.
- Enhance code maintainability.
- Facilitate communication among developers.

Phases:
- Requirement Analysis: Involves identifying user needs and system requirements.
- Design: Focuses on developing the system architecture and design specifications.
- Implementation: Entails writing and compiling the source code.
- Testing: Ensures the software functions correctly and meets requirements.
- Deployment: Involves releasing the software for user access.
- Maintenance: Covers updates and fixes to the software post-launch.
Models:
- Waterfall: A linear and sequential development method.
- Iterative: Involves repeated refinement and enhancement of software.
- Spiral: Merges iterative development with a focus on risk management.

Principles:
- Emphasizes customer collaboration over contract negotiation.
- Values responding to change more than strictly following a plan.
- Promotes frequent delivery of working software.
- Advocates for continuous attention to technical precision and quality design.
Popular Frameworks:
- Scrum: Organized around sprints, specific roles like Scrum Master and Product Owner, and ceremonies including Daily Stand-ups and Sprint Reviews.
- Kanban: Utilizes visual tools to manage work, limit work in progress, and enhance workflow efficiency.
- Extreme Programming (XP): Stresses technical practices such as pair programming and test-driven development.

Purpose: Essential for tracking changes, enabling code collaboration, and maintaining a historical record of modifications.
Types:
- Centralized VCS: Features a single server that retains all version histories (e.g., CVS, Subversion).
- Distributed VCS: Each user possesses a complete code history on their local device (e.g., Git, Mercurial).
Key Concepts:
- Branches: Serve as separate working copies of the codebase for individual development.
- Merging: Involves combining changes from different branches into a unified codebase.
- Commits: Document changes in the code with associated messages for historical reference.

Types:
- Unit Testing: Assesses the correctness of individual components.
- Integration Testing: Tests the interaction between integrated components.
- System Testing: Validates the complete software system's functionality.
- Acceptance Testing: Confirms that the software meets defined business requirements.
Testing Approaches:
- Manual Testing: Conducted by human testers executing specified test cases.
- Automated Testing: Relies on scripts and tools to perform tests automatically.
Key Concepts:
- Test-Driven Development (TDD): Advocates writing tests prior to coding the functionality.
- Continuous Testing: Involves ongoing testing of integrated code throughout the development cycle.

Definition: Established solutions for recurring issues in software design.
Categories:
- Creational Patterns: Focus on object creation techniques (e.g., Singleton, Factory).
- Structural Patterns: Emphasize the arrangement of objects (e.g., Adapter, Composite).
- Behavioral Patterns: Describe how objects communicate and interact (e.g., Observer, Strategy).
Benefits:
- Enhance code reusability by providing tested solutions.
- Improve code maintainability through standardized practices.
- Foster effective communication among development teams through shared terminology and practices.