)
<\/a><\/div>\n\n Vous commencez par définir un environnement de travail c\'est à dire, vos bases de données (champs, tables, index, liens entre les données ...) et d\'autres caractéristiques (constantes , droits des utilisateurs, menus ...).
\nCliquez et regardez l\'image pendant 5 secondes, pas plus.<\/span> Utilisez le bouton en haut de la nouvelle fenêtre pour la fermer.\n
\n
\nGlobalement vous avez vu des boites (les informations) et des flèches qui les relient (les interconnexions entre les informations). \n
\n
\nCa devenait compliqué car les informations et les interconnexions à gérer étaient si nombreuses que je ne parvenais plus à intégrer toutes les contraintes fonctionnelles ou techniques liées à ce genre de modèle.\n
\n
\nDans ce cas, on appelle des collègues et on fait de gros projets qui prennent du temps à mettre en place et qui finalement ne satisfont pas toujours les utilisateurs. \n<\/p>');
t.xxtree214.add(218,214,'... on trouve des solutions ...','Mais, ils en veulent plus les utilisateurs car ils ont des clients qui menacent en permanence d\'aller voir la concurrence si on ne peut pas fournir une nouvelle fonction stratégique généralement pour hier. \n
\n
\nDans ce cas, on fait de la maintenance, et là, ça devient vraiment difficile car, comprendre ce que le concepteur a bien voulu comprendre, reprendre ce que le programmeur a bien voulu programmer et assurer à l\'utilisateur que ce sera fait dans x jours pour un coût modeste de y jours/hommes, a toujours été, pour moi, une tâche qui oscillait entre un domaine probabiliste (ça devrait passer) et un domaine quasi mystique (pourvu que ça marche !). \n
\n
\nDonc, comme je n\'aimais pas cette situation, je me suis mis à développer un outil pour me faciliter la tâche. \n
\n
\nAu fur et à mesure de mes développements, je m\'apercevais que je me dirigeai tout droit et à grande vitesse dans un mur car ça devenais encore trop compliqué. Il fallait que je trouve un moyen pour pouvoir avancer dans les développements sans prendre le risque de faire croitre le nombre de bugs de façon exponentielle. \n
\n
\nJ\'en suis venu à la conclusion qu\'il fallait industrialiser<\/span> les développements et pour ce faire, il fallait que la conception et l\'écriture des programmes puisse être elle même industrialisée. \n
\nEt pour ce faire, j\'en suis venu à la deuxième conclusion que les programmes devaient pouvoir être analysés et modifiés par leurs propres moyens.<\/span> \n
\n
\nMais il fallait trouver le moyen de mettre en place toutes ces idées. \n');
t.xxtree214.add(278,214,'... on les construit ...','J\'ai donc fabriqué MyPitSelf . Le reverse-engineering étant assuré et le premier programme fabriqué avec MyPitSelf étant MyPitSelf lui même, je pense que les fondations ne sont pas trop mauvaises.\n
\n
\nUn jour, j\'ai demandé à un professeur de philosophie des sciences et d\'histoire des sciences où était la limite de mon système. Il m\'a répondu par la citation écrite plus haut à propos des Systèmes récursifs et de leur évolution illimité. \n
\nEn un mot, seul un environnement de développement ayant comme principale caractéristique la rétro-analyse permet de faire croitre et évoluer des applications sans risquer de tout devoir reconstruire à chaque fois.\n
\n
\nJe vous laisse tirer vos propres conclusions sur les outils de développement de systèmes d\'informations qui n\'offrent pas cette caractéristique.\n
\n
\nEn fait, la limite du système est imposée par des caractéristiques physiques des ordinateurs tels que la mémoire disponible, le temps d\'exécution acceptable, etc... Mais au moins, \non peut avancer, les limites fonctionnelles sont beaucoup plus loin maintenant.\n');
t.xxtree214.add(219,214,'... et on en parle !','J\'ai déjà utilisé MyPitSelf pour faire des programmes dans des situations réelles ( avec des utilisateurs autres que moi-même ) avec des modèles de données qui ressemblent à ça \n
\n<\/a> \n<\/a> \n<\/a> \n<\/a> \n<\/a>.\n
\nDes applications simples peuvent rapidement être mises en place une fois qu\'on est familiarisé avec l\'environnement de développement, mais ce n\'est pas si évident que ça car c\'est différent de ce que je connais de plus classique (vous êtes prévenus). \n
\nEn revanche, les programmes générés ont une forme classique.\n
\n
\nDes exemples simples de développement sont donnés plus bas\n
\nMais on peut aussi faire du compliqué, exemple: MyPitSelf n\'est pas un modèle de simplicité fonctionnelle, c\'est un environnement de développement prenant en charge le multi utilisateur et les autorisations gérées par groupes d\'utilisateurs, le multilangue, le multibase, des environnements multiples, des sauvegardes, la documentation avec des copies d\'écrans, etc ..... \n
\nLe modèle de données que vous avez vu plus haut pendant 5 secondes est celui de MyPitSelf. Ces images de modèles de données sont des copies d\'écran de schémas SVG. Grâce à ce SVG, on peut graphiquement spécifier les liens entre les tables. \n
\n
\nJ\'ai commencé à utiliser la rétro analyse pour maintenir MyPitSelf : par exemple, j\'avais défini une utilisation pas très propre d\'une fonction et je voulais modifier tout le code pour changer ça, comme j\'utilisais énormément cette fonction, j\'ai écrit une moulinette en langage MyPitSelf qui le faisait à ma place: MyPitSelf maintient MyPitSelf !. Comme cette moulinette a déjà été écrite, si je dois faire une modification sur un autre fonction, ce ne sera pas vraiment compliqué de la modifier. \n
\nCertaines personnes appellent ça le "refactoring".\n
\n
\nUn autre exemple d\'utilisation se produit quand on renomme un champ ou une table de la base de donnée. Dans ce cas, toutes les sources utilisant ce champ ou cette table sont traitées pour remplacer l\'ancien nom par le nouveau.\n
\n
\nLa suite du site est plus technique car j\'explique un peu comment tout ça fonctionne . C\'est en fait une extraction de la documentation du logiciel. Ces explications font croire que j\'ai tout d\'abord réfléchi pour faire ensuite: en fait, dans toute ma démarche, l\'action a précèdé la réflexion, je n\'ai pas honte de l\'avouer car je préfère un outil qui marche à un concept qui ne marche pas.\n
\n
\nL\'important est de pouvoir corriger ce qui ne va pas et ce n\'est plus qu\'une question de temps.\n
\nCela revient à revendiquer le droit à "l\'erreur" à condition que l\'on mette en place les moyens de corriger ces "erreurs". Le principe même de l\'outil est d\'une grande aide !\n
\n
\nIl y a encore du travail à faire, certaines parties ne sont pas encore très pures, mais maintenant, je n\'ai plus peur de nettoyer, je sais que ça ne deviendra pas un truc inmaintenable et que je pourrais capitaliser<\/span>. \n
\n
\nEn fait, en ce moment, je mets en place l\'environnement pour travailler avec ajax<\/span>, vous verrez mes premier essais ici<\/a>.\n
\n
\nMaintenant, au travail ! \n
\n
\nLe nom MyPitSelf vient de My<\/span>Sql, P<\/span>hp et Itself<\/span>\n\n');
t.xxtree214.add(220,214,'Comment ?','');
t.xxtree214.add(222,220,'Le noyau','<\/a>\n\n<\/div>\n\nUne partie du noyau est écrite directement en php, le reste est écrit en langage MyPitSelf. \n
\nLes programmes que vous concevez sont écrits en langage MyPitSelf. \nIls utilisent le même modèle que le programme MyPitSelf lui même avec en particulier : \n
\n
\n- Une base de données système contenant la description des données et les programmes\n
\n
\n- Une ou des bases de données contenant les données gérées ( bdd utilisateur )\n
\n
\nL\'application cible est conçue dans l\'environnement MyPitself puis, le code généré ( php aujourd\'hui )\npeut être extrait pour avoir une application indépendante de la base de données système et ne travaillant que sur la base de donnée utilisateur.\n
\n
\nEn d\'autre termes, le livrable peut être indépendant de MyPitSelf.\n');
t.xxtree214.add(221,220,'Définir les données','
\n
\nPuis vous générez des requêtes SQL simples grâce à un utilitaire permettant de stocker les caractéristiques de ces requêtes dans le système (type de requête, tables et champs utilisés , ...)
\n
\nCertaines des requêtes sont destinées à afficher les données (SELECT d\'une valeur particulière ou SELECT d\'une liste de valeurs).
\nD\'autres requêtes sont transformées en fonctions<\/span> qu\'il est possible d\'utiliser dans le langage de MyPitSelf (SELECT, INSERT, UPDATE, DELETE).
\n
\nC\'est là que le paradigme d\'accès aux données est résolu: comme l\'accès aux données est transformé en fonctions, et que ces fonctions sont intégrées aux programmes, il n\'y a plus de requêtes SQL au milieu des programmes source. Seuls les programmes générés contiennent des chaines de caractères contenant les requêtes.
\n
\nParadigme: Ensemble des unités qui peuvent commuter dans un contexte donné. <\/i><\/p>');
t.xxtree214.add(223,220,'Les programmes','Un langage basé sur des appels de fonctions imbriquées est utilisé pour écrire \nles fonctions au format source. Il utilise les fonctionnalités classiques des langages (variables, tests, boucles, accès fichiers ...) et les fonctions<\/span> générées par les requêtes. \n
\n
\nAprés analyse syntaxique des sources, le système produit le format table\n
\n
\nLe format table peut être mis à son tour en base de données et traité (reverse-engineering). Les fonctions deviennent donc disponibles pour traitement au même titre que les données.\n
\n
\nLe système peut regénérer le source a partir du format table.\n
\n
\nA partir du format table, le système produit le code exécutable en php à ce jour.\n
\n
\n
\nLa différence avec un autre language vient du fait que la forme tabulaire\ndu programme qui est la résultat de l\'analyse syntaxique est d\'une part \ndisponible et d\'autre part peut être traitée avec les moyens du language.\n
\n
\nTout se passe comme si vous étiez la personne ayant écrit le compilateur \net donc, que vous sachiez comment écrire l\'analyseur syntaxique, et qu\'à la fin\nde l\'étape d\'analyse syntaxique, vous seriez capable de reproduire le source.\n');
t.xxtree214.add(224,214,'Et alors ?','Et alors, je pense que MyPitSelf résoud ( et résoudra ) quelques problèmes rencontrés en informatique:');
t.xxtree214.add(225,224,'Complexité des traitements','Problème:<\/strong><\/u>\n
\nUne application évolue selon deux directions : Les données à gérer et les fonctions à fournir. Aujourd\'hui, on peut assez facilement ajouter des données à un système (par exemple, que vous ayez 50 ou 100 emails dans votre boîte de réception ne change pas grand chose) mais ajouter des fonctions est moins évident (par exemple le comptage des mails reçus en provenance de deux ou trois personnes ). \n
\n
\nLa complexité grandissante des applications demande un traitement industriel. Si la vérification du code ne passe que par des moyens humains, des erreurs se glisseront très probablement dans les programmes.\n
\n
\n
\nRéponse:<\/u><\/strong>\n
\n
\nUne fois les fonctions de base sur les données fournies, la combinaison de ces fonctions pour donner des fonctions plus complexes est une logique simple qu\'il est plus facile à appréhender si on considère cette opération comme une opérations sur des données ( ajouter la fonction de recherche de mails en provenance Jean à la fonction de recherche de mails en provenance de Paul ). Le fait de traiter les fonctions comme des données permet de résoudre ce problème. \n
\n
\nDans MyPitSelf, les fonctions sont transformées en données organisées en base de donnée. La vérification de la cohérence de données est une opération courante qui est vérifiable par des programmes Ad Hoc.\n
\n');
t.xxtree214.add(226,224,'Adaptation et capitalisation','Problème:<\/strong><\/u>\n
\n
\nLes données que l\'on gère sont définies par un modèle et des règles qui sont justifiées d\'une part, au moment de la conception et d\'autre part par l\'idée que le concepteur se fait de l\'application.
\nOr, cette application doit évoluer dans le temps car au fur et à mesure de son utilisation des fonctions nouvelles sont requises. \n
\nMais aussi, certaines parties qui était importantes lors de la création le deviennent moins et d\'autres peuvent prendre plus de poids. Dans ce cas, le modèle de données initial doit pouvoir évoluer de façon à s\'adapter à ces changements. \n
\n
\nL\'important n\'est plus modèle de données initial mais sa souplesse et la possibilité de pouvoir capitaliser sur l\'existant. \n
\n
\n
\nRéponse:<\/u><\/strong>\n
\n
\nLe premier programme fait avec MyPitSelf est lui même: Il n\'y avait au départ que le noyau puis des données ont été ajoutées puis des fonctions sur ces données et ainsi de suite. En d\'autre termes, le modèle a du être adapté tout au long de sa conception. Les programmes construits avec MyPitSelf se font sur le même modèle et suivent donc la même logique. \n
\n
\nAujourd\'hui les données gérées sont "suffisantes" pour l\'environnement de développement dans la version actuelle. Bien que les problèmes rencontrés pour construire ce genre de programmes représentent une bonne partie des traitements que l\'on peut imaginer, d\'autres données - et fonctions - vont être ajoutées pour gérer des problématiques plus spécifiques, comme par exemple des traitements graphiques. Les applications futures bénéficieront de ces améliorations. \n
\n');
t.xxtree214.add(227,224,'Conclusion',' MyPitSelf est disponible même s\'il n\'est qu\'à la version 0.8 car le reverse-engineering est aujourd\'hui assuré. \n
\nCeci implique que si MyPitSelf évolue, les programmes conçus avec une ancienne version pourront être repris.\n');
t.xxtree214.add(228,214,'Environnement de travail','95 % des développements sont réalisés via une interface web, seul l\'administrateur système doit avoir accès au serveur \n
\n
\nIl est multilangue au niveau système, MyPitSelf existe pour l\'instant en anglais et en français\n
\n
\nIl est multilangue au niveau application, les programmes sont dans les langues de votre choix, l\'utilisateur peut choisir sa langue à la volée.\n
\n
\nLa rédaction de la documentation fonctionnelle est facilitée grâce à la rétro-analyse et à : \n
\n- des copies d\'écrans lors des séquences de saisie.\n
\n- la génération de documents HTML basés sur la description de l\'environnement.\n
\n
\nLa gestion des droits des utilisateurs est intégrée dans le noyau et peut être étendue pour s\'adapter à vos programmes. \n
\n
\nIl facilite la conception d\'applications basées sur des modèles de données contenant beaucoup de liens.\n
\n
\nCopies d\'écrans<\/u>\n
\n
\nCes copies d\'écrans sont extraites de l\'exemple de développement expliqué plus bas.\nMyPitself permet d\'enregistrer les pages par lesquelles on passe pour, par exemple, créer la documentation d\'un logigiel.\n
\n
\nCréation d\'une requête: <\/a>. \n
\n
\nCréation de fonctions: <\/a>.\n
\n
\n');
t.xxtree214.SetLoaded();