Software Development and Design

Key Concepts

• Software Development Lifecycle (SDLC): Plan → Design → Develop → Test → Deploy → Maintain
• Version Control: Git is the standard; tracks changes, enables collaboration, branching strategies
• Design Patterns: Reusable solutions to common problems (MVC, Singleton, Observer, Factory)
• MVC (Model-View-Controller): Separates data (Model), UI (View), and logic (Controller)
• REST vs. SOAP: REST = stateless, uses HTTP verbs, JSON/XML; SOAP = strict XML, more overhead
• Coding Best Practices: DRY (Don't Repeat Yourself), KISS (Keep It Simple), SOLID principles
• Testing Types:
• Unit – single function/component
• Integration – multiple components together
• Functional – tests against requirements
• End-to-End (E2E) – full workflow simulation
• Regression – ensures new code doesn't break old features
• CI/CD: Continuous Integration (auto-build/test on commit) → Continuous Delivery/Deployment (auto-release)
• Agile vs. Waterfall: Agile = iterative sprints, flexible; Waterfall = sequential, rigid phases
• Scrum Artifacts: Product Backlog, Sprint Backlog, Increment
• Code Review: Peer review before merging; improves quality, catches bugs early
• Technical Debt: Shortcuts taken now that must be fixed later
• Pair Programming: Two devs, one keyboard — driver writes code, navigator reviews in real time

How It Works

• Git Branching: main is production-stable; feature branches are created, worked on, then merged via Pull Request (PR)
• CI/CD Pipeline Flow: Developer pushes code → trigger build → automated tests run → if passed, deploy to staging → promote to production
• TDD (Test-Driven Development): Write the failing test first → write code to pass it → refactor. Cycle = Red → Green → Refactor
• MVC Flow: User sends request → Controller handles it → queries Model for data → passes data to View → View renders response to user

Commands / Syntax / Key Values

Exam Gotchas

1. PUT vs. PATCH: PUT replaces the entire resource; PATCH updates only specified fields — exam questions love this distinction
2. CI vs. CD confusion: CI = automatically building and testing; CD = automatically deploying — they are separate steps, not the same thing
3. Unit ≠ Integration testing: Unit tests are isolated (mocks/stubs used); integration tests use real connections between components — don't mix them up
4. Agile ≠ Scrum: Scrum is one framework within Agile; Agile is the broader philosophy — saying they're the same is wrong
5. Git rebase vs. merge: Merge preserves branch history; rebase rewrites history for a cleaner linear log — rebase should not be used on shared/public branches

Quick Summary

Software Development and Design on the DEVASC exam focuses on three core areas: design principles (MVC, SOLID, DRY — know what each separates or solves), testing strategy (

Key Points

• Software Architecture organizes components and their connections; good architecture aids communication, performance prediction, and onboarding
• Six key architecture characteristics to consider when designing: Performance, Availability, Modifiability, Testability, Usability, Security
• Design patterns are reusable solutions to common problems — not libraries, just concepts; language-agnostic

Layered Architecture Pattern

• Organizes application into distinct layers, each with a specific, isolated responsibility
• Most common implementation: 4 layers
• Presentation – UI communication, user input, formatting output
• Business – business rules, calculations, order/customer processing
• Persistence – handles data requests to/from the database layer
• Database – physical storage and retrieval; uses query languages like SQL
• Business + Persistence layers are sometimes combined → 3-tier architecture
• Separation of concerns = each layer only handles its own domain
• Layers communicate via well-defined APIs/interfaces → promotes loose coupling, high cohesion
• Layers can be open or closed (open = optional to pass through for certain requests)
• Monolithic by nature — easy to develop and test, but difficult to scale
• Changes to one layer should be made in isolation from other layers

Architecture Patterns (list to know)

• Layered / Multitier
• Event-driven
• Microservices
• Model-View-Controller (MVC)
• Space-based

Software Design Patterns

• Three categories:
• Creational – class/object creation (Singleton, Abstract Factory, Prototype, Factory Method)
• Structural – organizing larger structures (Adapter, Decorator, Facade, Proxy)
• Behavioral – interaction between components (Observer, Interpreter, Mediator, State)
• Based on Gang of Four (GoF) book: Design Patterns: Elements of Reusable Object-Oriented Software — authors: Gamma, Helm, Johnson, Vlissides
• Design patterns are described using: Intent, Motivation, Applicability, Structure (UML), Implementation/sample code

Singleton Pattern

• Ensures a class has only one instance with a global access point
• Use case: shared resources like a database connection
• Achieved by: private constructor + static method (get_instance()) that returns the existing instance
• In Python: __init__() checks if instance exists → raises error if it does; access via get_instance()
• Avoids global variables while protecting shared resources from being overwritten

UML (Unified Modeling Language)

• Graphical notation for describing software design, especially object-oriented systems
• Used for: documentation, pre-coding design ("sketching"), and reverse-engineering existing systems
• Class inheritance shown with a solid line with an arrow
• Provides high-level abstraction independent of programming language

Commands / Values

• Python Singleton: __init__() raises error if instance exists; use get_instance() to retrieve instance
• SQL mentioned as the query language used by the Database Layer
• UML: solid line + arrow = class inheritance

Exam Watch-outs

• ⚠️ 3-tier vs 4-tier: The business and persistence layers are sometimes combined into one → results in a 3-tier architecture. Don't assume it's always 4 layers
• ⚠️ Design patterns ≠ libraries: They are concepts/templates, NOT importable code libraries
• ⚠️ Layered ≠ Microservices: Layered architecture is monolithic and hard to scale; microservices architecture is better for scaling — these are contrasted frequently
• ⚠️ Singleton constructor is private: In exam scenarios, if asked how Singleton prevents multiple instances, the answer is the private constructor + static get_instance() method, not just "using a global variable"
• ⚠️ Open vs Closed layers: A closed layer must be passed through; an open layer can be bypassed — easy to get these definitions reversed
• ⚠️ GoF = Gang of Four: Know the four authors and the book title — could appear as