Agilit{e} de d{e}veloppement des SI informatis{e}s et outils MDE : d{e}marche p{e}dagogique dans un cours de conception de syst{`e}mes dinformation informatis{e}s

In software development, business rules implemented by hand using programming code hinder agility of companies. Are our students in information systems aware of that? Do our lessons promote this realization ? We use model driven concepts (MDA, MDE) in order to demonstrate, with practical examples, that source code can be automatically generated as far as formal specification are sufficient and accurate. We have extended usual representation conventions of conceptual data modeling and developed a transformer tool. This make our students observing themselves that no source code need necessarily to be rewrite when a change of business rule occurs, but just an adaptation of the model and a new run of generation of code. In this way, they finally understand more easily the benefits of MDE tools.

💡 Research Summary

The paper addresses a fundamental problem in information systems education: students often implement business rules directly in source code, which mirrors the practice in many enterprises where hand‑coded rules hinder organizational agility. The authors ask whether students are aware of this issue and whether current curricula foster this awareness. To answer these questions, they adopt a model‑driven engineering (MDE) and model‑driven architecture (MDA) perspective, providing both a pedagogical framework and a concrete software tool that demonstrates automatic code generation from formal specifications.

The literature review first documents the historical rise and fall of CASE (Computer‑Aided Software Engineering) tools from the 1970s to the early 2000s. While those tools once offered substantial productivity gains—automatic generation of database schemas, integrity constraints, and application scaffolding—they have largely disappeared from the market. The authors attribute this disappearance to two main hypotheses: insufficient market penetration and a steep learning curve that prevented widespread adoption. They also illustrate, through real‑world anecdotes (e.g., a retail checkout system that could not apply a combined discount, a Swiss bank’s inflexible customer‑segmentation logic), how hard‑coded business rules create rigidity and impede rapid adaptation.

Building on this background, the authors design a two‑pronged educational intervention. The first component extends traditional conceptual data modeling notations (ER diagrams, Merise’s Modèle Conceptuel de Données) with UML profiles, stereotypes, and declarative constraints. This extension enables modelers to embed business rules directly into the model without translating them into imperative code. The second component is a custom transformation engine that consumes the enriched models and automatically produces SQL‑DDL scripts and table‑API code (e.g., frozen column constraints). The engine operates in an iterative, incremental fashion, aligning with agile development principles: each model change triggers a regeneration of the corresponding artefacts.

To evaluate the approach, the authors integrate it into an undergraduate information systems design course. Students are given two parallel assignments: one following the traditional “code‑first” method, and another using the model‑first, auto‑generation workflow. After modifying a business rule, students using the model‑first approach simply adjust the model and rerun the transformer, instantly obtaining updated source code. Surveys and performance metrics reveal that these students perceive a clear reduction in maintenance effort, a lower incidence of errors, and an enhanced understanding of data integrity enforcement at the design level. Moreover, the hands‑on experience makes the abstract benefits of MDE concrete, fostering a mindset that values model‑centric development for agility.

The paper concludes that the lack of modern CASE tools is not an insurmountable barrier; a purpose‑built, pedagogically oriented transformation pipeline can fill the gap. By coupling an extended modeling formalism with an automated code generator, educators can provide a seamless “model‑modify‑generate” loop that mirrors industrial model‑driven practices while remaining accessible to students. This approach not only improves learning outcomes but also prepares graduates to adopt model‑driven development in professional settings, thereby contributing to more agile, maintainable information systems. Future work is suggested to broaden the toolset to other domains (IoT, healthcare) and to collaborate with industry partners for real‑world project integration.