La génération automatique d'applications recouvre l'ensemble des concepts, techniques et outils du développement logiciel visant à produire le code d'une application sans avoir à le faire écrire directement par des développeurs. C'est en informatique une pratique transparente dès lors qu'un compilateur transforme du code C, Java ou autre en code binaire ou code interprétable par un browser Internet, un système d'exploitation ou encore une machine.

La génération automatique d'applications a évolué vers les phases hautes du processus de développement logiciel pour, dès en amont, transformer les besoins exprimés en langage naturel en artefacts logiciels.
Les usages les plus marqués sont le dessin d'interfaces utilisateur via les environnements de développements intégrés (IDE ou Integrated Development Environment en anglais) capables de produire le code construisant mais surtout contrôlant ces interfaces utilisateur dans les applications déployées.
Cette approche est pour l'essentiel à l'origine de l'acronyme RAD (Rapid Application Development) .

La génération automatique d'applications a cette vocation forte de délivrer au client, un produit qu'il a commandé dans un cycle de production qui se doit d'être compatible au marché (time-to-market delivery).
Cette livraison accélérée d'une application même si elle est incomplète en fonctionnalités (maquette ou prototype) permet de procéder au plus vite à sa validation, son appréciation et à toute reconsidération, jugée et prouvée plus coûteuse si cette dernière s'opère à la fin du développement.
L'autre objectif visé est l'affranchissement de contraintes techniques qui parasitent le recueil des besoins. Peu importe en effet de coder les interfaces utilisateur d'une manière ou d'autre pourvu que l'utilisateur futur, à travers ce qu'il voit et manipule, soit conforté au plus tôt dans ses choix.

Il serait réducteur de cantonner la génération automatique d'applications au RAD et aux interfaces utilisateur.
Il faut aussi évoquer les ateliers de génie logiciel (usine à logiciels est aujourd'hui un terme plus consacré). Par des formalismes graphiques le plus souvent (Merise, UML...), ils formatent des besoins pour les transformer, plus ou moins automatiquement, en applications conséquentes où de nombreux problèmes sont pris en charge de façon assistée et guidée :

• configuration,
• gestion de versions,
• gestion de plates-formes de déploiement,
• interfaces avec systèmes legacy...

Une telle démarche est aujourd'hui assimilée aux acronymes MDA/MDE/MDD (Model-Driven Architecture/Engineering/Development). Elle cible le développement coordonné de tous les sous-systèmes (au-delà de l'interface homme/machine en particulier) qui constitueront l'application à construire, à packager puis à déployer.
L'approche par les modèles ne voit le code écrit que comme un modèle de nature opérationnelle (Platform-Specific Model). Ceci par opposition à des modèles plus indépendants de la technique sous-jacente mais fortement en ligne avec les besoins (Platform-Independent Model).
En pratique donc, quoi de plus intéressant et efficace que la possibilité d'exprimer un modèle de données et ses contraintes de façon graphique ? On occulte ainsi, provisoirement en tout cas, le langage d'implantation :

• SQL92,
• SQL99
• toute variante de tels langages pour un SGBD donné,
• pire, pour une version particulière de ce SGBD.

Peut-on supprimer les développeurs ?

Le verrou technologique de la génération automatique d'applications est l'intelligence du processus de transformation de modèles en d'autres modèles, cela jusqu'au code.
Dans quelle mesure la créativité peut passer des mains des ingénieurs logiciel, développeurs aux outils de génération sans que l'application produite soit « hors sujet ». Les déboires sont le plus souvent liés à la génération de « choses » dont le coût de retouche peut devenir plus élevé que si ces choses avaient été faites directement « à la main ». Le MDA (MDE, MDD) propose une forte ouverture (un paramétrage poussé) des mécanismes de transformation de modèles de manière à rendre la génération adaptée au client, mais les connaissances requises pour de telles manipulations sont pointues. En résumé, la génération automatique d'applications reste une technologie sophistiquée même si dans l'esprit elle a pour but principal de simplifier les développements.

La génération automatique d'applications, l'approche par les modèles disciplinent le développement logiciel pour le faire réellement passer à une ère industrielle au même titre que l'on produit des automobiles par exemple, avec des phases d'études CAO (dessin industriel et Conception Assistée par Ordinateur) critiques et essentielles pour la qualité des produits, une rationalisation des composants, des techniques d'assemblage complexes et grandement réactives aux besoins des marchés.
La génération automatique d'applications, l'approche par les modèles préfigurent donc les futures usines à logiciels imposées par l'éclatement géographique des développements, le offshoring, chacun imposant les modèles comme des moyens pour communiquer puis pour intégrer face à la primauté croissante des architectures distribuées de type SOA et composants (J2EE, .Net (DotNet)).
Paradoxalement, le degré d'automatisation « intelligente » grandissant, l'externalisation et la sous-traitance des développements peuvent diminuer au profit de « générations 100% » où la richesse des modèles suffit à l'obtention d'applications complètes, un challenge en perspective pour l'offre en matière de génération automatique d'applications.

Ce livre s'adresse aux ingénieurs logiciel, développeurs, architectes et chefs de projet ainsi qu'aux étudiants d'écoles d'ingénieurs et masters informatiques. Il traite du nouveau paradigme informatique MDE (Model-Driven Engineering) ou " ingénierie des modèles " qui est intimement lié au standard international UML 2 (Unified Modeling Language). 
- La première partie revient sur la technologie des objets en général, et notamment sur le lien entre la modélisation orientée objet et la programmation orientée objet. Elle est illustrée de nombreux exemples de code et d'une étude de cas concise en C ++. 
- La deuxième partie est une présentation approfondie d'UML 2, et notamment de toutes ses différences et ses avancées en regard d'UML 1.x. 
- La dernière partie comporte trois études de cas implantées en totalité. 
UML 2 et MDE Dunod - novembre 2005