WikiAdmin : 1 version importée : dfg

2026-07-24T17:08:26Z

1 version importée : dfg

← Version précédente	Version du 24 juillet 2026 à 17:08
(Aucune différence)

toross>WikiAdmin : /* Exemple plus complexe */

2024-02-15T22:46:27Z

Exemple plus complexe

Nouvelle page

{{IntroductionDFG}}
== Introduction ==
{{parW|1=
L'informatique met à notre disposition des outils nous permettant d'éviter des tâches répétitives et ennuyeuses. Souvent, on devient informaticien car on veut éviter tout travail répétitif. Le développeur, déjà un informaticien, lui aussi veut éviter la programmation répétitive. Data Flow Generator est un outil parmi d'autres, que tout développeur finit par écrire car il est aussi un informaticien.
}}
=== Une méthodologie plus qu'un outil ===
{{parW|1=
Ces outils, tels que Data Flow Generator, qui aident à se passer du travail répétitif, finissent par s'intégrer dans une méthodologie de développement. En général un développeur commence à écrire son code avant même d'avoir réfléchi aux données que le programme va utiliser, à la structure des données, et pourquoi pas à la structure du programme même, qui lui aussi peut être pensé comme
une entité qui s'articulerait autour d'une architecture.
}}{{parW|1=
La réflexion fut longue et axée principalement sur trois branches : la spécialisation des logiciels (bases de données, middle-wares, etc.) et la spécialisation des outils de développement (langages, modélisation, etc.) et la thésaurisation de l'expérience.
}}
==== Les données et les programmes ====
{{parW|1=
Au fil des années, des logiciels se sont spécialisés dans le stockage et l'accès aux données (bases de données) ou dans le traitement de ces données, qui sont souvent des logiciels spécifiques à des besoins particuliers ou alors ces programmes sont mis dans des libraires quand ils sont réutilisables. Le langage {{m|SQL}} a été mis au point interroger ces bases de données, c'est un langage qui permet d'éviter de se préoccuper des problèmes que gèrent les base de données.
}}
==== Les langages de programmation et la modélisation ====
{{parW|1=
En même temps, des langages de programmation se sont crées pour faciliter le travail du programmeur tout en évitant les taches répétitives. Chaque langage a ses qualités et ses défauts, nous dirons que chacun est optimal pour un ensemble de besoins donnés et chaque langage continue d'évoluer en intégrant de nouveaux concepts innovants.
}}{{parW|1=
La programmation orientée objet ({{m|POO}}) fut une étape importante pour commencer à modéliser la structure des données dans le code du programme même. La modélisation MERISE qui était utilisée pour modéliser les données dans les bases de données relationnelles finit par être remplacée par UML ; le diagramme de classe d'UML est un bon outil pour modéliser les classes dans langages orientées objet. C'est cette modélisation qui sera utilisée dans Data Flow Generator.
}}
==== Le design pattern ====
{{parW|1=
En parallèle à toutes ces innovations, le non concepteur d'outil de développement, les utilisateurs de ces outils continuaient et continue de réfléchir.
Le développeur expérimenté finit par décrire ou définir des modèles ou ce qu'on appelle des {{m|patrons}} ou en anglais (pattern). Ces longues réflexions basées sur l'expérience à conduit à l'établissement du {{m|design pattern}}.
}}
=== Pourquoi générer du code ; le développement piloté par les modèles (model-driven development) ===
{{parW|1=
Toutes ces améliorations dans le monde du développement de logiciels se retrouvent forcément dans le développement piloté par les modèles ({{m|model-driven development}}).
}}{{parW|1=
Vous trouverez facilement de la documentation sur les avantages et les inconvénients du développement piloté par les modèles, qui est encore mal connu par bon nombre de développeurs.
}}{{parW|1=
Le développement de DataFlowGenerator a été fortement inspiré, d'une manière très simplifiée, du projet {{m|FAROS}}. C'est une façon simple d'illustrer, ces méthodes; le développement piloté par les modèles ({{m|Model driven architecture}} ou {{m|model-driven development}}).
}}{{parW|1=
Le projet FAROS a déjà écrit l'état de l'art sur cette question, si vous voulez en savoir plus consultez le chapitre 5 du document [http://www2.lifl.fr/faros/pub/uploads/Main/RNTL-FAROS-F1-1.pdf Etat de l’art sur la contractualisation et la composition]
}}{{parW|1=
Le site du projet FAROS : [http://www2.lifl.fr/faros/Main/HomePage www2.lifl.fr/faros]
}}{{parW|1=
Mais retenez que cette méthodologie permet de se concentrer ce qui est essentiel, ce qui rend le nécessité de faire le développement, mis sous forme minimale, sous forme plus accessible à l'analyse et à la conception, et surtout la charge de la maintenance du code est forcément très réduits car l'action des corrections et des évolutions se limitent à une quantité d'information la plus minimale qui aussi limite les erreurs de propagation de la même information.
}}

=== La place de Data Flow Generator dans tout ça ===
{{parW|1=
Data Flow Generator est un outil de développement, qui à partir d'un modèle (développement piloté par les modèles), génère du code qui permet de construire une structure de données en mémoire vive et la même structure de données sous forme persistante ou sérialisée. Il ne génère pas seulement du code déclarative comme certains éditeurs d'UML, mais aussi il génère un minimum de code pour manipuler ces données (copie, extraction, création, lecture, écriture, vérification de cardinalité, interception, etc.).
}}{{parW|1=
Pour l'instant il génére du code en c++ et python. La forme persistante actuelle utilise le format {{m|XML}} ; en c++ la librairie {{m|XERCES}} est utilisée et en python le module {{m|xml.dom.minidom}}
}}{{parW|1=
Il permet aussi de garder la cohérence entre le modèle et le code en cours de développement. En effet le modèle peut être modifié et le code régénéré sans gêner le développement manuel (classique) des traitements autour de ces données ainsi restructurées.
}}{{parW|1=
Cet outil a été développé en ayant à l'esprit rois exigences essentielles :

*'''Synchronisation permanente entre le modèle et le code'''
:La structure des données intrinsèquement définit par le code doit être exactement la structure définit par le modèle.
*'''Le passage immédiat en développement manuel (classique)'''
:Le code généré doit ressembler à un code développé manuellement afin que celui-ci puisse être reprise.
*'''Pas de pollutions avec le code généré (séparation entre code généré et code écrit)'''
:Le code généré ne doit pas être mélangé dans le code écrit manuellement (les fichiers sont bien séparés).
}}
==== Schema ====
{{parW|1=
A ma connaissance il n'existe pas d'outil en open source équivalent à Data Flow Generator pour générer du c++. Pour le monde java il en existe sûrement.
La grammaire utilisée pour modéliser est une forme personnalisée très simplifiée et limité de {{m|Schema}} voir http://www.w3.org/XML/Schema et http://fr.wikipedia.org/wiki/XML_Schema.
}}{{parW|1=
Vous pouvez consulter ces sites pour trouver d' éventuels outils pour générer du c++.
}}
==== Utilitié et liens ====
{{parW|1=
Pour ceux qui développent en C++, Python et veulent sérialiser leurs données sous format XML (et peut être bientôt sous HDF) ou tout simplement pour tout ceux qui veulent développer en C++ et Python et veulent avoir rapidement un ensemble de classes prêt à l'emploi en mémoire interne, cet outil peut dans la plupart des cas vous générer le code pour vous. Il n'y pas de rupture entre le modèle et le code généré; le modèle reflétera toujours la structure des données (Le modèle commande le code !).
}}{{parW|1=
Vous pouvez utiliser DataFlowGenerator en ligne sur : http://dfg.bht-diffusion.com
}}{{parW|1=
Le manuel de référence, qui est souvent difficile à digérer, se trouve sur [http://wiki.bht-diffusion.com/index.php/Manuel_de_r%C3%A9f%C3%A9rence_de_la_grammaire_de_Data_Flow_Generator manuel de référence sur wiki.bht-diffusion.com]
}}

=== La structure des données est arborescente ===
{{parW|1=
Les données en général sont structurées en arborescente. Par exemple le système de fichiers des système LINUX est arborescent avec une racine unique. Pour représenter des graphies il faut faire toucher certains feuilles de l'arbre par des liens.
}}{{parW|1=
Les modèles de Data Flow generator modélisent des données ayant une structures arborescentes à racine unique. Le modèle ne permet pas de définir des liens entre les feuilles. S'il faut décrire de graphes c'est l'utilisateur du code généré qui doit définir ces liens.
}}

== Où trouver l'outil ==
{{parW|1=
L'outil est utilisable en ligne sur Internet à l'adresse http://dfg.bht.fr .
}}

== Le work flow ==
{{parW|1=
Le work flow est assez simple. Le modèle est définit dans un fichier au format XML. Ce fichier sert d'entrée à {{m|DFG}} (Data Flow Generator). Suivant le langage choisi DFG contient des modèles applicatifs ou des sortes de patron de codes. A partir de ces données DFG génère le code permettant de travailler avec la structure de ces données défini par le modèle.
}}{{parW|1=
{{c| {{figc|Le work flow de Data Flow Generator|DataFlowGenerator_data_flow.png|ref1|10cm}} }}
}}{{parW|1=
Le work flow suivant montre les évolutions possibles pour étendre la liste des formats de bas niveau des fichiers de sérialisation (cadres en pointillés).
}}{{parW|1=
{{c| {{figc|Le work flow des évolutions possibles de Data Flow Generator|DataFlowGenerator_data_flow_evol.png|ref2|10cm}} }}
}}

== La modèlisation des données ==
{{parW|1=
La grammaire de la modélisation est définie entièrement dans [[Manuel de référence de la grammaire de Data Flow Generator]].
}}{{parW|1=
Mais prenons un exemple sous sa forme la plus simple pour être comprise de façon intuitive :
}}
=== Exemple simple ===
{{parW|1=
<source lang="text">

. tuto_001 : grammar from "tuto_001.xml" type="xml" version="1.0.0"
FileFormatVersion="1.0.0"
. . entreprise:CEntreprise
. . . red:CRed
. . . . departement:CDepartement cardinality="+"
. . . . . nom:string /
. . . . . agents:CAgent cardinality="*"
. . . . . . prenom:string /
. . . . . . nom:string /
. . . . . . fonction:string /
</source>
}}{{parW|1=
Ce modèle dit que l'enreprise possède un R&D. la R&D possède plus d'un département. Chaque département a un nom et possède des agents (de 0 à l'infini). Chaque agent possède un prénom, nom et fonction.
}}{{parW|1=
L'équivalent de ce modèle dans la grammaire de Data Flow Generator est le suivant :
<source lang="xml">
<?xml version="1.0" encoding="UTF8"?>
<grammar type="xml" version="1.0.0" FileFormatVersion="1.0.0">
<el name="entreprise" type='CEntreprise' >
<el name="red" type='CRed' >
<el name="departement" type='CDepartement' cardinality="1:*">
<el name="nom" type='string'/>
<el name="agents" type='CAgent' cardinality="*">
<el name="prenom" type='string'/>
<el name="nom" type='string'/>
<el name="fonction" type='string'/>
</el>
</el>
</el>
</el>
</grammar>
</source>
}}{{parW|1=
Le diagramme UML équivalent est le suivant :
{{c|
<uml>
class CEntreprise {
}
CEntreprise *--> "1" CRed : red
CRed *--> "+" CDepartement : departement
CDepartement : string nom
CDepartement *--> "*" CAgent : agents
CAgent : string prenom
CAgent : string nom
CAgent : string fonction
hide empty methods
hide empty fields
</uml>
}}
}}

=== Exemple plus complexe ===
{{parW|1=
<source lang="text">

. tuto_002 : grammar from "tuto_002.xml" type="xml" version="1.0.0" FileFormatVersion="1.0.0"
. . dessin:CDessin
. . . base:CBase OnlyDefinition="1"
. . . point:CPoint heritances="CBase" OnlyDefinition="1"
. . . . x:float /
. . . . y:float /
. . . segment:CSegment heritances="CBase" OnlyDefinition="1"
. . . . A:@CPoint
. . . . B:@CPoint
. . . cercle:CCercle heritances="CBase" OnlyDefinition="1"
. . . . C:@CPoint
. . . . R:float /
. . . compound:CCompound cardinality="*" heritances="CBase"
. . . . elements:@CBase cardinality="*" accept="CPoint:CSegment:CCercle:CCompound"
</source>

Ce modèle décrit un dessin qui est formé d'une liste de forme géométriques combinées. Chacune de ces formes est faite par un ensemble de formes élementaires ou forme combinées.
}}{{parW|1=
L'équivalent de ce modèle dans la grammaire de Data Flow Generator est le suivant :
<source lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<grammar type="xml" version="1.0.0" FileFormatVersion="1.0.0">
<el name="dessin" type="CDessin">
<el name="base" type="CBase" OnlyDefinition="1">
</el>
<el name="point" type="CPoint" heritances="CBase" OnlyDefinition="1">
<el name="x" type="float"/>
<el name="y" type="float"/>
</el>
<el name="segment" type="CSegment" heritances="CBase" OnlyDefinition="1">
<el name="A" type="@CPoint"/>
<el name="B" type="@CPoint"/>
</el>
<el name="cercle" type="CCercle" heritances="CBase" OnlyDefinition="1">
<el name="C" type="@CPoint"/>
<el name="R" type="float"/>
</el>
<el name="compound" type="CCompound" cardinality="*" heritances="CBase">
<el name="elements" type="@CBase" cardinality="*"
accept="CPoint:CSegment:CCercle:CCompound"/>
</el>
</el>
</grammar>
</source>
}}{{parW|1=
Le diagramme UML équivalent est le suivant :
{{c|1=
<uml>
class CDessin {
}
CDessin *--> "1" CBase : base
CPoint --|> CBase
CPoint : float x
CPoint : float y
CSegment --|> CBase
CSegment *--> "1" CPoint : A
CSegment *--> "1" CPoint : B
CCercle --|> CBase
CCercle *--> "1" CPoint : C
CCercle : float R
CCompound --|> CBase
CCompound *--> "*" CBase : elements
hide empty methods
hide empty fields
</uml>
}}
}}{{parW|1=
Voici un exemple de forme persistante de données défini par le modèle :
<source lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<dessin DriverName="DataFlowGenerator_XML_DOM_MINIDOOM" DriverVersion="0.22.0" FileFormatVersion="1.0.0">
<compound>
<elements dfg_classname="CCercle">
<C>
<x>3.000000E+00</x>
<y>0.000000E+00</y>
</C>
<R>4.000000E+01</R>
</elements>
<elements dfg_classname="CSegment">
<A>
<x>5.000000E+00</x>
<y>6.000000E+00</y>
</A>
<B>
<x>1.000000E+00</x>
<y>-2.000000E+00</y>
</B>
</elements>
<elements dfg_classname="CCompound">
<elements dfg_classname="CCercle">
<C>
<x>7.000000E+00</x>
<y>0.000000E+00</y>
</C>
<R>3.000000E+01</R>
</elements>
<elements dfg_classname="CCompound">
<elements dfg_classname="CCercle">
<C>
<x>4.000000E+00</x>
<y>0.000000E+00</y>
</C>
<R>2.000000E+01</R>
</elements>
</elements>
</elements>
</compound>
<compound>
<elements dfg_classname="CCercle">
<C>
<x>4.000000E+00</x>
<y>0.000000E+00</y>
</C>
<R>2.000000E+01</R>
</elements>
</compound>
</dessin>
</source>
}}

== Exemple de développement en c++ sous LINUX ==
Voir [[Tutoriel de Data Flow_Generator#Tuto_002_:_D.C3.A9veloppement_en_c.2B.2B_sous_LINUX|Tutoriel de Data Flow_Generator]]

Manuel d'utilisation de Data Flow Generator V0 - Historique des versions

WikiAdmin : 1 version importée : dfg

toross>WikiAdmin : /* Exemple plus complexe */