|
 Bienvenue dans MyPitSelf
|
 English(US)
 Français(FR)
 Plan du site |
Cette documentation a été produite avec MyPitSelf00816 |
|
|
|
Bienvenue dans MyPitSelf
|
|
English(US)
Français(FR)
Plan du site |
Cette documentation a été produite avec MyPitSelf00816 |
Bienvenue dans MyPitSelf
MyPitSelf© est un Système permettant
de produire des systèmes d'informations, dans un contexte de bases de données.
Le mode de conception permet la rétro-analyse des programmes (rétro-ingénierie ou reverse-engineering).
Comme pour tous les Systèmes, on peut toujours penser à une nouvelle fonction à fournir, il n'y a pas de limite.
Or, ce qui fait qu'un Système peut évoluer sans limite est lié au principe de récursivité d'après lequel, par retour sur tout ou partie des éléments de départ, un petit nombre d'éléments finis suffit à construire une série infinie d'éléments.
La rétro-analyse est un processus de type récursif et MyPitSelf est une solution mettant en oeuvre ce principe sur les programmes.
Dans la continuité de cette logique, le premier programme écrit avec MyPitSelf est MyPitSelf lui même.
En effet, c'est aussi un système d'information comme ceux qu'il permet de produire mais, au lieu de gérer des comptes en banque, des mails, des sites web, des processus,,, il gère des programmes et des bases de données.
La mise en oeuvre du principe est réalisée grâce à:
- une méthode permettant de résoudre le problème du paradigme d'accès aux bases de données ( SQL vs language de programmation ).
- Un langage utilisant la méthode d'accès aux données et dont les phrases peuvent être
transformées en données et inversement.
Une partie de cette documentation n'est pas trop technique ( voir Présentation Générale ),
les autres chapitres le sont.
MyPitSelf utilise
MySql,
Php,
SVG,
Apache,
HTMLArea,
linux,
firefox,
Win2K/XP/IE6/7
et surtout
lui même!
Le nom MyPitSelf vient de MySql, Php et Itself
|
J'ai eu un problème quand j'ai du maintenir des systèmes d'information dont les données avaient une représentation qui ressemblait au modèle présenté dans l'image çi dessous.
)
Cliquez et regardez l'image pendant 5 secondes, pas plus. Utilisez le bouton 
en haut de la nouvelle fenêtre pour la fermer.
Globalement vous avez vu des boites (les informations) et des flèches qui les relient (les interconnexions entre les informations).
Le problème était que ça devenait trop 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.
Dans 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.
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.
Dans 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 !).
Donc, comme je n'aimais pas cette situation, je me suis mis à développer un outil pour me faciliter la tâche.
Au fur et à mesure de mes développements, je m'apercevais que je me dirigeais 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.
j'en suis venu à la conclusion qu'il fallait industrialiser les développements et pour ce faire, il fallait que la conception et l'écriture des programmes puisse être elle même industrialisée.
Et 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.
Mais il fallait trouver le moyen de mettre en place toutes ces idées.
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.
Un 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é.
En 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.
Je vous laisse tirer vos propres conclusions sur les outils de développement de systèmes d'informations qui n'offrent pas cette caractéristique.
En 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,
on peut avancer, les limites fonctionnelles sont beaucoup plus loin maintenant.
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
)
)
)
)
)
.
Des 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).
En revanche, les programmes générés ont une forme classique.
Des exemples simples de développement sont donnés plus bas
Mais 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 .....
Le 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.
J'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.
Certaines personnes appellent ça le "refactoring".
Un 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.
La 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.
L'important est de pouvoir corriger ce qui ne va pas et ce n'est plus qu'une question de temps.
Cela 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 !
Il 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.
En fait, en ce moment, je mets en place l'environnement pour travailler avec ajax, vous verrez mes premier essais ici.
Maintenant, au travail !
MyPitSelf utilise
Apache,
Php,
MySql,
HTMLArea,
linux,
firefox,
Win2K/IE6
SVG,
et surtout
lui même!
Le nom MyPitSelf vient de MySql, Php et Itself
)
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 ...).
Puis 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 , ...)
Certaines des requêtes sont destinées à afficher les données (SELECT d'une valeur particulière ou SELECT d'une liste de valeurs).
D'autres requêtes sont transformées en fonctions qu'il est possible d'utiliser dans le langage de MyPitSelf (SELECT, INSERT, UPDATE, DELETE).
C'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.
Paradigme: Ensemble des unités qui peuvent commuter dans un contexte donné.
Un langage basé sur des appels de fonctions imbriquées est utilisé pour écrire
les fonctions au format source. Il utilise les fonctionnalités classiques des langages (variables, tests, boucles, accès fichiers ...) et les fonctions générées par les requêtes.
Aprés analyse syntaxique des sources, le système produit le format table
Le 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.
Le système peut regénérer le source a partir du format table.
A partir du format table, le système produit le code exécutable en php à ce jour.
La différence avec un autre language vient du fait que la forme tabulaire
du programme qui est la résultat de l'analyse syntaxique est d'une part
disponible et d'autre part peut être traitée avec les moyens du language.
Tout se passe comme si vous étiez la personne ayant écrit le compilateur
et donc, que vous sachiez comment écrire l'analyseur syntaxique, et qu'à la fin
de l'étape d'analyse syntaxique, vous seriez capable de reproduire le source.
Et alors, je pense que MyPitSelf résoud ( et résoudra ) quelques problèmes rencontrés en informatique:
Problème:
Une 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 ).
La 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.
Réponse:
Une 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.
Dans 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.
Problème:
Les 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.
Or, cette application doit évoluer dans le temps car au fur et à mesure de son utilisation des fonctions nouvelles sont requises.
Mais 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.
L'important n'est plus modèle de données initial mais sa souplesse et la possibilité de pouvoir capitaliser sur l'existant.
Réponse:
Le 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.
Aujourd'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.
MyPitSelf est disponible même s'il n'est qu'à la version 0.8 car le reverse-engineering est aujourd'hui assuré.
Ceci implique que si MyPitSelf évolue, les programmes conçus avec une ancienne version pourront être repris.
95 % des développements sont réalisés via une interface web, seul l'administrateur système doit avoir accès au serveur
Il est multilangue au niveau système, MyPitSelf existe pour l'instant en anglais et en français
Il est multilangue au niveau application, les programmes sont dans les langues de votre choix, l'utilisateur peut choisir sa langue à la volée.
La rédaction de la documentation fonctionnelle est facilitée grâce à la rétro-analyse et à :
- des copies d'écrans lors des séquences de saisie.
- la génération de documents HTML basés sur la description de l'environnement.
La gestion des droits des utilisateurs est intégrée dans le noyau et peut être étendue pour s'adapter à vos programmes.
Il facilite la conception d'applications basées sur des modèles de données contenant beaucoup de liens.
Copies d'écrans
Ces copies d'écrans sont extraites de l'exemple de développement expliqué plus bas.
MyPitself permet d'enregistrer les pages par lesquelles on passe pour, par exemple, créer la documentation d'un logigiel.
Création d'une requête: 
.
Création de fonctions: .
C'est un système pour développer des programmes autour d'une base de données
Chaque développement a son propre environnement qui comprend:
Une base de donnée système qui contient:
- La description des données,
- Les sources des programmes,
- Des valeurs discrètes ( constantes, les répertoires de travail .... )
Une ou plusieurs bases de données contenant les données à maintenir.
Pendant la phase de développement, les environnements sont contenus dans l'environnement principal de MyPitSelf.
Après la phase de développement, on peut produire un ensemble qui est indépendant de l'environnement principal.
Donc, Avec MyPitSelf, en tant que développeur, vous allez construire les environnements pour les autres programmes et remplir les bases de données systèmes de vos programmes.
La cible est de développer des programmes multi utilisateurs donc il y a des gestions d'autorisations basées sur un code/mot de passe de l'utilisateur.
Trois raisons principales:
1°) Les SGBD sont des bons systèmes pour stocker et utiliser les données. Ils peuvent aussi être des bons systèmes pour stocker et utiliser les programmes. Donc les programmes devaient être écrits de façon à ce qu'ils puissent être mis en base pour qu'ils puissent être liés aux données qu'ils traitent. C'est pour celà que cet environnement a son propre langage. Ceci veut aussi dire que les programmes sont finalement considérés comme des données, en conséquence, on peut appliquer des traitements aux programmes.
2°) Une fois que les données sont définies, les programmes les traitent. Donc, dans ce système, la première étape est de définir les données et enfin, les programmes peuvent être écrits. Les données de base sont celles définies au niveau dans la base de donnée.
| 3°) Le premier programme écrit avec ce système est lui même car si ce système peut organiser et traiter des données, il permet aussi d'écrire un système pouvant organiser et traiter les données. Ceci explique la boucle dans ce shéma. |
)
|
Grâce à PHP, MySql, Javascript et Apache sur window et Linux sur firefox/IE.
Les outils principalement utilisés pour son développement sont lui même (85%), le blocNote de w2k (10%) et PhpMyAdmin (5%) .
Lcc a été utilisé pour écrire un programme permettant de lancer de jobs en batch. C'est une adaptation du programme mikehup.exe écrit par Michael Kohn (naken@naken.cc), Web page: http://www.naken.cc/
J'utilise SVG pour dessiner les tables avec les liens.
PHP est utilisé pour écrire les fonctions de base.
Toutes les fonctions utilisateur devraient être écrites dans le langage de MyPitSelf. Les principes de base de ce langage sont:
Jamais fini car il y a toujours des nouvelles fonctions à ajouter! Mais suffisament bon pour avoir des sites en production.
Il y a des fonctions comme le versionning, les scénarios de test, la documentation ... que j'ai commencé mais qui ne sont pas encore finies.
Au moins celles qui existent permettent de faire ce que vous allez voir ( si vous continuez ).
Je ne peut pas vous dire quand sortira la prochaine version car je ne peut pas consacrer 100% de mon temps à ce produit.
Maintenant, voyons à quoi tout celà ressemble.
Je suppose que vous avez un modèle de données avec une table de gens contenant leur nom et leur age.
Je suppose aussi que vous avez généré plusieurs requêtes grâce au système, dont la requête portant le numéro 1203 (par exemple).
Une utilisation de cette fonction pourra par exemple servir à afficher tous les gens dont l'age est >= 30.
Cela donnera un programme qui ressemble à (les commentaires sont précédés par //) :
Tac( // Take and call: met des valeurs dans la pile d'appel
// et/ou appel des fonctions.
Cst(30), // constante 30 ans mise dans une pile d'appel
R_1203_Select( // Liste de ces gens, le paramètre SQLPAR0 = 30
Do(
Take(T0.Nom), // mettre le contenu du champ Nom dans la pile d'appel
out(1) // afficher le premier element contenu dans la pile d'appel
) // T0.Nom est retire de la pile d'appel a ce niveau
)
) // 30 est retire de la pile d'appel a ce niveau
Remarque: Les interlignes sont ignorés, on aurait pu tout aussi bien écrire cette fonction sous la forme:
Ce programme aura la forme tabulaire suivante:
| In | NU | PA | PO | NA | TY | NC | LE | C1 | C2 |
| 0 | 0 | -1 | 0 | 0 | INIT | 1 | 0 | ||
| 1 | 1 | 0 | 1 | Tac | f | 2 | 1 | // 30 est retire de la pile d'appel a ce niveau | |
| 2 | 2 | 1 | 1 | Cst | f | 1 | 2 | // Take and call: met des valeurs dans la pile d'appel // et/ou appel des fonctions. | |
| 3 | 3 | 2 | 1 | 30 | v | 0 | 3 | ||
| 4 | 4 | 1 | 2 | R_1203_Select | f | 1 | 2 | // constante 30 ans mise dans une pile d'appel | |
| 5 | 5 | 4 | 1 | Do | f | 2 | 3 | // Liste de ces gens, le paramètre SQLPAR0 = 30 | // T0.Nom est retire de la pile d'appel a ce niveau |
| 6 | 6 | 5 | 1 | Take | f | 1 | 4 | ||
| 7 | 7 | 6 | 1 | T0.Nom | v | 0 | 5 | ||
| 8 | 8 | 5 | 2 | out | f | 1 | 4 | // mettre le contenu du champ Nom dans la pile d'appel | // afficher le premier element contenu dans la pile d'appel |
| 9 | 9 | 8 | 1 | 1 | v | 0 | 5 |
<?php
function f_5001(){
global $XVS,$XCS; // variable stack and call stack
$xxSI=sizeof($XCS); // call stack init pos
$xxSC=0; // Stack push count
//===== Start of function =====
//===================
$req4 = "
SELECT T0.Nom FROM `Gens` T0
WHERE T0.Age<=30
ORDER BY T0.Nom ASC " ;
//===================
$result4=mysql_query($req4);
if(mysql_errno()==0){
while($mpsrow4=mysql_fetch_row($result4)){
echo '<span class="DBG">'.$mpsrow4[0].'</span><br />'; // output
}
}else{
return(xxErrSql('1203_SELECT',mysql_error(),$req4,$xxSI));
}
mysql_free_result($result4);
//===== End of function =====
return(true);
}
?>
L'exemple précédent est simplifié mais vous pourrez voir en cliquant ici quelque chose d'un peu plus trapu: c'est une des fonction assurant la rétro-analyse de l'exécution d'un programme, elle modifie une forme tabulaire d'une fonction.
Je suppose que Apache(1.3.29), Php(4.3.9), MySql(4.0), Firefox ou Ie(6.0) fonctionnent correctement sur votre système. Les numéros de version citées sont celles que j'utilise actuellement mais je suppose que ça marchera avec des versions équivalentes.
Je suppose que vous conaissez un minimum ces logiciels et en particulier le fait de les faire fonctionner ensemble.
Si ce n'est pas le cas, voyez la documentation gigantesque écrite à leur sujet.
Il y a deux fichiers à dézipper:
mypitselfw ( fichiers Web ) à dézipper quelquepart sous le dossier htdocs du serveur Web.
mypitselfp ( fichiers programmes ) à dézipper ailleurs que sous le dossier htdocs.
Sur un système linux, vous devez exécuter ces commandes:
cd /var/www # supposons que vous avez mis les dossiers mypitselfw and mypitselfp dans /var/www
chmod -R o+w mypitselfp
chmod -R o+w mypitselfw
cd mypitselfp
chown root:root batch_linux.exe
chmod -R o+x batch_linux.exe
L'utilisation du fichier php.ini-recommended donné dans votre distribution de Php est fortement recommandée.
Si vous utilisez quelquechose d'autre, à votre guise, mais au moins, vérifiez que les configurations ci dessous sont:
register_globals = Off
J'utilise les paramètre
display_errors = on
display_startup_errors = On
error_reporting = E_ALL
Remarque: ces paramètres ne sont pas recommandés pour les sites en production
mais c'est plus pratique pour de déboggage.
Je suppose qu'apache/php tourne correctement sur votre système.
Ajoutez ce paramètre dans le fichier de configuration d'apache pour aller sur index.php
Quand vous avez essayé de vous connecter au premier écran, vous avez vu un écran comme celui ci.
Si ça n'a pas été le cas, eh bien, quelquechose s'est mal passé, essayez de réinstaller après avoir effacé les dossiers et la base de donnée.
MyPitSelf installation.
Create database Delete database |
MyPitSelf installation.
MyPitSelfxxyzz A été créée avec succès. Vous pouver retourner sur le menu. ou bien Supprimer la base MyPitSelf |
Cliquez là Vers MyPitSelf
Vous obtenez l'écran qui vous demande votre nom d'utilisateur et votre mot de passe
Entrez "1" dans chaque champ et cliquez sur "Entrer". Maintenant si vous obtenez une fenêtre qui ressemble à celle ci, vous pouvez être content!.
|
: Qui vous permet d'aller à l'écran initial.
: Qui vous permet d'aller à l'écran précédent.
: Qui vous permet d'aller voir la doc.
: Qui vous permet de quitter.
: Nouvel élément
: dupliquer un élément
: voir un élément
: Modifier un élément
: Supprimer un élément
: Liste des propriétés d'un élément
: Déplacer un élément
A partir des informations entrées pour créer votre application, MyPitSelf peut générer une documentation.
Cette documentation technique contient entre autres le schéma SVG des relations entre les tables.
Un plug-in SVG est disponible sur le site d'Adobe.
Pour y accéder, cliquez ici 
C'est une application permettant d'afficher les données provenant de la base de donnée "world" disponible sur le site de MySql.
Le shéma de la base est le suivant
Pour y accéder, cliquez
ici
Cette application est un petit CRM permettant à un fournisseur de service informatiques de mettre à la disposition de ses clients de type entreprise une organisation leur permettant de gérer leur propres conntacts.
Chaque société aura un utilisateur principal appelé manager.
Le manager crée les contacts ( nom, prénom, .... )
Le manager définit les informations qui pourront être rattachées aux contacts selon ses besoins propres à la société.
Les informations sont de deux types:
- Evènement: c'est une réunion, un déjeuner ... à une date donnée.
- Relation: c'est un fait concernant le contact comme par exemple, il est important, moyen ou petit, il parle anglais, italien ou français, demande des conditions particulières de livraison ...
La liste des contacts est unique pour une société donnée et sera partagée par les utilisateurs de la société en relation avec les contacts.
Le manager définit les utilisateurs ( login, nom, prénom, mot de passe .... ).
L'utilisateur aura une liste de contacts qu'il devra piocher parmi la liste des contacts de la société.
Sur chacun des contacts qu'il se sera approprié il pourra ajouter des relations ou des évènements dans le cadre définit par le manager.
Le contact peut être partagé par plusieurs utilisateurs.
Un système de requêttage permet à l'utilisateur de lister ses contacts satisfaisant à des relations particulières. Ces requêtes peuvent être combinées par des fonction ET, OU, NOT ou XOR.
Le manager peut effectuer ces requêtes sur tous les contacts de la société.
Le modèle de données de cet exemple est celui que vous obtenez en cliquant sur l'image çi-dessous
)
.
ici .
Nous allons utiliser cet exemple pour voir l'utilisation de ce système.
Le but est de construire un programme à la demande d'un client.
Les explications sont minimales, ne vous en faites pas si vous ne saisissez pas tout, ça viendra au fur et à mesure.
L'approche projet a trois niveaux.
Niveau organisationnel ( que veut le client ? ).
Il besoin d'un système permettant de gérer les tâches à réaliser. Chaque utilisateur pourra créer ses propres tâches composées d'un nom et d'un niveau de priorité. Le niveau de priorité sera un nombre et chaque utilisateur pourra voir sa liste de tâches triées selon son son ordre de priorité.
Chaque utilisateur pourra trouver les tâches contenant une chaine de caractères.
Les managers pourront aussi voir les tâches des autres utilisateurs mais les utilisateurs normaux ne pourront voir que leurs propres tâches.
Un utilisateur peut modifier, dupliquer ou supprimer ses tâches.
Niveau fonctionnel ( Que devons nous faire ? ).
Une table contenant un identifiant utilisateur, un nom de tâche et un niveau de priorité.
Une table des utilisateurs contenant l'identifiant utilisateur, son nom et son prénom.
Une gestion des groupes ( utilisateurs normaux et managers ).
Nous aurons besoin d'une fonction affichant une liste de tâches selon son niveau de priorité et selon le fait que les tâches contiennent certains mots. A partir de cette liste, on pourra créer des nouvelles tâches, modifier celles existantes ou les supprimer.
Une autre fonction ( manager ) affichera une liste de tache le nom de l'utilisateur.
Donc selon le profil utilisateur, il faudra afficher différents menus:
Utilisateur: Voir mes tâches Manager: Voir mes tâches, Voir toutes les tâches
Un super utilisateur aura la possibilité d'autoriser de nouveaux utilisateurs et de leur assigner un niveau d'utilisation ( manager ou utilisateur )
Un manager sera considéré comme un utilisateur pour ses propres tâches.
Niveau technique: ( Comment allons nous réaliser ceci ).
Voir les chapitres suivants.
Remarque: Comme pendant une modification, il y a un vérou qui est mis en place et que pendant les procédures suivantes il se peut que vous fermiez des fenêtres alors que vous faites une modification, le vérou restera.
Pour le retirer, allez dans le menu Profil puis choisisez l'option Voir les vérous puis cliquez sur le bouton Unlock.
Donc,cliquez ici pour ouvrir une fenêtre si ce n'est déjà fait. sur MyPitSelf et connectez vous en tant qu'utilisateur/mot de passe = 1/1
La première des choses à faire est de créer un nouvel environnement.
Note: pour le moment, je n'ai pas assez travaillé sur les privilèges sur les bases de données donc il n'y a pas de réglage fin de ce coté.
Ca fonctionne en définissant pour chaque environnement un utilisateur/mot de passe ( ou en définissant toujours le même ) et les autorisations sur les bases sont réglées pour cet utilisateur.
Je vous conseil d'utiliser MyPitSelfDev, ça marche !
Pour réaliser celà, vous devrez faire les actions décrites sur les écrans que vous verez en cliquant ici .
Créer un nouvel environnement revient à créer des répertoires et une base de donnée système. ( regardez dans les répertoires mypitselfp et mypitselfw )
Cliquez ici pour ouvrir une fenêtre si ce n'est déjà fait. sur MyPitSelf et connectez vous en tant qu'utilisateur/mot de passe = 1/1
Il faut maintenant créer un manager qui aura la possibilité d'utiliser ce nouvel environnement.
Il y a trois profils de base dans un développement avec MyPitSelf:
Cliquez ici pour ouvrir une nouvelle fenetre si ce n'est déjà fait
Quittez l'environnement principal si vous êtes connecté en tant qu'utilisateur 1/1
et connectez vous en tant que m/1
Comme vous vous êtes connecté en tant qu'utilisateur m, vous ne voyez pas les mêmes menus que précédamment, en particulier, les menus permettant de gérer les utilisateurs sont réservés au super utilisateur.
En revanche d'autres menus sont apparus et vous permettront de développer.
Il faut tout d'abord créer une image de la base de donnée. En fait cette image a déjà été créée lors de la création de l'environnement. Vous pouvez la voir en cliquant sur le bouton base du menu.
Puis il faut donner à cette image une existance réelle c'est à dire créer réellement la base dans MySql.
Pour ce faire, exécutez les actions que vous voyez en cliquant ici
.
Remarque: La base contient déjà 2 tables: Une table utilisateurs et Lock ( verrous ).
Ces deux tables sont créées car MyPitSelf est conçu pour travailler en environnement multi utilisateur.
Elles peuvent être supprimées ou modifiées mais pour l'instant, nous n'allons pas y toucher.
Puis il faut créer la table des tâches. Cette table est rattachée à la base et contient :
.
Maintenant il faut créer une requête permettant de lister les tâches. Elle resemblera à:
.
Maintenant, il faut créer un menu permettant d'afficher la liste des tâches.
Ceci passe tout d'abord par la création d'une fonction écrite en langage MyPitSelf.
Cette fonction sera ensuite attachée à un menu.
Pour ce faire, exécutez les actions que vous voyez en cliquant ici .
Utilisez un copier/coller pour éviter de réécrire la fonction.
Un petit mot ici sur le langage MyPitSelf puisque cette fonction a été écrite dans ce langage:
Cette fonction permettant d'afficher la liste des tâches de l'utilisateur
Maintenant, il faut créer une fonction permettant d'ajouter une tâche.
Nous allons utiliser l'outil pour créer une requête de type SELECT VALUE.
Ce type de requêtes a été défini car il permet de générer des instructions propres à l'affichage d'une entrée dans la base. Pour ce faire, exécutez les actions que vous voyez en cliquant ici .
Enfin, nous pouvons créer la fonction de type LISTTOP rattachée à la liste affichant la requête 1201
Pour ce faire, exécutez les actions que vous voyez en cliquant ici .
Enfin la dernière étape sera de regénérer toutes les requêtes, de compiler toutes las fonctions, d'établir la langue par défaut du programme et de créer les utilisateurs initiaux ( 0 = tous, 1 = super user )
Pour ce faire, exécutez les actions que vous voyez en cliquant ici .
Finalement, on peut commencer à tester l'application qui contient maintenant quelque chose.
Cliquez iciet choisisez le bouton Test pour ouvrir une fenêtre sur votre nouveau programme en vous connectant avec le nom/mot de passe 1/1.
Maintenant, vous êtes le super utilisateur du NOUVEAU PROGRAMME, vous pourrez définir les autres utilisateurs et leurs droits tout comme vous avez défini un nouvel utilisateur dans l'environnement principal.
Tout d'abord, il faut savoir que par défaut, le super utilisateur est aussi un utilisateur normal et peut avoir accès à tous les menus.Si lors de la création du menu ( plus haut ) , vous ne cochez pas la case "pas pour super", le menu est disponible pour le super utilisateur.
Maintenant, nous allons tester le menu tâches en cliquant ici .
Puis nous allons ajouter deux utilisateurs en les rattachant à des groupes d'utilisateurs
manager et utilisateurs qu'il faudra ensuite créer dans l'environnement de développement.
Pour créer ces utilisateurs, exécutez les actions que vous voyez en cliquant ici .
Puis nous allons définir deux groupes d'utilisateurs ( manager et utilisateurs )
dans l'environnement de développement
Les actions à faire sont celles que vous obtenez en cliquant ici .
Pour leur assigner des menus, les actions à faire sont celles que vous obtenez en cliquant ici .
Revenez dans l'environnement de développement de MyPitSelf en cliquant ici et connectez vous en tant que m/1.
Nous allons ajouter des fonctions qui permettent de voir, de modifier, de dupliquer ou de supprimer une tâche.
Pour la supression, il faudra tout d'abord créer une requête de type DELETE VALUE.
Retenez le numéro de requête créé, nous nous en serviront dans les fonctions.
Pour ce faire, exécutez les actions que vous voyez en cliquant ici .
Puis nous crérons les fonctions de type LISTFUNCT.
Pour ce faire, exécutez les actions que vous voyez en cliquant ici .
Maintenant, nous allont tester les nouvelles fonctions; allez dans l'environnement test et
connectez vous en tant que m/1
puis testez en exécutant les actions que vous voyez en cliquant ici .
Voilà, la première partie de l'aspect organisationnel est fini. Nous allons maintenant créer la fonction permettant au manager de voir les tâches de tout le monde.
Maintenant, nous pouvons faire un menu permettant de voir les tâches de tout le monde. Ce menu sera pour les managers.
Pour celà, il faudra créer une requête pour lister les tâches et le nom de la personne ayant créée la tâche doit apparaître.
Cette requête aura deux tables: la table des utilisateurs et la table des tâches.
Exécutez les actions que vous obtenez en cliquant ici .
Puis il faudra créer un nouveau menu.
Exécutez les actions que vous obtenez en cliquant ici .
Puis reconnectez vous en tant qu'utilisateur m/1, ce menu est apparu et vous pouvez le tester en exécutant les actions que vous obtenez en cliquant ici .
Le client veut ajouter des fonctionnalités:
A partir de la liste des toutes les tâches, le manager doit pouvoir:
Créer une tache pour un autre utilisateur que lui même.
Modifier une tâche d'un utilisateur et en particulier, la réaffecter à un autre utilisateur.
Comment mettre celà en place ?
Je pense que vous avez compris que MyPitSelf utilise des tables liées.
Par exemple, pendant le développement, vous avez remarqué qu'on rattachait un menu à une fonction, une table à une base, un champ à une table, un menu à un groupe d'utilisateur, etc ....
Nous allons créer un lien.
Le lien qui nous concerne ici est qu'une tâche est rattachée à un utilisateur particulier.
Lorsqu'un manager doit affecter la tache d'un utilisateur "A" à un autre utilisateur "B", il doit pouvoir choisir l'utilisateur dans la liste des utilisateurs existants, c'est à dire dans la table des utilisateurs.
Ce lien existe déjà partiellement car lors de la création de la table des taches, nous avons spécifié que le champ xRefUser pointait sur le champ code de la table des utilisateurs.
En revanche, la fonction associée était bidon ( dummy ). Maintenant, nous allons créer une vrai fonction.
Ceci passe par la création
.
.
.
.
.
Tout cet exemple vous a montré comment on développe avec MyPitSelf ainsi qu'une partie des fonctionnalités.
Ici, l'approche a été très détaillée et en pratique, il existe des raccourcis pour créer les éléments ( requêtes, fonctions, menus ... ) automatiquement.
En fait le développement de cette application ne devrait pas prendre plus de 15 minutes.
Le livrable se situera finalement dans le répertoire "prod" après avoir utilisé la fonction d'extraction ( voir menu outil / Créer les programmes dans l'environnement externe )
Un des intérêts d'avoir un environnement de production séparé de l'environnement de développement est que ce dernier peut contenir des fonctionnalités du type mise à jour de libellés en ligne.
C'est pour cela que dans le menu profil, il existe le bouton permettant de basculer le mode de déboggage. Quand ce dernier est actif, on peur suivre à la trace tous les appels de fonctions.
Comme MyPitSelf est fait en majorité avec lui même, le meilleur exemple de développement que vous pourrez trouver s'obtient en vous connectant en tant qu'utilisateur 1/1 à l'environnement de développement.
Puis cliquez sur le menu "Outil", puis cliquez sur le bouton "Basculer le mode de développement de MyPitSelf".
Tous les menus apparaissent alors et vous pourrez voir pas mal de choses.
Vous pouvez aussi utiliser le bouton "Cacher ou voir les appels de fonctions" dans le menu profil qui permet de voir quelles fonctions/requêtes sont utilisées.
Un trait essentiel de MyPitSelf est que les fonctions écrites dans son langage sont décomposées en unités syntaxiques qui sont visualisable en utilisant le bouton imprimer en face des sources des fonctions dans la liste des fonctions.
Le résultat de cette décomposition est une grille qui peut être mise dans une table de base de donnée.
Les tuples de cette table peuvent être analysés et modifiés par des fonctions de bases de données.
On peut exécuter des fonction de reverse engineering sur cette forme tabulaire puis regénérer le code source à partir de cette forme tabulaire .
Voyez aussi les chapitres suivants pour en apprendre un peu plus sur MyPitSelf
Je n'ai pas encore parlé de beaucoup de choses, il faut que j'enrichisse encore la documentation, mais je pense que vous les avez plus ou moins présenties.
MyPitSelf va encore évoluer car il y a des trous fonctionnel, mais étant donné que presque tout est en base de donnée, y compris les programmes, que les programmes sont liés aux données et que les programmes sont en fait que des données à traiter, tout ce qu'il y a à faire est d'ajouter les données pour combler ces trous.
Quand on doit gérer des modèles de données un peu complexes (voir par exemple au hasard, celui de MyPitSelf présent sur la page d'accueil), c'est bien d'avoir un outil que facilide la tâche.
Je trouve que MyPitSelf, c'est pas mal pour gérer des modèles avec beaucoup de liens .
The MyPitSelf language evolves constantly because of its own concept and because improvements are brought, but it will remain with only function calls returning true or false.
It is a "blending" of
lisp for the nested treatments and true or false return values
C for the function calls
Assembler for the stack mechanism
The best method to learn this language is like for all languages:
- Look and do the development examples given above, this will make you familiar to the basic concepts and the development environment.
- See examples of this language. for this, go to the MyPitSelf environment as user 1/1 and to choose in the tool menu the button "Set or unset Developping mode for MyPitSelf" and to look at the functions.
This function refererence is mostly done so that when I need to write some source, I can copy the example and then paste it in the source.
When you are in the function list, the 
button gives a result under a table view.
In other words, if a function is f(g(x),h(y)), the table result of this function is
| Function# | Parent Number |
Order In Parent |
Function Name |
Function Type |
Number Of Children |
Level |
| 0 | -1 | 0 | 0 | INIT | 1 | 0 |
| 1 | 0 | 1 | f | formula | 2 | 1 |
| 2 | 1 | 1 | g | formula | 1 | 2 |
| 3 | 2 | 1 | x | zone | 0 | 3 |
| 4 | 1 | 2 | h | formula | 1 | 2 |
| 5 | 4 | 1 | y | zone | 0 | 3 |
Variables can contain any basic type of data ( strings, dates, times...) but not yet arrays
There are two sets of variables.
Some are declared and named ( see SetVar below ) and are contained in a stack: It's the variable stack.
Others are put in a stack by programs. It's the Call Stack.
As MyPitSelf is based on data, some instructions extract data from the databases and puts them in the call stack.
The way to reach the variables put in the call stack is by giving a number which represents the position in the call stack:
If the call stack contains ( it is filled going downwards )
SetVar(xxxx,yyyy[,yyyy]) for local variables
or
SetVarG(xxxx,yyyy[,yyyy]) for global variables
Where xxxx can be:
a variable name ( no spaces or special characters admitted )
Var(xxxx) : The content of the variable whose name is xxxx. ( equivalent to the $$ in php ).
yyyy can be:
-Var(zzzz) or VarG(zzzz): The content of the variable zzzz, zzzz must exist.
-Chr(n): where n is the ascii code of a character. It is useful for specials characters like Chr(10) or Chr(13)
-Cst(xxxx) : A constant, it can be a string or a number.
-n: A number which represents the niest last character of the CallStack.
-Display(nnnn) : nnnn is the message number in the msg list ( usefull for internationalisation )
-Funct(nnnn) : nnnn is a function number: It replaces the Cst(nnnn) because if someone give a new number mmmm to nnnn, all Funct(nnnn) will be moved to Funct(mmmm).
-Stack(oooo) : oooo is a name of a variable which contain the position of the element to fetch in stack.
-SessionVar(ssss) : ssss is a name of a constant to get in $_SESSION .
-HttpPostVar(pppp) : pppp is a name of a constant to get in $_POST .
-Num(qqqq,x) : qqqq is a name of a variable, x is the number of decimals.
-Env(rrrr) : rrrr is a constant representing the environment variable to get ( php getenv() )
-XVS(zzzz) : gets the content of the variable which is in the Variable stack ( zzz is the variable name )
Examples:
An environment has it's own variables like
the folder of it's programs
The user code of the current user,
Default values for data ....
Go to the profile menu and use the "see/hide function call" button to see function calls.
Then a button appears on the main menu ( print variable stack ).
These predefined variables can be seen using this button. They start with xxx.
These variable are in the variable stack just like the ones the ones declared with SetVarG.
The pvs() function can be used to display variables in a program.
For the moment, one can update these variable which is absolutely not correct and has not to be done but this will be enhanced to have more control on the use of the "system variables" according to the user profile.
They are basic because most operations are done using values in the call stack.
Tac: pushes values into the callstack
Puts in the call stack the value of a variable.
It is usually used to return some values: as this language returns only true or false,
if you want to get something different from a function call, you can use the
call stack and put some values in it.
Example
Fills a variable with a value according to it's data type:
It is mostly used for ENUM and FLAG types
Example:
Tac( SetVar(DataType,Cst(1002)), SetVar(Value,Cst(1)), FillVar(Libelle,DataType,Value), // Now Libelle containsEch(Var(Lib)), )
To put a number in the local format, do:
Tests a contition to execute or not execute a treatment