Génie logiciel avancée
Aperçu des sections
-
-
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
-
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
-
-
-
-
-
-
-
-
-
-
-
-