Software Engineering Fundamentals: Tools, Design, and SDLC

Posted on May 16, 2026 in Software Engineering

Week 2: Build Tools, Testing, and Maintainable Code

• Maven: Build automation tool for Java.
• Dependency: External library or project used by software.
• IDE: Integrated Development Environment.
• Coding Standards: Rules for consistent, readable code.
• Unit Testing: Testing small, isolated methods or components.
• Integration Testing: Testing components working together.
• System Testing: Testing the whole application.
• TDD: Write test → fail → write code → pass → refactor.
• Javadoc: Documentation generator for Java.
• Static Analysis: Analyzing code without running it.
• Checkstyle: Checks coding standard violations.
• SpotBugs: Finds potential bugs statically.
• CI: Continuous Integration (automatic build/testing).
• CD: Continuous Deployment/Delivery (automatic release).
• Code Review: Developers review code before merge.
• Maintainability: Easy to modify or fix later.
• Readability: Easy for humans to understand.
• Testability: Easy to test code or components.
• Automation: Tasks performed automatically.

Week 3–4: Licensing and Clean Code

• Copyright: Legal ownership protection for software.
• Proprietary License: Closed-source software.
• Open Source License: Source code freely viewable/modifiable.
• Copyleft License: Modified versions must remain open source.
• Permissive License: Few restrictions on reuse.
• Public-Domain-Equivalent: Almost no restrictions.
• Clean Code: Simple, understandable, maintainable code.
• Technical Debt: Future maintenance cost caused by poor code.
• Reusability: Code reused elsewhere.
• Consistency: Uniform coding style or behavior.
• Debugging: Finding and fixing software bugs.
• Code Quality: Overall standard of code or software.

Week 5: UML, Design Principles, and Spring

• UML: Visual modelling language.
• Class Diagram: Shows classes, attributes, methods, and relationships.
• Sequence Diagram: Shows interaction order between objects.
• Activity Diagram: Shows workflow or process flow.
• Attribute: Class data or fields.
• Operation: Class method or function.
• Visibility: + public, – private.
• Inheritance: Child class extends parent.
• Aggregation: Weak “has-a” relationship.
• Composition: Strong “has-a” relationship.
• Multiplicity: Relationship quantity (1 = one, * = many).
• DRY: Don’t Repeat Yourself.
• KISS: Keep It Short/Simple.
• YAGNI: Don’t build unnecessary features.
• SOLID: 5 object-oriented design principles (SRP, OCP, LSP, ISP, DIP).
• Dependency Injection: Dependencies supplied externally.
• DAO: Separates database access logic.
• ORM: Maps objects to database tables.
• MockMvc: Testing Spring MVC controllers.
• Loose Coupling: Minimal dependencies between components.
• High Cohesion: Focused responsibilities within a class.
• Separation of Concerns: Split responsibilities logically.
• Modularity: System split into independent modules.

Week 6–7: Design Patterns

• Design Pattern: Reusable solution to a common design problem.
• Singleton: Only one instance exists.
• Factory: Centralized object creation.
• Abstract Factory: Creates families of related objects.
• Builder: Constructs complex objects step-by-step.
• Observer: One object notifies subscribers.
• State Pattern: Object behavior changes by state.
• Visitor: Separates operations from object structure.
• Facade: Simplified interface hiding complexity.
• Adapter: Makes incompatible interfaces work together.
• Bridge: Separates abstraction from implementation.
• MVC: Model-View-Controller architecture.
• Flexibility: Easy to adapt or change.
• Extensibility: Easy to add features.
• Abstraction: Hide unnecessary complexity.
• Encapsulation: Hide internal state or details.
• Scalability: System handles growth effectively.

Week 8: Refactoring and Code Smells

• Refactoring: Improving internal code without changing behavior.
• Extract Method: Move repeated logic into a separate method.
• Extract Class: Split overloaded class responsibilities.
• Replace Magic Number: Replace hardcoded values with constants.
• Simplifying Conditionals: Reduce complex if-else logic.
• Generalization: Share common behavior in a parent class.
• Code Smell: Sign of poor design or code quality.
• Bloater: Class or method is too large.
• Long Method: Method doing too much.
• Primitive Obsession: Using primitives instead of objects.
• Magic Number: Unexplained hardcoded number.
• Long Parameter List: Too many method parameters.
• Data Clumps: Same data repeatedly grouped together.
• Dead Code: Unused or unreachable code.
• Duplicate Code: Same code repeated.
• Feature Envy: Method overuses another class.
• Message Chains: Long object call chains.

Week 9: SDLC, Agile, and Scrum

• Waterfall: Linear sequential development model.
• Spiral Model: Iterative model focused on risk management.
• Agile: Iterative, flexible development approach.
• Scrum: Agile framework using sprints.
• Product Owner: Manages product backlog and priorities.
• Scrum Master: Facilitates the Scrum process.
• User Story: Feature description from a user perspective.
• Sprint: Short development iteration.
• Timeboxed: Fixed maximum duration activity.
• Retrospective: Meeting reviewing sprint improvements.
• Kanban: Visual workflow or task management system.
• Extreme Programming (XP): Agile method emphasizing testing and collaboration.

Week 10: Metrics, Coverage, and CFG

• Control Flow Graph (CFG): Graph showing execution flow.
• Cyclomatic Complexity: Number of independent execution paths (Formula: Decisions + 1).
• Statement Coverage: Percentage of executed statements.
• Branch Coverage: Tests true/false branches.
• Condition Coverage: Each condition tested as true and false.
• Complexity: Higher complexity equals harder testing and maintenance.
• Test Coverage: How much code was tested.
• Robustness: Handles errors safely.
• Early Bug Detection: Finding bugs early through testing.