SWE Foundations
What is the primary goal of software engineering?
To systematically build reliable, maintainable, and efficient software using engineering principles.
What is modularity?
Breaking a system into independent, cohesive modules that are easier to understand, maintain, and reuse.
Purpose of software testing
To find defects and ensure the system meets requirements and behaves correctly.
CRUD
Create, Read, Update, Delete
What is a DBMS?
Software that manages databases and provides tools for storing, retrieving, and manipulating data.
Programming is writing code; software engineering is the full process of designing, building, testing, deploying, and maintaining software.
What makes architecture "good"?
Low coupling, high cohesion, scalability, maintainability, clear separation of concerns, and alignment with requirements.
Verification vs validation
- Verification: "Are we building the product right?" (meets specs)
- Validation: "Are we building the right product?" (meets user needs)
Single Responsibility Principle
A class/module should have one reason to change - one focused responsibility
Primary key vs foreign key
Primary key: Unique identifier for a row
Foreign key: References a primary key in another table to create relationships
Three major SDLC activities
Requirements, Design, Implementation, Testing, Deployment, Maintenance
Describe MVC
- Model: Data + business logic
- View: UI representation
- Controller: Handles input and updates Model/View
Two types of tests
- Unit testing: Tests individual functions/classes
- Integration testing: Tests interactions between components
- System testing: Tests the whole system
- Acceptance testing: Ensures readiness for users
- Manual testing: Human-driven testing
Inheritance vs. composition:
- Inheritance: "Is-a" relationship; class extends another
- Composition: "Has-a" relationship; class contains other objects. Preferred for flexibility
SQL SELECT Statement
SELECT * FROM table_name
Functional vs non-functional requirements
Functional: What the system must do (features, behaviors)
Non-functional: How the system performs (performance, security, usability, reliability)
Layered vs microservices architecture
- Layered: Organized into layers (UI -> Logic -> Data). Centralized, easier to manage, but less flexible
- Microservices: Independent services communicating via APIs. Highly scalable and deployable but more complex.
The cost of taking shortcuts now that must be “paid back” later through refactoring or fixes. Poor testing increases technical debt.
Polymorphism
Objects of different types can be treated through a common interface, enabling different behaviors with the same method call.
What is an API and why use it?
An API is an interface that allows software systems to communicate. Developers use APIs to reuse functionality, integrate services, and avoid reinventing features.
WRSPM Model
- World: The real-world environment/problem
- Requirements: What the system must achieve in the world
- Specification: Formal description of system behavior
- Program: The actual code implementation
- Machine: Hardware/software platform the program runs on.
Intellectual Distance
The gap between what a developer wants to express and how they must express it in code.
Why can software never be bug-free?
- Software complexity makes exhaustive testing impossible
- Requirements change over time
- Interactions with environments/platforms are unpredictable
Deployment is a mix of what?
Deployment requires:
- Implementation (building, packaging, configuring)
- Testing (verifying in staging/production environments)
Git vs GitHub + staging area
Git: Local version control system
GitHub: Cloud hosting for Git repositories
Staging area: Where changes go after git add and before committing; a preview of what will be included in the next commit