Topic outline

  • Announcements & Discussions

    Collapse all Expand all

  • Course Presentation

    The primary learning objective of this course is to equip students with advanced software engineering principles and modern practices, enabling them to effectively design, develop, and maintain large-scale, robust, and scalable software systems.

    This section presents a detailed description for this course.

    • Learning Objectives

      Upon successful completion of this course, students will be able to:
      • Review and utilize the Unified Modeling Language (UML) for effective software system specification, visualization, and documentation.
      • Compare and contrast foundational software engineering processes (e.g., Agile, Waterfall) to select appropriate lifecycle management approaches.
      • Apply fundamental design principles (SOLID, KISS, DRY, YAGNI) to write clean, maintainable, and extensible code.
      • Analyze design problems and implement appropriate (some of) Gang of Four (GoF) design patterns to create flexible and reusable solutions.
      • Discover the concepts of Object-Relational Mapping (ORM) and implement data persistence solutions using the Java Persistence API (JPA).
      • Investigate and apply the strategic principles of Domain-Driven Design (DDD) to model complex business domains and align software with business logic.
      • Discover the Test-Driven Development (TDD) methodology to write high-quality, verified code and drive robust software design.
      • Utilize Model-Driven Engineering (MDE) techniques to create and leverage models as primary artifacts for system analysis and automated code generation.

    • Course Summary

      Mindmap of the course

  • Chapter 01 : Reminder

    This chapter serves as a crucial review of the foundational concepts you will need for this course. We will revisit the Unified Modeling Language (UML) as the standard for visualizing and documenting systems, and review common Software Engineering Processes (like Agile and Waterfall) that structure the development lifecycle.

    Learning Objective: 

    The goal is to refresh and solidify your understanding of these core principles to ensure you have a strong base for tackling the advanced topics ahead.


  • Chapter 02 : Clean Code

    This chapter introduces the core principles of professional software development essential for writing clean, high-quality code. We will explore a set of fundamental guidelines—SOLID, KISS (Keep It Simple, Stupid), DRY (Don't Repeat Yourself), and YAGNI (You Ain't Gonna Need It)—that are critical for building software that is maintainable, scalable, and easy to understand.

    Learning Objective: 

    The objective is to enable students to analyze code quality and apply these design principles to write (and refactor) software that is robust, flexible, and resistant to technical debt.


  • Chapter 03 : Design Patterns

    This chapter moves from foundational principles to proven, reusable solutions for common software design problems. We will explore key Design Patterns, such as those cataloged by the "Gang of Four" (GoF). These patterns provide established, well-tested templates for solving recurring structural (e.g., Adapter, Decorator), creational (e.g., Singleton, Factory), and behavioral (e.g., Observer, Strategy) challenges in object-oriented design.

    Learning Objective: 

    The objective is to equip students with the ability to recognize common design challenges, select the most appropriate design pattern, and implement it effectively to create more flexible, reusable, and elegant software systems.


  • Chapter 04 : JPA/ORM Design Patterns

    This presentation introduces the principles of Object–Relational Mapping (ORM) using Java Persistence API (JPA), focusing on design patterns that address the impedance mismatch between object-oriented models and relational databases. It covers entity modeling, relationships, inheritance strategies, and common ORM patterns such as Data Mapper, Repository, and Unit of Work.

  • Chapter 05 : Test Driven Development

    This presentation presents Test-Driven Development (TDD) as a disciplined software development practice that emphasizes writing automated tests before production code. It explains the Red–Green–Refactor cycle, the role of unit tests in design, and the impact of TDD on code quality, maintainability, and architectural decisions.

  • Chapter 06 : Model Driven Engineering

    This course introduces Model-Driven Engineering (MDE) as a modern software engineering paradigm that places models at the center of system development. It covers the fundamentals of modeling, metamodeling, and the MOF-based four-layer architecture (M3–M0), with concrete illustrations using UML, SysML, and Entity–Relationship models. Students will learn how models conform to metamodels, how metamodels are defined using MOF, and how model-to-model transformations (e.g., UML Class Diagrams to ER Diagrams) are specified at the meta-level.

  • Advanced Software Engineering Exam

  • Topic 9

  • Topic 10

  • Topic 11

  • Topic 12

  • Topic 13

  • Topic 14

  • Topic 15

  • Topic 16

  • Topic 17

  • Topic 18

  • Topic 19

  • Topic 20

  • Topic 21