From f92f8f78534d2474dc66c08e36c0b29ec262b6a9 Mon Sep 17 00:00:00 2001 From: Suzanne Soy Date: Sun, 13 Jun 2021 02:29:42 +0100 Subject: [PATCH] Backup of the source code and contents from a few years ago --- .htaccess | 17 ++ config.php | 8 + fastiki/langues/en.php | 11 ++ fastiki/langues/fr.php | 11 ++ fastiki/modeles/appercu.htmlf | 4 + fastiki/modeles/editer.htmlf | 2 + fastiki/modeles/formulaire_edition.htmlf | 12 ++ fastiki/modeles/site.html | 29 ++++ fastiki/modeles/typedoc/page.htmlf | 1 + fastiki/modeles/typedoc/tache.htmlf | 7 + fastiki/php/authentification.php | 9 + fastiki/php/cache.php | 15 ++ fastiki/php/config_defaut.php | 42 +++++ fastiki/php/configuration.php | 41 +++++ fastiki/php/editer.php | 56 +++++++ fastiki/php/fichiers.php | 35 ++++ fastiki/php/fonctions.php | 65 ++++++++ fastiki/php/historique.php | 153 +++++++++++++++++ fastiki/php/langues.php | 48 ++++++ fastiki/php/modele.php | 20 +++ fastiki/php/plugin.php | 51 ++++++ fastiki/php/require.php | 16 ++ fastiki/php/securite.php | 51 ++++++ fastiki/plugins/langue.php | 18 ++ fastiki/plugins/tache.php | 44 +++++ fastiki/plugins/url.php | 28 ++++ fastiki/plugins/wiki.php | 98 +++++++++++ historique/log.txt | 81 +++++++++ historique/page/Accueil/0/log.txt | 1 + historique/page/Accueil/0/source.txt | 5 + historique/page/Accueil/1/log.txt | 1 + historique/page/Accueil/1/source.txt | 5 + historique/page/Accueil/10/log.txt | 1 + historique/page/Accueil/10/source.txt | 9 + historique/page/Accueil/11/log.txt | 1 + historique/page/Accueil/11/source.txt | 9 + historique/page/Accueil/12/log.txt | 1 + historique/page/Accueil/12/source.txt | 9 + historique/page/Accueil/13/log.txt | 1 + historique/page/Accueil/13/source.txt | 9 + historique/page/Accueil/14/log.txt | 1 + historique/page/Accueil/14/source.txt | 9 + historique/page/Accueil/15/log.txt | 1 + historique/page/Accueil/15/source.txt | 9 + historique/page/Accueil/16/log.txt | 1 + historique/page/Accueil/16/source.txt | 9 + historique/page/Accueil/17/log.txt | 1 + historique/page/Accueil/17/source.txt | 9 + historique/page/Accueil/18/log.txt | 1 + historique/page/Accueil/18/source.txt | 9 + historique/page/Accueil/19/log.txt | 1 + historique/page/Accueil/19/source.txt | 11 ++ historique/page/Accueil/2/log.txt | 1 + historique/page/Accueil/2/source.txt | 5 + historique/page/Accueil/20/log.txt | 1 + historique/page/Accueil/20/source.txt | 11 ++ historique/page/Accueil/21/log.txt | 1 + historique/page/Accueil/21/source.txt | 11 ++ historique/page/Accueil/22/log.txt | 1 + historique/page/Accueil/22/source.txt | 11 ++ historique/page/Accueil/23/log.txt | 1 + historique/page/Accueil/23/source.txt | 1 + historique/page/Accueil/24/log.txt | 1 + historique/page/Accueil/24/source.txt | 11 ++ historique/page/Accueil/3/log.txt | 1 + historique/page/Accueil/3/source.txt | 5 + historique/page/Accueil/4/log.txt | 1 + historique/page/Accueil/4/source.txt | 5 + historique/page/Accueil/5/log.txt | 1 + historique/page/Accueil/5/source.txt | 5 + historique/page/Accueil/6/log.txt | 1 + historique/page/Accueil/6/source.txt | 9 + historique/page/Accueil/7/log.txt | 1 + historique/page/Accueil/7/source.txt | 9 + historique/page/Accueil/8/log.txt | 1 + historique/page/Accueil/8/source.txt | 9 + historique/page/Accueil/9/log.txt | 1 + historique/page/Accueil/9/source.txt | 9 + historique/page/Accueil/version.txt | 1 + .../page/Gestion des ressources/0/log.txt | 1 + .../page/Gestion des ressources/0/source.txt | 14 ++ .../page/Gestion des ressources/1/log.txt | 1 + .../page/Gestion des ressources/1/source.txt | 14 ++ .../page/Gestion des ressources/2/log.txt | 1 + .../page/Gestion des ressources/2/source.txt | 14 ++ .../page/Gestion des ressources/version.txt | 1 + .../page/Interface Homme-2dMachine/0/log.txt | 1 + .../Interface Homme-2dMachine/0/source.txt | 9 + .../page/Interface Homme-2dMachine/1/log.txt | 1 + .../Interface Homme-2dMachine/1/source.txt | 9 + .../page/Interface Homme-2dMachine/2/log.txt | 1 + .../Interface Homme-2dMachine/2/source.txt | 19 +++ .../page/Interface Homme-2dMachine/3/log.txt | 1 + .../Interface Homme-2dMachine/3/source.txt | 21 +++ .../page/Interface Homme-2dMachine/4/log.txt | 1 + .../Interface Homme-2dMachine/4/source.txt | 27 +++ .../page/Interface Homme-2dMachine/5/log.txt | 1 + .../Interface Homme-2dMachine/5/source.txt | 27 +++ .../page/Interface Homme-2dMachine/6/log.txt | 1 + .../Interface Homme-2dMachine/6/source.txt | 27 +++ .../Interface Homme-2dMachine/version.txt | 1 + historique/page/Langage/0/log.txt | 1 + historique/page/Langage/0/source.txt | 15 ++ historique/page/Langage/1/log.txt | 1 + historique/page/Langage/1/source.txt | 17 ++ historique/page/Langage/10/log.txt | 1 + historique/page/Langage/10/source.txt | 46 ++++++ historique/page/Langage/11/log.txt | 1 + historique/page/Langage/11/source.txt | 52 ++++++ historique/page/Langage/12/log.txt | 1 + historique/page/Langage/12/source.txt | 55 ++++++ historique/page/Langage/13/log.txt | 1 + historique/page/Langage/13/source.txt | 58 +++++++ historique/page/Langage/14/log.txt | 1 + historique/page/Langage/14/source.txt | 58 +++++++ historique/page/Langage/15/log.txt | 1 + historique/page/Langage/15/source.txt | 60 +++++++ historique/page/Langage/16/log.txt | 1 + historique/page/Langage/16/source.txt | 69 ++++++++ historique/page/Langage/17/log.txt | 1 + historique/page/Langage/17/source.txt | 69 ++++++++ historique/page/Langage/18/log.txt | 1 + historique/page/Langage/18/source.txt | 70 ++++++++ historique/page/Langage/19/log.txt | 1 + historique/page/Langage/19/source.txt | 70 ++++++++ historique/page/Langage/2/log.txt | 1 + historique/page/Langage/2/source.txt | 24 +++ historique/page/Langage/20/log.txt | 1 + historique/page/Langage/20/source.txt | 70 ++++++++ historique/page/Langage/21/log.txt | 1 + historique/page/Langage/21/source.txt | 70 ++++++++ historique/page/Langage/3/log.txt | 1 + historique/page/Langage/3/source.txt | 24 +++ historique/page/Langage/4/log.txt | 1 + historique/page/Langage/4/source.txt | 28 ++++ historique/page/Langage/5/log.txt | 1 + historique/page/Langage/5/source.txt | 32 ++++ historique/page/Langage/6/log.txt | 1 + historique/page/Langage/6/source.txt | 36 ++++ historique/page/Langage/7/log.txt | 1 + historique/page/Langage/7/source.txt | 36 ++++ historique/page/Langage/8/log.txt | 1 + historique/page/Langage/8/source.txt | 36 ++++ historique/page/Langage/9/log.txt | 1 + historique/page/Langage/9/source.txt | 40 +++++ historique/page/Langage/version.txt | 1 + historique/page/Licence/0/log.txt | 1 + historique/page/Licence/0/source.txt | 18 ++ historique/page/Licence/1/log.txt | 1 + historique/page/Licence/1/source.txt | 28 ++++ historique/page/Licence/2/log.txt | 1 + historique/page/Licence/2/source.txt | 30 ++++ historique/page/Licence/3/log.txt | 1 + historique/page/Licence/3/source.txt | 30 ++++ historique/page/Licence/4/log.txt | 1 + historique/page/Licence/4/source.txt | 34 ++++ historique/page/Licence/5/log.txt | 1 + historique/page/Licence/5/source.txt | 35 ++++ historique/page/Licence/version.txt | 1 + historique/page/Nouvelle page/0/log.txt | 1 + historique/page/Nouvelle page/version.txt | 1 + .../page/Systeme de fichiers.html/0/log.txt | 1 + .../Systeme de fichiers.html/0/source.txt | 30 ++++ .../page/Systeme de fichiers.html/1/log.txt | 1 + .../Systeme de fichiers.html/1/source.txt | 30 ++++ .../page/Systeme de fichiers.html/2/log.txt | 1 + .../Systeme de fichiers.html/2/source.txt | 47 ++++++ .../page/Systeme de fichiers.html/3/log.txt | 1 + .../Systeme de fichiers.html/3/source.txt | 47 ++++++ .../page/Systeme de fichiers.html/4/log.txt | 1 + .../page/Systeme de fichiers.html/version.txt | 1 + .../page/Système de fichiers.html/0/log.txt | 1 + .../Système de fichiers.html/0/source.txt | 47 ++++++ .../page/Système de fichiers.html/1/log.txt | 1 + .../Système de fichiers.html/version.txt | 1 + .../page/Système de fichiers/0/log.txt | 1 + .../page/Système de fichiers/0/source.txt | 47 ++++++ .../page/Système de fichiers/1/log.txt | 1 + .../page/Système de fichiers/1/source.txt | 47 ++++++ .../page/Système de fichiers/2/log.txt | 1 + .../page/Système de fichiers/2/source.txt | 55 ++++++ .../page/Système de fichiers/3/log.txt | 1 + .../page/Système de fichiers/3/source.txt | 55 ++++++ .../page/Système de fichiers/4/log.txt | 1 + .../page/Système de fichiers/4/source.txt | 55 ++++++ .../page/Système de fichiers/5/log.txt | 1 + .../page/Système de fichiers/5/source.txt | 55 ++++++ .../page/Système de fichiers/6/log.txt | 1 + .../page/Système de fichiers/6/source.txt | 57 +++++++ .../page/Système de fichiers/version.txt | 1 + historique/page/commentaires/0/log.txt | 1 + historique/page/commentaires/0/source.txt | 5 + historique/page/commentaires/1/log.txt | 1 + historique/page/commentaires/1/source.txt | 5 + historique/page/commentaires/2/log.txt | 1 + historique/page/commentaires/2/source.txt | 5 + historique/page/commentaires/version.txt | 1 + site/diff/index.php | 0 site/editer/index.php | 9 + site/historique/index.php | 0 site/image/editer.png | Bin 0 -> 1169 bytes site/image/logo.png | Bin 0 -> 1639 bytes site/image/tache.png | Bin 0 -> 1335 bytes site/image/tuxfamily.png | Bin 0 -> 1382 bytes site/login/index.php | 0 site/page/Accueil.html | 49 ++++++ site/page/Gestion des ressources.html | 49 ++++++ site/page/Interface Homme-2dMachine.html | 74 +++++++++ site/page/Langage.html | 156 ++++++++++++++++++ site/page/Licence.html | 77 +++++++++ site/page/Système de fichiers.html | 108 ++++++++++++ site/page/commentaires.html | 32 ++++ site/style/logo.js | 34 ++++ site/style/style.css | 147 +++++++++++++++++ 214 files changed, 3980 insertions(+) create mode 100644 .htaccess create mode 100644 config.php create mode 100644 fastiki/langues/en.php create mode 100644 fastiki/langues/fr.php create mode 100644 fastiki/modeles/appercu.htmlf create mode 100644 fastiki/modeles/editer.htmlf create mode 100644 fastiki/modeles/formulaire_edition.htmlf create mode 100644 fastiki/modeles/site.html create mode 100644 fastiki/modeles/typedoc/page.htmlf create mode 100644 fastiki/modeles/typedoc/tache.htmlf create mode 100644 fastiki/php/authentification.php create mode 100644 fastiki/php/cache.php create mode 100644 fastiki/php/config_defaut.php create mode 100644 fastiki/php/configuration.php create mode 100644 fastiki/php/editer.php create mode 100644 fastiki/php/fichiers.php create mode 100644 fastiki/php/fonctions.php create mode 100644 fastiki/php/historique.php create mode 100644 fastiki/php/langues.php create mode 100644 fastiki/php/modele.php create mode 100644 fastiki/php/plugin.php create mode 100644 fastiki/php/require.php create mode 100644 fastiki/php/securite.php create mode 100644 fastiki/plugins/langue.php create mode 100644 fastiki/plugins/tache.php create mode 100644 fastiki/plugins/url.php create mode 100644 fastiki/plugins/wiki.php create mode 100644 historique/log.txt create mode 100644 historique/page/Accueil/0/log.txt create mode 100644 historique/page/Accueil/0/source.txt create mode 100644 historique/page/Accueil/1/log.txt create mode 100644 historique/page/Accueil/1/source.txt create mode 100644 historique/page/Accueil/10/log.txt create mode 100644 historique/page/Accueil/10/source.txt create mode 100644 historique/page/Accueil/11/log.txt create mode 100644 historique/page/Accueil/11/source.txt create mode 100644 historique/page/Accueil/12/log.txt create mode 100644 historique/page/Accueil/12/source.txt create mode 100644 historique/page/Accueil/13/log.txt create mode 100644 historique/page/Accueil/13/source.txt create mode 100644 historique/page/Accueil/14/log.txt create mode 100644 historique/page/Accueil/14/source.txt create mode 100644 historique/page/Accueil/15/log.txt create mode 100644 historique/page/Accueil/15/source.txt create mode 100644 historique/page/Accueil/16/log.txt create mode 100644 historique/page/Accueil/16/source.txt create mode 100644 historique/page/Accueil/17/log.txt create mode 100644 historique/page/Accueil/17/source.txt create mode 100644 historique/page/Accueil/18/log.txt create mode 100644 historique/page/Accueil/18/source.txt create mode 100644 historique/page/Accueil/19/log.txt create mode 100644 historique/page/Accueil/19/source.txt create mode 100644 historique/page/Accueil/2/log.txt create mode 100644 historique/page/Accueil/2/source.txt create mode 100644 historique/page/Accueil/20/log.txt create mode 100644 historique/page/Accueil/20/source.txt create mode 100644 historique/page/Accueil/21/log.txt create mode 100644 historique/page/Accueil/21/source.txt create mode 100644 historique/page/Accueil/22/log.txt create mode 100644 historique/page/Accueil/22/source.txt create mode 100644 historique/page/Accueil/23/log.txt create mode 100644 historique/page/Accueil/23/source.txt create mode 100644 historique/page/Accueil/24/log.txt create mode 100644 historique/page/Accueil/24/source.txt create mode 100644 historique/page/Accueil/3/log.txt create mode 100644 historique/page/Accueil/3/source.txt create mode 100644 historique/page/Accueil/4/log.txt create mode 100644 historique/page/Accueil/4/source.txt create mode 100644 historique/page/Accueil/5/log.txt create mode 100644 historique/page/Accueil/5/source.txt create mode 100644 historique/page/Accueil/6/log.txt create mode 100644 historique/page/Accueil/6/source.txt create mode 100644 historique/page/Accueil/7/log.txt create mode 100644 historique/page/Accueil/7/source.txt create mode 100644 historique/page/Accueil/8/log.txt create mode 100644 historique/page/Accueil/8/source.txt create mode 100644 historique/page/Accueil/9/log.txt create mode 100644 historique/page/Accueil/9/source.txt create mode 100644 historique/page/Accueil/version.txt create mode 100644 historique/page/Gestion des ressources/0/log.txt create mode 100644 historique/page/Gestion des ressources/0/source.txt create mode 100644 historique/page/Gestion des ressources/1/log.txt create mode 100644 historique/page/Gestion des ressources/1/source.txt create mode 100644 historique/page/Gestion des ressources/2/log.txt create mode 100644 historique/page/Gestion des ressources/2/source.txt create mode 100644 historique/page/Gestion des ressources/version.txt create mode 100644 historique/page/Interface Homme-2dMachine/0/log.txt create mode 100644 historique/page/Interface Homme-2dMachine/0/source.txt create mode 100644 historique/page/Interface Homme-2dMachine/1/log.txt create mode 100644 historique/page/Interface Homme-2dMachine/1/source.txt create mode 100644 historique/page/Interface Homme-2dMachine/2/log.txt create mode 100644 historique/page/Interface Homme-2dMachine/2/source.txt create mode 100644 historique/page/Interface Homme-2dMachine/3/log.txt create mode 100644 historique/page/Interface Homme-2dMachine/3/source.txt create mode 100644 historique/page/Interface Homme-2dMachine/4/log.txt create mode 100644 historique/page/Interface Homme-2dMachine/4/source.txt create mode 100644 historique/page/Interface Homme-2dMachine/5/log.txt create mode 100644 historique/page/Interface Homme-2dMachine/5/source.txt create mode 100644 historique/page/Interface Homme-2dMachine/6/log.txt create mode 100644 historique/page/Interface Homme-2dMachine/6/source.txt create mode 100644 historique/page/Interface Homme-2dMachine/version.txt create mode 100644 historique/page/Langage/0/log.txt create mode 100644 historique/page/Langage/0/source.txt create mode 100644 historique/page/Langage/1/log.txt create mode 100644 historique/page/Langage/1/source.txt create mode 100644 historique/page/Langage/10/log.txt create mode 100644 historique/page/Langage/10/source.txt create mode 100644 historique/page/Langage/11/log.txt create mode 100644 historique/page/Langage/11/source.txt create mode 100644 historique/page/Langage/12/log.txt create mode 100644 historique/page/Langage/12/source.txt create mode 100644 historique/page/Langage/13/log.txt create mode 100644 historique/page/Langage/13/source.txt create mode 100644 historique/page/Langage/14/log.txt create mode 100644 historique/page/Langage/14/source.txt create mode 100644 historique/page/Langage/15/log.txt create mode 100644 historique/page/Langage/15/source.txt create mode 100644 historique/page/Langage/16/log.txt create mode 100644 historique/page/Langage/16/source.txt create mode 100644 historique/page/Langage/17/log.txt create mode 100644 historique/page/Langage/17/source.txt create mode 100644 historique/page/Langage/18/log.txt create mode 100644 historique/page/Langage/18/source.txt create mode 100644 historique/page/Langage/19/log.txt create mode 100644 historique/page/Langage/19/source.txt create mode 100644 historique/page/Langage/2/log.txt create mode 100644 historique/page/Langage/2/source.txt create mode 100644 historique/page/Langage/20/log.txt create mode 100644 historique/page/Langage/20/source.txt create mode 100644 historique/page/Langage/21/log.txt create mode 100644 historique/page/Langage/21/source.txt create mode 100644 historique/page/Langage/3/log.txt create mode 100644 historique/page/Langage/3/source.txt create mode 100644 historique/page/Langage/4/log.txt create mode 100644 historique/page/Langage/4/source.txt create mode 100644 historique/page/Langage/5/log.txt create mode 100644 historique/page/Langage/5/source.txt create mode 100644 historique/page/Langage/6/log.txt create mode 100644 historique/page/Langage/6/source.txt create mode 100644 historique/page/Langage/7/log.txt create mode 100644 historique/page/Langage/7/source.txt create mode 100644 historique/page/Langage/8/log.txt create mode 100644 historique/page/Langage/8/source.txt create mode 100644 historique/page/Langage/9/log.txt create mode 100644 historique/page/Langage/9/source.txt create mode 100644 historique/page/Langage/version.txt create mode 100644 historique/page/Licence/0/log.txt create mode 100644 historique/page/Licence/0/source.txt create mode 100644 historique/page/Licence/1/log.txt create mode 100644 historique/page/Licence/1/source.txt create mode 100644 historique/page/Licence/2/log.txt create mode 100644 historique/page/Licence/2/source.txt create mode 100644 historique/page/Licence/3/log.txt create mode 100644 historique/page/Licence/3/source.txt create mode 100644 historique/page/Licence/4/log.txt create mode 100644 historique/page/Licence/4/source.txt create mode 100644 historique/page/Licence/5/log.txt create mode 100644 historique/page/Licence/5/source.txt create mode 100644 historique/page/Licence/version.txt create mode 100644 historique/page/Nouvelle page/0/log.txt create mode 100644 historique/page/Nouvelle page/version.txt create mode 100644 historique/page/Systeme de fichiers.html/0/log.txt create mode 100644 historique/page/Systeme de fichiers.html/0/source.txt create mode 100644 historique/page/Systeme de fichiers.html/1/log.txt create mode 100644 historique/page/Systeme de fichiers.html/1/source.txt create mode 100644 historique/page/Systeme de fichiers.html/2/log.txt create mode 100644 historique/page/Systeme de fichiers.html/2/source.txt create mode 100644 historique/page/Systeme de fichiers.html/3/log.txt create mode 100644 historique/page/Systeme de fichiers.html/3/source.txt create mode 100644 historique/page/Systeme de fichiers.html/4/log.txt create mode 100644 historique/page/Systeme de fichiers.html/version.txt create mode 100644 historique/page/Système de fichiers.html/0/log.txt create mode 100644 historique/page/Système de fichiers.html/0/source.txt create mode 100644 historique/page/Système de fichiers.html/1/log.txt create mode 100644 historique/page/Système de fichiers.html/version.txt create mode 100644 historique/page/Système de fichiers/0/log.txt create mode 100644 historique/page/Système de fichiers/0/source.txt create mode 100644 historique/page/Système de fichiers/1/log.txt create mode 100644 historique/page/Système de fichiers/1/source.txt create mode 100644 historique/page/Système de fichiers/2/log.txt create mode 100644 historique/page/Système de fichiers/2/source.txt create mode 100644 historique/page/Système de fichiers/3/log.txt create mode 100644 historique/page/Système de fichiers/3/source.txt create mode 100644 historique/page/Système de fichiers/4/log.txt create mode 100644 historique/page/Système de fichiers/4/source.txt create mode 100644 historique/page/Système de fichiers/5/log.txt create mode 100644 historique/page/Système de fichiers/5/source.txt create mode 100644 historique/page/Système de fichiers/6/log.txt create mode 100644 historique/page/Système de fichiers/6/source.txt create mode 100644 historique/page/Système de fichiers/version.txt create mode 100644 historique/page/commentaires/0/log.txt create mode 100644 historique/page/commentaires/0/source.txt create mode 100644 historique/page/commentaires/1/log.txt create mode 100644 historique/page/commentaires/1/source.txt create mode 100644 historique/page/commentaires/2/log.txt create mode 100644 historique/page/commentaires/2/source.txt create mode 100644 historique/page/commentaires/version.txt create mode 100644 site/diff/index.php create mode 100644 site/editer/index.php create mode 100644 site/historique/index.php create mode 100644 site/image/editer.png create mode 100644 site/image/logo.png create mode 100644 site/image/tache.png create mode 100644 site/image/tuxfamily.png create mode 100644 site/login/index.php create mode 100644 site/page/Accueil.html create mode 100644 site/page/Gestion des ressources.html create mode 100644 site/page/Interface Homme-2dMachine.html create mode 100644 site/page/Langage.html create mode 100644 site/page/Licence.html create mode 100644 site/page/Système de fichiers.html create mode 100644 site/page/commentaires.html create mode 100644 site/style/logo.js create mode 100644 site/style/style.css diff --git a/.htaccess b/.htaccess new file mode 100644 index 0000000..0747874 --- /dev/null +++ b/.htaccess @@ -0,0 +1,17 @@ + +RewriteEngine On +RewriteBase / +RewriteRule ^$ ./site/page/Accueil.html [PT,L] + +RewriteCond %{REQUEST_URI} !^/site/ +RewriteRule (.*) /site/$1 [NC] + +RewriteCond %{REQUEST_URI} !^/site/page/ +RewriteCond %{REQUEST_URI} !^/diff/ +RewriteCond %{REQUEST_URI} !^/editer/ +RewriteCond %{REQUEST_URI} !^/historique/ +RewriteCond %{REQUEST_URI} !^/image/ +RewriteCond %{REQUEST_URI} !^/login/ +RewriteCond %{REQUEST_URI} !^/style/ +RewriteCond %{REQUEST_URI} !^/utilisateur/ +RewriteRule /site/(.*) /site/page/$1 [L] diff --git a/config.php b/config.php new file mode 100644 index 0000000..437dbf4 --- /dev/null +++ b/config.php @@ -0,0 +1,8 @@ + diff --git a/fastiki/langues/en.php b/fastiki/langues/en.php new file mode 100644 index 0000000..83a92a1 --- /dev/null +++ b/fastiki/langues/en.php @@ -0,0 +1,11 @@ + \ No newline at end of file diff --git a/fastiki/langues/fr.php b/fastiki/langues/fr.php new file mode 100644 index 0000000..60f1b09 --- /dev/null +++ b/fastiki/langues/fr.php @@ -0,0 +1,11 @@ + \ No newline at end of file diff --git a/fastiki/modeles/appercu.htmlf b/fastiki/modeles/appercu.htmlf new file mode 100644 index 0000000..862f5ab --- /dev/null +++ b/fastiki/modeles/appercu.htmlf @@ -0,0 +1,4 @@ +

{{{lang:Apperçu}}}

+${contenu} +

{{{lang:Edition de la page}}} ${he:nom page}

+${formulaire_edition} \ No newline at end of file diff --git a/fastiki/modeles/editer.htmlf b/fastiki/modeles/editer.htmlf new file mode 100644 index 0000000..e7b0402 --- /dev/null +++ b/fastiki/modeles/editer.htmlf @@ -0,0 +1,2 @@ +

{{{lang:Edition de la page}}} ${he:nom page}

+${formulaire_edition} \ No newline at end of file diff --git a/fastiki/modeles/formulaire_edition.htmlf b/fastiki/modeles/formulaire_edition.htmlf new file mode 100644 index 0000000..2cddd40 --- /dev/null +++ b/fastiki/modeles/formulaire_edition.htmlf @@ -0,0 +1,12 @@ +
+

+ +

+

+ +

+

+ + +

+
\ No newline at end of file diff --git a/fastiki/modeles/site.html b/fastiki/modeles/site.html new file mode 100644 index 0000000..cc66b7c --- /dev/null +++ b/fastiki/modeles/site.html @@ -0,0 +1,29 @@ + + + + + ${he:nom page} + + + + +

+ Gruntnetwork ⁃ + + {{{lang:Accueil}}} ⁃ + {{{lang:Éditer}}} + +

+
+
+ ${contenu} +
+
+

+ Hébergé par tuxfamily. + {{{lang:Licence}}} + Màj : ${he:datenbsp} + +

+ + diff --git a/fastiki/modeles/typedoc/page.htmlf b/fastiki/modeles/typedoc/page.htmlf new file mode 100644 index 0000000..6b95c0a --- /dev/null +++ b/fastiki/modeles/typedoc/page.htmlf @@ -0,0 +1 @@ +${contenu} \ No newline at end of file diff --git a/fastiki/modeles/typedoc/tache.htmlf b/fastiki/modeles/typedoc/tache.htmlf new file mode 100644 index 0000000..eb6a05a --- /dev/null +++ b/fastiki/modeles/typedoc/tache.htmlf @@ -0,0 +1,7 @@ +

Tâche : ${titre}

+
+
Dependances :
+
${dependances}
+
+

Description

+${contenu} \ No newline at end of file diff --git a/fastiki/php/authentification.php b/fastiki/php/authentification.php new file mode 100644 index 0000000..0ac4d16 --- /dev/null +++ b/fastiki/php/authentification.php @@ -0,0 +1,9 @@ + \ No newline at end of file diff --git a/fastiki/php/cache.php b/fastiki/php/cache.php new file mode 100644 index 0000000..2774e0b --- /dev/null +++ b/fastiki/php/cache.php @@ -0,0 +1,15 @@ + \ No newline at end of file diff --git a/fastiki/php/config_defaut.php b/fastiki/php/config_defaut.php new file mode 100644 index 0000000..f0a55bf --- /dev/null +++ b/fastiki/php/config_defaut.php @@ -0,0 +1,42 @@ + diff --git a/fastiki/php/configuration.php b/fastiki/php/configuration.php new file mode 100644 index 0000000..d44b1bc --- /dev/null +++ b/fastiki/php/configuration.php @@ -0,0 +1,41 @@ + \ No newline at end of file diff --git a/fastiki/php/editer.php b/fastiki/php/editer.php new file mode 100644 index 0000000..6ad43d0 --- /dev/null +++ b/fastiki/php/editer.php @@ -0,0 +1,56 @@ + auth_get_user(), + "date" => date("r"), + "datenbsp" => preg_replace("| |", " ", date("r")), // space -> no-break space + "logo" => "editer.png", + "source" => $source, + "nom page" => $nom_page, + "nouveau nom page" => $nouveau_nom_page + ); + + return compiler_page_modele("formulaire_edition.htmlf", $tags_source, $nom_resultat); + } + + function editer($nom_page, $nouveau_nom_page) { + $nom_page = desecuriser_chaine($nom_page); + $nouveau_nom_page = desecuriser_chaine($nouveau_nom_page); + + if (post_has("appliquer")) { + $source = dos2unix($_POST["source"]); + + $tags_contenu = compiler_source($nouveau_nom_page, $source, "contenu"); + $tags_site = compiler_page_modele("site.html", $tags_contenu, "contenu"); + + // TODO : Homogénéiser les noms. + // mettre_a_jour_cache("source compilee", $nom_page, $nouveau_nom_page, $tags_contenu); + mettre_a_jour_cache("page", $nom_page, $nouveau_nom_page, $tags_site); + historique_modifier_source(auth_get_user(), $nom_page, $nouveau_nom_page, $source); + + header("HTTP/1.0 302 Redirect"); + header("Location: " . url("page", $nouveau_nom_page)); + + return ""; + } else if (post_has("appercu")) { + $source = dos2unix($_POST["source"]); + + $tags_formulaire_edition = generer_formulaire_edition($nom_page, $nouveau_nom_page, $source, "formulaire_edition"); + $tags_contenu = compiler_source($nouveau_nom_page, $source, "contenu"); + $tags_appercu = compiler_page_modele("appercu.htmlf", array_merge($tags_contenu, $tags_formulaire_edition), "contenu"); + $tags_site = compiler_page_modele("site.html", $tags_appercu, "contenu"); + + return $tags_site["contenu"]; + } else { + $source = lire_source($nom_page, "page\n\n= $nom_page ="); + + $tags_formulaire_edition = generer_formulaire_edition($nom_page, $nom_page, $source, "formulaire_edition"); + $tags_editer = compiler_page_modele("editer.htmlf", $tags_formulaire_edition, "contenu"); + $tags_site = compiler_page_modele("site.html", $tags_editer, "contenu"); + + return $tags_site["contenu"]; + } + } +?> diff --git a/fastiki/php/fichiers.php b/fastiki/php/fichiers.php new file mode 100644 index 0000000..c9a1871 --- /dev/null +++ b/fastiki/php/fichiers.php @@ -0,0 +1,35 @@ + \ No newline at end of file diff --git a/fastiki/php/fonctions.php b/fastiki/php/fonctions.php new file mode 100644 index 0000000..c3931ad --- /dev/null +++ b/fastiki/php/fonctions.php @@ -0,0 +1,65 @@ + $v) + $a[$k] = $a[$k][$index]; + return $a; + } + + function preg_find_delete($regexp, &$donnees, $match = NULL, $submatch = NULL, $limit = -1) { + preg_match_all($regexp, $donnees, $matches); + if (!is_null($match)) + $matches = subarrays($matches, $match); + if (!is_null($submatch)) + $matches = $matches[$submatch]; + + $donnees = preg_replace($regexp, "", $donnees, $limit); + return $matches; + } +?> \ No newline at end of file diff --git a/fastiki/php/historique.php b/fastiki/php/historique.php new file mode 100644 index 0000000..f6dc1f6 --- /dev/null +++ b/fastiki/php/historique.php @@ -0,0 +1,153 @@ + diff --git a/fastiki/php/langues.php b/fastiki/php/langues.php new file mode 100644 index 0000000..d080376 --- /dev/null +++ b/fastiki/php/langues.php @@ -0,0 +1,48 @@ + \ No newline at end of file diff --git a/fastiki/php/modele.php b/fastiki/php/modele.php new file mode 100644 index 0000000..b295a59 --- /dev/null +++ b/fastiki/php/modele.php @@ -0,0 +1,20 @@ + \ No newline at end of file diff --git a/fastiki/php/plugin.php b/fastiki/php/plugin.php new file mode 100644 index 0000000..708d1f3 --- /dev/null +++ b/fastiki/php/plugin.php @@ -0,0 +1,51 @@ + auth_get_user(), + "date" => date("r"), + "datenbsp" => preg_replace("| |", " ", date("r")), // space -> no-break space + "logo" => "logo.png", + "source" => $source, + "nom page" => $nom_page, + "typedoc" => $typedoc, + $nom_resultat => $matches[2] + ); + + $tags = appliquer_plugins("typedoc_".$tags["typedoc"], $tags, $nom_resultat); + $tags = appliquer_plugins("base", $tags, $nom_resultat); + $tags = compiler_page_modele("typedoc/".$tags["typedoc"].".htmlf", $tags, $nom_resultat); + + return $tags; + } + + function charger_plugins() { + if (! $dossier = @opendir(get_cfg("dossier", "plugins"))) + die ("N'a pas pu ouvrir '" . get_cfg("dossier", "plugins") . "'."); + + while ($fichier = readdir($dossier)) + if (preg_match("/\.php$/", $fichier) != 0) + include_once(get_cfg("dossier", "plugins") . "/" . $fichier); + } +?> diff --git a/fastiki/php/require.php b/fastiki/php/require.php new file mode 100644 index 0000000..74d0883 --- /dev/null +++ b/fastiki/php/require.php @@ -0,0 +1,16 @@ + \ No newline at end of file diff --git a/fastiki/php/securite.php b/fastiki/php/securite.php new file mode 100644 index 0000000..9bf95a3 --- /dev/null +++ b/fastiki/php/securite.php @@ -0,0 +1,51 @@ + \ No newline at end of file diff --git a/fastiki/plugins/langue.php b/fastiki/plugins/langue.php new file mode 100644 index 0000000..c715a19 --- /dev/null +++ b/fastiki/plugins/langue.php @@ -0,0 +1,18 @@ + \ No newline at end of file diff --git a/fastiki/plugins/tache.php b/fastiki/plugins/tache.php new file mode 100644 index 0000000..bae5c39 --- /dev/null +++ b/fastiki/plugins/tache.php @@ -0,0 +1,44 @@ +
' + . 'tâche' + . '

' + . $donnees + . '

'; + } + + function tache_base($tags, $nom_resultat) { + $donnees = $tags[$nom_resultat]; + + $donnees = preg_replace('/{{{TACHE:(.*)}}}/Ume', + "'$1')", + $donnees); + + $donnees = preg_replace('/(.*)<\/tache>/Use', + "taches_formater_tache_inline(unquote('$1'))", + $donnees); + + $donnees = preg_replace('/

\s*<\/p>/m', '', $donnees); + + $tags[$nom_resultat] = $donnees; + return $tags; + } + + function tache_typedoc_tache($tags, $nom_resultat) { + $donnees = $tags[$nom_resultat]; + + $tags["logo"] = "tache.png"; + $tags["niveau entetes"] = 1; + + $tags["titre"] = preg_find_delete("|^=\s*(.*?)\s*=$|m", $donnees, 0, 1, 1); + + $dependances = preg_find_delete("|^(.*?)$|m", $donnees, NULL, 1); + $dependances = preg_replace("|^.*$|e", "'$0')", $dependances); + $tags["dependances"] = implode(", ", $dependances); + + $tags[$nom_resultat] = $donnees; + return $tags; + } + + enregisterPlugin("tache"); +?> \ No newline at end of file diff --git a/fastiki/plugins/url.php b/fastiki/plugins/url.php new file mode 100644 index 0000000..6b537c9 --- /dev/null +++ b/fastiki/plugins/url.php @@ -0,0 +1,28 @@ + \ No newline at end of file diff --git a/fastiki/plugins/wiki.php b/fastiki/plugins/wiki.php new file mode 100644 index 0000000..556702e --- /dev/null +++ b/fastiki/plugins/wiki.php @@ -0,0 +1,98 @@ + $niveau_precedent) { + $resultat .= str_repeat("

\n", $niveau_precedent - $niveau); + if ($niveau > 0 && $ligne != "") + $resultat .= "\n
  • \n$ligne\n"; + } + + $niveau_precedent = $niveau; + } + + $resultat .= str_repeat("
    • \n\n", $niveau_precedent); + return $resultat; + } + + function wiki_formater_lien($lien_externe, $lien) { + preg_match("/^([^#|]*)#?([^|]*)\|?(.*)$/", $lien, $matches); + $nom_page = $matches[1]; + $nom_ancre = $matches[2]; + $texte_lien = $matches[3]; + + if ($nom_page == "" && $nom_ancre == "") + return $texte_lien; + + if ($texte_lien == "") { + if ($nom_page != "") + $texte_lien = $nom_page; + else + $texte_lien = $nom_ancre; + } + + if ($nom_page != "") { + if ($lien_externe == "") { + $url_lien = url("page", $nom_page); + } else { + $url_lien = htmlentities($nom_page, ENT_QUOTES, "UTF-8"); + } + } + + if ($nom_ancre != "") + $url_lien .= "#" . htmlentities(urlencode($nom_ancre), ENT_QUOTES, "UTF-8"); + + return "" . $texte_lien . ""; + } + + function wiki_base($tags, $nom_resultat) { + $donnees = $tags[$nom_resultat]; + $tags["niveau entetes"] = ($tags["niveau entetes"] != "") ? $tags["niveau entetes"] : 0; + $niveau_entetes = $tags["niveau entetes"]; + + /* === Titres === */ + $donnees = preg_replace('/^(={1,6})\s*(.*?)\s*\1$/me', + '"\n

    \n$2\n

    "', + $donnees); + + /* '''Emphases''' */ + $donnees = preg_replace("/'''''(.*)'''''/Um", '$1', $donnees); /* À éviter */ + $donnees = preg_replace("/'''(.*)'''/Um", '$1', $donnees); + $donnees = preg_replace("/''(.*)''/Um", '$1', $donnees); + + /* [Liens internes] et [[liens externes]] */ + // TODO : capture : [xyz]], le 2e ] ne devrait être capturé que s'il y en a deux au début. + $donnees = preg_replace('/\[(\[?)([^]]*?)\]\]?/me', "wiki_formater_lien('$1', unquote('$2'))", $donnees); + + /* * Listes */ + $donnees = preg_replace('/^([ \t]*\*[ \t*]+.*\n?)+/me', + "'\n

    \n' . wiki_formater_liste(unquote('$0')) . '

    \n'", + $donnees); + + /* Paragraphes (les lignes vides séparent les paragraphes) */ + $donnees = preg_replace('/^/', "

    \n", $donnees); + $donnees = preg_replace('/$/D', "\n

    ", $donnees); + $donnees = preg_replace('/^\n/m', "\n

    \n

    \n", $donnees); + $donnees = preg_replace('/

    \s*<\/p>/m', '', $donnees); + + /* Nettoyage du code xhtml */ + $donnees = preg_replace('/^\n/m', '', $donnees); + $donnees = preg_replace('/(

    )([^\n])/m', "$1\n$2", $donnees); + + $tags[$nom_resultat] = $donnees; + return $tags; + } + + enregisterPlugin("wiki"); +?> \ No newline at end of file diff --git a/historique/log.txt b/historique/log.txt new file mode 100644 index 0000000..7f8021f --- /dev/null +++ b/historique/log.txt @@ -0,0 +1,81 @@ +1259271912 js RenomerDepuis Accueil 0 Nouvelle-20page -2d1 +1259271912 js RenomerVers Nouvelle-20page 0 Accueil 0 +1259271949 js Creer Accueil 1 -vide -vide +1259271985 js Creer Accueil 2 -vide -vide +1259278974 js Creer Langage 0 -vide -vide +1259280194 js Creer Langage 1 -vide -vide +1259299917 js Creer Langage 2 -vide -vide +1259299944 js Creer Accueil 3 -vide -vide +1259300616 js Creer Accueil 4 -vide -vide +1259300699 js Creer Langage 3 -vide -vide +1259309964 js Creer Accueil 5 -vide -vide +1259310464 js Creer Accueil 6 -vide -vide +1259310683 js Creer Accueil 7 -vide -vide +1259311081 js Creer Langage 4 -vide -vide +1259313898 js Creer Accueil 8 -vide -vide +1259314263 js Creer Langage 5 -vide -vide +1259314280 js Creer Langage 6 -vide -vide +1259323247 js Creer Accueil 9 -vide -vide +1259323264 js Creer Langage 7 -vide -vide +1259323845 js Creer Accueil 10 -vide -vide +1259323861 js Creer Accueil 11 -vide -vide +1259323919 js Creer Accueil 12 -vide -vide +1259323971 js Creer Accueil 13 -vide -vide +1259521261 js Creer Langage 8 -vide -vide +1259521286 js Creer Accueil 14 -vide -vide +1259603152 js Creer Langage 9 -vide -vide +1259755329 js Creer Accueil 15 -vide -vide +1259755367 js Creer Langage 10 -vide -vide +1259767145 js Creer Langage 11 -vide -vide +1259770272 js Creer Langage 12 -vide -vide +1259784652 js Creer Langage 13 -vide -vide +1259784950 js Creer Langage 14 -vide -vide +1259785546 js Creer Langage 15 -vide -vide +1259792637 js Creer Langage 16 -vide -vide +1259837196 js Creer Langage 17 -vide -vide +1259839115 js Creer Langage 18 -vide -vide +1259839143 js Creer Langage 19 -vide -vide +1259841424 js Creer Interface-20Homme-2dMachine 0 -vide -vide +1259841472 js Creer Accueil 16 -vide -vide +1259841488 js Creer Interface-20Homme-2dMachine 1 -vide -vide +1259846394 js Creer Interface-20Homme-2dMachine 2 -vide -vide +1259846709 js Creer Interface-20Homme-2dMachine 3 -vide -vide +1259853267 js Creer Interface-20Homme-2dMachine 4 -vide -vide +1259853400 js Creer Accueil 17 -vide -vide +1259853421 js Creer Accueil 18 -vide -vide +1259863232 js Creer Systeme-20de-20fichiers.html 0 -vide -vide +1259863251 js Creer Systeme-20de-20fichiers.html 1 -vide -vide +1259867335 js Creer Systeme-20de-20fichiers.html 2 -vide -vide +1259869519 js Creer Systeme-20de-20fichiers.html 3 -vide -vide +1259869533 js RenomerDepuis Système-20de-20fichiers.html 0 Systeme-20de-20fichiers.html 3 +1259869533 js RenomerVers Systeme-20de-20fichiers.html 4 Système-20de-20fichiers.html 0 +1259869730 js RenomerDepuis Système-20de-20fichiers 0 Système-20de-20fichiers.html 0 +1259869730 js RenomerVers Système-20de-20fichiers.html 1 Système-20de-20fichiers 0 +1259869760 js Creer Système-20de-20fichiers 1 -vide -vide +1259870498 js Creer Gestion-20des-20ressources 0 -vide -vide +1259966078 js Creer Système-20de-20fichiers 2 -vide -vide +1259966204 js Creer Accueil 19 -vide -vide +1259966234 js Creer commentaires 0 -vide -vide +1260009715 js Creer Licence 0 -vide -vide +1260009733 js Creer Accueil 20 -vide -vide +1260009744 js Creer Langage 20 -vide -vide +1260009754 js Creer Interface-20Homme-2dMachine 5 -vide -vide +1260009780 js Creer Système-20de-20fichiers 3 -vide -vide +1260009798 js Creer Gestion-20des-20ressources 1 -vide -vide +1260009853 js Creer commentaires 1 -vide -vide +1260025956 js Creer Licence 1 -vide -vide +1260026797 js Creer Licence 2 -vide -vide +1260026929 js Creer Licence 3 -vide -vide +1260027054 js Creer Licence 4 -vide -vide +1260027296 js Creer Licence 5 -vide -vide +1260466408 js Creer Accueil 21 -vide -vide +1260466430 js Creer Langage 21 -vide -vide +1260466435 js Creer Interface-20Homme-2dMachine 6 -vide -vide +1260466445 js Creer Système-20de-20fichiers 4 -vide -vide +1260466460 js Creer Gestion-20des-20ressources 2 -vide -vide +1260466465 js Creer commentaires 2 -vide -vide +1260637053 js Creer Système-20de-20fichiers 5 -vide -vide +1260637302 js Creer Système-20de-20fichiers 6 -vide -vide +1261649474 js Creer Accueil 22 -vide -vide +1264309582 js Creer Accueil 23 -vide -vide +1264533981 js Creer Accueil 24 -vide -vide diff --git a/historique/page/Accueil/0/log.txt b/historique/page/Accueil/0/log.txt new file mode 100644 index 0000000..89be934 --- /dev/null +++ b/historique/page/Accueil/0/log.txt @@ -0,0 +1 @@ +1259271912 js RenomerDepuis Accueil 0 Nouvelle-20page -2d1 diff --git a/historique/page/Accueil/0/source.txt b/historique/page/Accueil/0/source.txt new file mode 100644 index 0000000..bd6c7e5 --- /dev/null +++ b/historique/page/Accueil/0/source.txt @@ -0,0 +1,5 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation construit (et programmable) avec un langage de programmation graphique. \ No newline at end of file diff --git a/historique/page/Accueil/1/log.txt b/historique/page/Accueil/1/log.txt new file mode 100644 index 0000000..092053b --- /dev/null +++ b/historique/page/Accueil/1/log.txt @@ -0,0 +1 @@ +1259271949 js Creer Accueil 1 -vide -vide diff --git a/historique/page/Accueil/1/source.txt b/historique/page/Accueil/1/source.txt new file mode 100644 index 0000000..bd6c7e5 --- /dev/null +++ b/historique/page/Accueil/1/source.txt @@ -0,0 +1,5 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation construit (et programmable) avec un langage de programmation graphique. \ No newline at end of file diff --git a/historique/page/Accueil/10/log.txt b/historique/page/Accueil/10/log.txt new file mode 100644 index 0000000..b7d7e6c --- /dev/null +++ b/historique/page/Accueil/10/log.txt @@ -0,0 +1 @@ +1259323845 js Creer Accueil 10 -vide -vide diff --git a/historique/page/Accueil/10/source.txt b/historique/page/Accueil/10/source.txt new file mode 100644 index 0000000..952ab12 --- /dev/null +++ b/historique/page/Accueil/10/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * Le modèle d'exécution est [Orienté document|orienté document], et non processus ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/11/log.txt b/historique/page/Accueil/11/log.txt new file mode 100644 index 0000000..8f0c77e --- /dev/null +++ b/historique/page/Accueil/11/log.txt @@ -0,0 +1 @@ +1259323861 js Creer Accueil 11 -vide -vide diff --git a/historique/page/Accueil/11/source.txt b/historique/page/Accueil/11/source.txt new file mode 100644 index 0000000..952ab12 --- /dev/null +++ b/historique/page/Accueil/11/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * Le modèle d'exécution est [Orienté document|orienté document], et non processus ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/12/log.txt b/historique/page/Accueil/12/log.txt new file mode 100644 index 0000000..9a84c96 --- /dev/null +++ b/historique/page/Accueil/12/log.txt @@ -0,0 +1 @@ +1259323919 js Creer Accueil 12 -vide -vide diff --git a/historique/page/Accueil/12/source.txt b/historique/page/Accueil/12/source.txt new file mode 100644 index 0000000..952ab12 --- /dev/null +++ b/historique/page/Accueil/12/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * Le modèle d'exécution est [Orienté document|orienté document], et non processus ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/13/log.txt b/historique/page/Accueil/13/log.txt new file mode 100644 index 0000000..78bdcbc --- /dev/null +++ b/historique/page/Accueil/13/log.txt @@ -0,0 +1 @@ +1259323971 js Creer Accueil 13 -vide -vide diff --git a/historique/page/Accueil/13/source.txt b/historique/page/Accueil/13/source.txt new file mode 100644 index 0000000..952ab12 --- /dev/null +++ b/historique/page/Accueil/13/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * Le modèle d'exécution est [Orienté document|orienté document], et non processus ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/14/log.txt b/historique/page/Accueil/14/log.txt new file mode 100644 index 0000000..5ab977a --- /dev/null +++ b/historique/page/Accueil/14/log.txt @@ -0,0 +1 @@ +1259521286 js Creer Accueil 14 -vide -vide diff --git a/historique/page/Accueil/14/source.txt b/historique/page/Accueil/14/source.txt new file mode 100644 index 0000000..952ab12 --- /dev/null +++ b/historique/page/Accueil/14/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * Le modèle d'exécution est [Orienté document|orienté document], et non processus ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/15/log.txt b/historique/page/Accueil/15/log.txt new file mode 100644 index 0000000..1e0f71c --- /dev/null +++ b/historique/page/Accueil/15/log.txt @@ -0,0 +1 @@ +1259755329 js Creer Accueil 15 -vide -vide diff --git a/historique/page/Accueil/15/source.txt b/historique/page/Accueil/15/source.txt new file mode 100644 index 0000000..3abd862 --- /dev/null +++ b/historique/page/Accueil/15/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * L'interface homme-machine [Orienté document|orientée document], et non processus, est [Génération semi-automatique d'IHM|générée semi-automatiquement] ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/16/log.txt b/historique/page/Accueil/16/log.txt new file mode 100644 index 0000000..cfe6286 --- /dev/null +++ b/historique/page/Accueil/16/log.txt @@ -0,0 +1 @@ +1259841472 js Creer Accueil 16 -vide -vide diff --git a/historique/page/Accueil/16/source.txt b/historique/page/Accueil/16/source.txt new file mode 100644 index 0000000..4c8176a --- /dev/null +++ b/historique/page/Accueil/16/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * L'interface homme-machine [Interface Homme-Machine#Interface orientée document|orientée document], et non processus, est [Interface Homme-Machine#Génération semi-automatique|générée semi-automatiquement] ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/17/log.txt b/historique/page/Accueil/17/log.txt new file mode 100644 index 0000000..756d348 --- /dev/null +++ b/historique/page/Accueil/17/log.txt @@ -0,0 +1 @@ +1259853400 js Creer Accueil 17 -vide -vide diff --git a/historique/page/Accueil/17/source.txt b/historique/page/Accueil/17/source.txt new file mode 100644 index 0000000..4c8176a --- /dev/null +++ b/historique/page/Accueil/17/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * L'interface homme-machine [Interface Homme-Machine#Interface orientée document|orientée document], et non processus, est [Interface Homme-Machine#Génération semi-automatique|générée semi-automatiquement] ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/18/log.txt b/historique/page/Accueil/18/log.txt new file mode 100644 index 0000000..92212bc --- /dev/null +++ b/historique/page/Accueil/18/log.txt @@ -0,0 +1 @@ +1259853421 js Creer Accueil 18 -vide -vide diff --git a/historique/page/Accueil/18/source.txt b/historique/page/Accueil/18/source.txt new file mode 100644 index 0000000..1cc2032 --- /dev/null +++ b/historique/page/Accueil/18/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * L'interface homme-machine [Interface Homme-Machine#Interface orientée document|orientée document], et non processus, est [Interface Homme-Machine#Génération semi-automatique|générée semi-automatiquement] ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/19/log.txt b/historique/page/Accueil/19/log.txt new file mode 100644 index 0000000..9fbb23e --- /dev/null +++ b/historique/page/Accueil/19/log.txt @@ -0,0 +1 @@ +1259966204 js Creer Accueil 19 -vide -vide diff --git a/historique/page/Accueil/19/source.txt b/historique/page/Accueil/19/source.txt new file mode 100644 index 0000000..474ae11 --- /dev/null +++ b/historique/page/Accueil/19/source.txt @@ -0,0 +1,11 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * L'interface homme-machine [Interface Homme-Machine#Interface orientée document|orientée document], et non processus, est [Interface Homme-Machine#Génération semi-automatique|générée semi-automatiquement] ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. + +Vous pouvez laisser des [commentaires] si vous en avez. \ No newline at end of file diff --git a/historique/page/Accueil/2/log.txt b/historique/page/Accueil/2/log.txt new file mode 100644 index 0000000..6d18b05 --- /dev/null +++ b/historique/page/Accueil/2/log.txt @@ -0,0 +1 @@ +1259271985 js Creer Accueil 2 -vide -vide diff --git a/historique/page/Accueil/2/source.txt b/historique/page/Accueil/2/source.txt new file mode 100644 index 0000000..bd6c7e5 --- /dev/null +++ b/historique/page/Accueil/2/source.txt @@ -0,0 +1,5 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation construit (et programmable) avec un langage de programmation graphique. \ No newline at end of file diff --git a/historique/page/Accueil/20/log.txt b/historique/page/Accueil/20/log.txt new file mode 100644 index 0000000..421e82a --- /dev/null +++ b/historique/page/Accueil/20/log.txt @@ -0,0 +1 @@ +1260009733 js Creer Accueil 20 -vide -vide diff --git a/historique/page/Accueil/20/source.txt b/historique/page/Accueil/20/source.txt new file mode 100644 index 0000000..474ae11 --- /dev/null +++ b/historique/page/Accueil/20/source.txt @@ -0,0 +1,11 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * L'interface homme-machine [Interface Homme-Machine#Interface orientée document|orientée document], et non processus, est [Interface Homme-Machine#Génération semi-automatique|générée semi-automatiquement] ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. + +Vous pouvez laisser des [commentaires] si vous en avez. \ No newline at end of file diff --git a/historique/page/Accueil/21/log.txt b/historique/page/Accueil/21/log.txt new file mode 100644 index 0000000..e30b236 --- /dev/null +++ b/historique/page/Accueil/21/log.txt @@ -0,0 +1 @@ +1260466408 js Creer Accueil 21 -vide -vide diff --git a/historique/page/Accueil/21/source.txt b/historique/page/Accueil/21/source.txt new file mode 100644 index 0000000..474ae11 --- /dev/null +++ b/historique/page/Accueil/21/source.txt @@ -0,0 +1,11 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * L'interface homme-machine [Interface Homme-Machine#Interface orientée document|orientée document], et non processus, est [Interface Homme-Machine#Génération semi-automatique|générée semi-automatiquement] ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. + +Vous pouvez laisser des [commentaires] si vous en avez. \ No newline at end of file diff --git a/historique/page/Accueil/22/log.txt b/historique/page/Accueil/22/log.txt new file mode 100644 index 0000000..3301e0a --- /dev/null +++ b/historique/page/Accueil/22/log.txt @@ -0,0 +1 @@ +1261649474 js Creer Accueil 22 -vide -vide diff --git a/historique/page/Accueil/22/source.txt b/historique/page/Accueil/22/source.txt new file mode 100644 index 0000000..d3d48b5 --- /dev/null +++ b/historique/page/Accueil/22/source.txt @@ -0,0 +1,11 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * L'interface homme-machine [Interface Homme-Machine#Interface orientée document|orientée document], et non processus, est [Interface Homme-Machine#Génération semi-automatique|générée semi-automatiquement] ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisamment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. + +Vous pouvez laisser des [commentaires] si vous en avez. \ No newline at end of file diff --git a/historique/page/Accueil/23/log.txt b/historique/page/Accueil/23/log.txt new file mode 100644 index 0000000..01e4529 --- /dev/null +++ b/historique/page/Accueil/23/log.txt @@ -0,0 +1 @@ +1264309582 js Creer Accueil 23 -vide -vide diff --git a/historique/page/Accueil/23/source.txt b/historique/page/Accueil/23/source.txt new file mode 100644 index 0000000..61d5cfb --- /dev/null +++ b/historique/page/Accueil/23/source.txt @@ -0,0 +1 @@ +cfZXLF nctpsqlxetsn, [url=http://dfzcmrhhkbee.com/]dfzcmrhhkbee[/url], [link=http://xkaqpslgpmeu.com/]xkaqpslgpmeu[/link], http://ebnlhzwdljim.com/ \ No newline at end of file diff --git a/historique/page/Accueil/24/log.txt b/historique/page/Accueil/24/log.txt new file mode 100644 index 0000000..b7919c3 --- /dev/null +++ b/historique/page/Accueil/24/log.txt @@ -0,0 +1 @@ +1264533981 js Creer Accueil 24 -vide -vide diff --git a/historique/page/Accueil/24/source.txt b/historique/page/Accueil/24/source.txt new file mode 100644 index 0000000..3ba07f2 --- /dev/null +++ b/historique/page/Accueil/24/source.txt @@ -0,0 +1,11 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * L'interface homme-machine [Interface Homme-Machine#Interface orientée document|orientée document], et non processus, est [Interface Homme-Machine#Génération semi-automatique|générée semi-automatiquement] ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisamment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. + +Vous pouvez laisser des [commentaires] si vous en avez. \ No newline at end of file diff --git a/historique/page/Accueil/3/log.txt b/historique/page/Accueil/3/log.txt new file mode 100644 index 0000000..2efd847 --- /dev/null +++ b/historique/page/Accueil/3/log.txt @@ -0,0 +1 @@ +1259299944 js Creer Accueil 3 -vide -vide diff --git a/historique/page/Accueil/3/source.txt b/historique/page/Accueil/3/source.txt new file mode 100644 index 0000000..40715fb --- /dev/null +++ b/historique/page/Accueil/3/source.txt @@ -0,0 +1,5 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation construit (et programmable) avec un [langage|langage de programmation graphique]. \ No newline at end of file diff --git a/historique/page/Accueil/4/log.txt b/historique/page/Accueil/4/log.txt new file mode 100644 index 0000000..9a364cd --- /dev/null +++ b/historique/page/Accueil/4/log.txt @@ -0,0 +1 @@ +1259300616 js Creer Accueil 4 -vide -vide diff --git a/historique/page/Accueil/4/source.txt b/historique/page/Accueil/4/source.txt new file mode 100644 index 0000000..ba5e815 --- /dev/null +++ b/historique/page/Accueil/4/source.txt @@ -0,0 +1,5 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation construit (et programmable) avec un [Langage|langage de programmation graphique]. Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles. Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, ... De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/5/log.txt b/historique/page/Accueil/5/log.txt new file mode 100644 index 0000000..55de5ff --- /dev/null +++ b/historique/page/Accueil/5/log.txt @@ -0,0 +1 @@ +1259309964 js Creer Accueil 5 -vide -vide diff --git a/historique/page/Accueil/5/source.txt b/historique/page/Accueil/5/source.txt new file mode 100644 index 0000000..584b52c --- /dev/null +++ b/historique/page/Accueil/5/source.txt @@ -0,0 +1,5 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation construit (et programmable) avec un [Langage|langage de programmation graphique]. Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles. Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/6/log.txt b/historique/page/Accueil/6/log.txt new file mode 100644 index 0000000..9dc5c0e --- /dev/null +++ b/historique/page/Accueil/6/log.txt @@ -0,0 +1 @@ +1259310464 js Creer Accueil 6 -vide -vide diff --git a/historique/page/Accueil/6/source.txt b/historique/page/Accueil/6/source.txt new file mode 100644 index 0000000..952ab12 --- /dev/null +++ b/historique/page/Accueil/6/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * Le modèle d'exécution est [Orienté document|orienté document], et non processus ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/7/log.txt b/historique/page/Accueil/7/log.txt new file mode 100644 index 0000000..4bfd55c --- /dev/null +++ b/historique/page/Accueil/7/log.txt @@ -0,0 +1 @@ +1259310683 js Creer Accueil 7 -vide -vide diff --git a/historique/page/Accueil/7/source.txt b/historique/page/Accueil/7/source.txt new file mode 100644 index 0000000..952ab12 --- /dev/null +++ b/historique/page/Accueil/7/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * Le modèle d'exécution est [Orienté document|orienté document], et non processus ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/8/log.txt b/historique/page/Accueil/8/log.txt new file mode 100644 index 0000000..8040eb9 --- /dev/null +++ b/historique/page/Accueil/8/log.txt @@ -0,0 +1 @@ +1259313898 js Creer Accueil 8 -vide -vide diff --git a/historique/page/Accueil/8/source.txt b/historique/page/Accueil/8/source.txt new file mode 100644 index 0000000..952ab12 --- /dev/null +++ b/historique/page/Accueil/8/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * Le modèle d'exécution est [Orienté document|orienté document], et non processus ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/9/log.txt b/historique/page/Accueil/9/log.txt new file mode 100644 index 0000000..41f2638 --- /dev/null +++ b/historique/page/Accueil/9/log.txt @@ -0,0 +1 @@ +1259323247 js Creer Accueil 9 -vide -vide diff --git a/historique/page/Accueil/9/source.txt b/historique/page/Accueil/9/source.txt new file mode 100644 index 0000000..952ab12 --- /dev/null +++ b/historique/page/Accueil/9/source.txt @@ -0,0 +1,9 @@ +page + += Gruntnetwork = + +'''Gruntnetwork''' est un projet de système d'expoitation, avec les particularités suivantes : + * Il est construit (et programmable) avec un [Langage|langage de programmation graphique] ; + * Le modèle d'exécution est [Orienté document|orienté document], et non processus ; + * Son [Système de fichiers|système de fichiers] est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; + * Sa [Gestion des ressources|gestion des ressources] matérielles est suffisemment souple pour permettre à des programmes ''en cours d'exécution'' d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. \ No newline at end of file diff --git a/historique/page/Accueil/version.txt b/historique/page/Accueil/version.txt new file mode 100644 index 0000000..cabf43b --- /dev/null +++ b/historique/page/Accueil/version.txt @@ -0,0 +1 @@ +24 \ No newline at end of file diff --git a/historique/page/Gestion des ressources/0/log.txt b/historique/page/Gestion des ressources/0/log.txt new file mode 100644 index 0000000..9cb7e86 --- /dev/null +++ b/historique/page/Gestion des ressources/0/log.txt @@ -0,0 +1 @@ +1259870498 js Creer Gestion-20des-20ressources 0 -vide -vide diff --git a/historique/page/Gestion des ressources/0/source.txt b/historique/page/Gestion des ressources/0/source.txt new file mode 100644 index 0000000..7055afd --- /dev/null +++ b/historique/page/Gestion des ressources/0/source.txt @@ -0,0 +1,14 @@ +page + += Gestion des ressources = + +Les programmes fonctionnant sous le système d'exploitation gruntnetwork doivent faire une demmande d'allocation de ressource auprès du système d'exploitation lorsqu'ils ont besoin de mémoire, d'une sortie sonore, d'une portion d'affichage graphique, voire de temps de calcul. + +Cette ressource n'est pas allouée définitivement par le système et l'accès à celle-ci peut être révoqué à tout moment. Un signal est alors envoyé à l'application qui peut traiter cette disparition de ressource. + +La ressource peut être reprise de plusieurs manières (l'application en est informé) : + + * Accès temporairement désactivé, lors de la mise en veille par exemple. La ressource sera ré-allouée au réveil ; + * Accès révoqué de manière permanente, lors de l'arrêt de la machine, ou lors de la déconnexion d'un périphérique ; + +Cette gestion des ressources permet des choses étonemment pratiques, comme la mise en hibernation d'un processus (accès temporairement désactivé), puis son réveil sur une autre machine (accès restitué, mais avec une ressource légèrement différente). Cela permet de déplacer des processus en cours d'exécution d'une machine à l'autre, ou de les enregistrer en vue de les relancer plus tard, … \ No newline at end of file diff --git a/historique/page/Gestion des ressources/1/log.txt b/historique/page/Gestion des ressources/1/log.txt new file mode 100644 index 0000000..9fc4b3e --- /dev/null +++ b/historique/page/Gestion des ressources/1/log.txt @@ -0,0 +1 @@ +1260009798 js Creer Gestion-20des-20ressources 1 -vide -vide diff --git a/historique/page/Gestion des ressources/1/source.txt b/historique/page/Gestion des ressources/1/source.txt new file mode 100644 index 0000000..7055afd --- /dev/null +++ b/historique/page/Gestion des ressources/1/source.txt @@ -0,0 +1,14 @@ +page + += Gestion des ressources = + +Les programmes fonctionnant sous le système d'exploitation gruntnetwork doivent faire une demmande d'allocation de ressource auprès du système d'exploitation lorsqu'ils ont besoin de mémoire, d'une sortie sonore, d'une portion d'affichage graphique, voire de temps de calcul. + +Cette ressource n'est pas allouée définitivement par le système et l'accès à celle-ci peut être révoqué à tout moment. Un signal est alors envoyé à l'application qui peut traiter cette disparition de ressource. + +La ressource peut être reprise de plusieurs manières (l'application en est informé) : + + * Accès temporairement désactivé, lors de la mise en veille par exemple. La ressource sera ré-allouée au réveil ; + * Accès révoqué de manière permanente, lors de l'arrêt de la machine, ou lors de la déconnexion d'un périphérique ; + +Cette gestion des ressources permet des choses étonemment pratiques, comme la mise en hibernation d'un processus (accès temporairement désactivé), puis son réveil sur une autre machine (accès restitué, mais avec une ressource légèrement différente). Cela permet de déplacer des processus en cours d'exécution d'une machine à l'autre, ou de les enregistrer en vue de les relancer plus tard, … \ No newline at end of file diff --git a/historique/page/Gestion des ressources/2/log.txt b/historique/page/Gestion des ressources/2/log.txt new file mode 100644 index 0000000..d81709c --- /dev/null +++ b/historique/page/Gestion des ressources/2/log.txt @@ -0,0 +1 @@ +1260466460 js Creer Gestion-20des-20ressources 2 -vide -vide diff --git a/historique/page/Gestion des ressources/2/source.txt b/historique/page/Gestion des ressources/2/source.txt new file mode 100644 index 0000000..7055afd --- /dev/null +++ b/historique/page/Gestion des ressources/2/source.txt @@ -0,0 +1,14 @@ +page + += Gestion des ressources = + +Les programmes fonctionnant sous le système d'exploitation gruntnetwork doivent faire une demmande d'allocation de ressource auprès du système d'exploitation lorsqu'ils ont besoin de mémoire, d'une sortie sonore, d'une portion d'affichage graphique, voire de temps de calcul. + +Cette ressource n'est pas allouée définitivement par le système et l'accès à celle-ci peut être révoqué à tout moment. Un signal est alors envoyé à l'application qui peut traiter cette disparition de ressource. + +La ressource peut être reprise de plusieurs manières (l'application en est informé) : + + * Accès temporairement désactivé, lors de la mise en veille par exemple. La ressource sera ré-allouée au réveil ; + * Accès révoqué de manière permanente, lors de l'arrêt de la machine, ou lors de la déconnexion d'un périphérique ; + +Cette gestion des ressources permet des choses étonemment pratiques, comme la mise en hibernation d'un processus (accès temporairement désactivé), puis son réveil sur une autre machine (accès restitué, mais avec une ressource légèrement différente). Cela permet de déplacer des processus en cours d'exécution d'une machine à l'autre, ou de les enregistrer en vue de les relancer plus tard, … \ No newline at end of file diff --git a/historique/page/Gestion des ressources/version.txt b/historique/page/Gestion des ressources/version.txt new file mode 100644 index 0000000..d8263ee --- /dev/null +++ b/historique/page/Gestion des ressources/version.txt @@ -0,0 +1 @@ +2 \ No newline at end of file diff --git a/historique/page/Interface Homme-2dMachine/0/log.txt b/historique/page/Interface Homme-2dMachine/0/log.txt new file mode 100644 index 0000000..af9e016 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/0/log.txt @@ -0,0 +1 @@ +1259841424 js Creer Interface-20Homme-2dMachine 0 -vide -vide diff --git a/historique/page/Interface Homme-2dMachine/0/source.txt b/historique/page/Interface Homme-2dMachine/0/source.txt new file mode 100644 index 0000000..91f3079 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/0/source.txt @@ -0,0 +1,9 @@ +page + += Interface orientée document = + +L'Interface Homme-Machine (IHM) de gruntnetwork est orientée document. Cela signifie que l'élément principal présenté à l'utilisateur est le document, autour duquel viennent se greffer des outils. + +Dans la plupart des sytèmes actuels, on présente à l'utilisateur la possibilité de lancer divers processus directement (via un menu d'applications), ou bien de lancer ces mêmes processus avec une certaine donnée en entrée (l'ouverture d'un fichier via son icône passe obligatoirement par le démarrage d'un processus, qui décide que faire de ce fichier). + += Génération semi-automatique = \ No newline at end of file diff --git a/historique/page/Interface Homme-2dMachine/1/log.txt b/historique/page/Interface Homme-2dMachine/1/log.txt new file mode 100644 index 0000000..e823b37 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/1/log.txt @@ -0,0 +1 @@ +1259841488 js Creer Interface-20Homme-2dMachine 1 -vide -vide diff --git a/historique/page/Interface Homme-2dMachine/1/source.txt b/historique/page/Interface Homme-2dMachine/1/source.txt new file mode 100644 index 0000000..91f3079 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/1/source.txt @@ -0,0 +1,9 @@ +page + += Interface orientée document = + +L'Interface Homme-Machine (IHM) de gruntnetwork est orientée document. Cela signifie que l'élément principal présenté à l'utilisateur est le document, autour duquel viennent se greffer des outils. + +Dans la plupart des sytèmes actuels, on présente à l'utilisateur la possibilité de lancer divers processus directement (via un menu d'applications), ou bien de lancer ces mêmes processus avec une certaine donnée en entrée (l'ouverture d'un fichier via son icône passe obligatoirement par le démarrage d'un processus, qui décide que faire de ce fichier). + += Génération semi-automatique = \ No newline at end of file diff --git a/historique/page/Interface Homme-2dMachine/2/log.txt b/historique/page/Interface Homme-2dMachine/2/log.txt new file mode 100644 index 0000000..db1187d --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/2/log.txt @@ -0,0 +1 @@ +1259846394 js Creer Interface-20Homme-2dMachine 2 -vide -vide diff --git a/historique/page/Interface Homme-2dMachine/2/source.txt b/historique/page/Interface Homme-2dMachine/2/source.txt new file mode 100644 index 0000000..66b4147 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/2/source.txt @@ -0,0 +1,19 @@ +page + += Interface Homme-Machine = + +== Interface orientée document == + +L'Interface Homme-Machine (IHM) de gruntnetwork est orientée document. Cela signifie que l'élément principal présenté à l'utilisateur est le document, autour duquel viennent se greffer des outils. + +Dans la plupart des sytèmes actuels, on présente à l'utilisateur la possibilité de lancer divers processus directement (via un menu d'applications), ou bien de lancer ces mêmes processus avec une certaine donnée en entrée (l'ouverture d'un fichier via son icône passe obligatoirement par le démarrage d'un processus, qui décide que faire de ce fichier). Cette approche présente plusieurs défauts : + + * Lorsque le processus plante, tous ses documents sont perdus ; + * Intuitivement, l'utilisateur a l'impression d'avoir ouvert un document, alors qu'en réalité il vient de démarrer une application. L'utilisateur a donc une vision erronnée du système, ce qui est en général mauvais, car moins il comprend le système, moins il est efficace ; + * Des mécanismes complexes de dialogue entre applications sont nécessaires pour l'édition de documents composite (OLE, Kpart, …) ; + * Si l'application ne sait pas gérer un certain protocole (http, ouverture de fichiers à l'intérieur de fichiers compressés, …), elle ne pourra pas ouvrir les documents accessibles via ce protocole. L'environnement de bureau KDE apporte une solution en permettant le partage de ces protocoles via les KIOSlaves. + +Une approche orientée document apporte des solutions à ces problèmes : + * Lorsqu'un des outils greffés autour du document plante, il suffi + +== Génération semi-automatique == \ No newline at end of file diff --git a/historique/page/Interface Homme-2dMachine/3/log.txt b/historique/page/Interface Homme-2dMachine/3/log.txt new file mode 100644 index 0000000..39d4c37 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/3/log.txt @@ -0,0 +1 @@ +1259846709 js Creer Interface-20Homme-2dMachine 3 -vide -vide diff --git a/historique/page/Interface Homme-2dMachine/3/source.txt b/historique/page/Interface Homme-2dMachine/3/source.txt new file mode 100644 index 0000000..609a14e --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/3/source.txt @@ -0,0 +1,21 @@ +page + += Interface Homme-Machine = + +== Interface orientée document == + +L'Interface Homme-Machine (IHM) de gruntnetwork est orientée document. Cela signifie que l'élément principal présenté à l'utilisateur est le document, autour duquel viennent se greffer des outils. + +Dans la plupart des sytèmes actuels, on présente à l'utilisateur la possibilité de lancer divers processus directement (via un menu d'applications), ou bien de lancer ces mêmes processus avec une certaine donnée en entrée (l'ouverture d'un fichier via son icône passe obligatoirement par le démarrage d'un processus, qui décide que faire de ce fichier). Cette approche présente plusieurs défauts : + + * Lorsque le processus plante, tous ses documents sont perdus ; + * Intuitivement, l'utilisateur a l'impression d'avoir ouvert un document, alors qu'en réalité il vient de démarrer une application. L'utilisateur a donc une vision erronnée du système, ce qui est en général mauvais, car moins il comprend le système, moins il est efficace ; + * Des mécanismes complexes de dialogue entre applications sont nécessaires pour l'édition de documents composite (OLE, Kpart, …) ; + * Si l'application ne sait pas gérer un certain protocole (http, ouverture de fichiers à l'intérieur de fichiers compressés, …), elle ne pourra pas ouvrir les documents accessibles via ce protocole. L'environnement de bureau KDE apporte une solution en permettant le partage de ces protocoles via les KIOSlaves. + +Une approche orientée document apporte des solutions à ces problèmes : + * Lorsqu'un des outils greffés autour du document plante, il suffit de le redémarrer. Et quand bien même cela serait impossible, ou si c'est le programme chargé de l'affichage du document qui plante, il est toujours possible de proposer à l'utilisateur d'enregistrer son document pour éviter des pertes de données. + * L'édition de documents composites se fait sans encombre : selon la portion du document considérée, les outils qui viennent se greffer changent. + * Les outils ne gèrent pas l'ouverture du document, on a des blocs différents pour le chargement en mémoire, le décodage, la visualisation, la modification, l'encodage et l'enregistrement, chacun fonctionnant indépendemment des autres. + +== Génération semi-automatique == \ No newline at end of file diff --git a/historique/page/Interface Homme-2dMachine/4/log.txt b/historique/page/Interface Homme-2dMachine/4/log.txt new file mode 100644 index 0000000..5bd8fb8 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/4/log.txt @@ -0,0 +1 @@ +1259853267 js Creer Interface-20Homme-2dMachine 4 -vide -vide diff --git a/historique/page/Interface Homme-2dMachine/4/source.txt b/historique/page/Interface Homme-2dMachine/4/source.txt new file mode 100644 index 0000000..0c1ebcb --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/4/source.txt @@ -0,0 +1,27 @@ +page + += Interface Homme-Machine = + +== Interface orientée document == + +L'Interface Homme-Machine (IHM) de gruntnetwork est orientée document. Cela signifie que l'élément principal présenté à l'utilisateur est le document, autour duquel viennent se greffer des outils. + +Dans la plupart des sytèmes actuels, on présente à l'utilisateur la possibilité de lancer divers processus directement (via un menu d'applications), ou bien de lancer ces mêmes processus avec une certaine donnée en entrée (l'ouverture d'un fichier via son icône passe obligatoirement par le démarrage d'un processus, qui décide que faire de ce fichier). Cette approche présente plusieurs défauts : + + * Lorsque le processus plante, tous ses documents sont perdus ; + * Intuitivement, l'utilisateur a l'impression d'avoir ouvert un document, alors qu'en réalité il vient de démarrer une application. L'utilisateur a donc une vision erronnée du système, ce qui est en général mauvais, car moins il comprend le système, moins il est efficace ; + * Des mécanismes complexes de dialogue entre applications sont nécessaires pour l'édition de documents composite (OLE, Kpart, …) ; + * Si l'application ne sait pas gérer un certain protocole (http, ouverture de fichiers à l'intérieur de fichiers compressés, …), elle ne pourra pas ouvrir les documents accessibles via ce protocole. L'environnement de bureau KDE apporte une solution en permettant le partage de ces protocoles via les KIOSlaves. + +Une approche orientée document apporte des solutions à ces problèmes : + * Lorsqu'un des outils greffés autour du document plante, il suffit de le redémarrer. Et quand bien même cela serait impossible, ou si c'est le programme chargé de l'affichage du document qui plante, il est toujours possible de proposer à l'utilisateur d'enregistrer son document pour éviter des pertes de données. + * L'édition de documents composites se fait sans encombre : selon la portion du document considérée, les outils qui viennent se greffer changent. + * Les outils ne gèrent pas l'ouverture du document, on a des blocs différents pour le chargement en mémoire, le décodage, la visualisation, la modification, l'encodage et l'enregistrement, chacun fonctionnant indépendemment des autres. + +== Génération semi-automatique == + +L'Interface Homme-Machine (IHM) de gruntnetwork est générée semi-automatiquement à partir d'une spécification déclarative. Cette spécification indique au système quelles sont les informations qui sont les plus importantes (et donc devraient être affichées à l'écran), quelles sont les informations secondaires (accessibles par exemple au travers d'une boîte de dialogue de propriétés), etc. + +De même, cette spécification liste les actions qu'il est possible d'effectuer, les plus importantes s'affichant sous forme d'icône par exemple, les autres étant rangées dans des menus ou bien accessibles via des raccourcis clavier. + +Plusieurs spécifications peuvent coexister, ce qui permet d'avoir très facilement des interfaces différentes pour les utilisateurs expérimentés et les novices. On peut aussi imaginer une spécification d'interface actualisée dynamiquement en fonction des actions les plus fréquentes de l'utilisateur. \ No newline at end of file diff --git a/historique/page/Interface Homme-2dMachine/5/log.txt b/historique/page/Interface Homme-2dMachine/5/log.txt new file mode 100644 index 0000000..2702a23 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/5/log.txt @@ -0,0 +1 @@ +1260009754 js Creer Interface-20Homme-2dMachine 5 -vide -vide diff --git a/historique/page/Interface Homme-2dMachine/5/source.txt b/historique/page/Interface Homme-2dMachine/5/source.txt new file mode 100644 index 0000000..0c1ebcb --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/5/source.txt @@ -0,0 +1,27 @@ +page + += Interface Homme-Machine = + +== Interface orientée document == + +L'Interface Homme-Machine (IHM) de gruntnetwork est orientée document. Cela signifie que l'élément principal présenté à l'utilisateur est le document, autour duquel viennent se greffer des outils. + +Dans la plupart des sytèmes actuels, on présente à l'utilisateur la possibilité de lancer divers processus directement (via un menu d'applications), ou bien de lancer ces mêmes processus avec une certaine donnée en entrée (l'ouverture d'un fichier via son icône passe obligatoirement par le démarrage d'un processus, qui décide que faire de ce fichier). Cette approche présente plusieurs défauts : + + * Lorsque le processus plante, tous ses documents sont perdus ; + * Intuitivement, l'utilisateur a l'impression d'avoir ouvert un document, alors qu'en réalité il vient de démarrer une application. L'utilisateur a donc une vision erronnée du système, ce qui est en général mauvais, car moins il comprend le système, moins il est efficace ; + * Des mécanismes complexes de dialogue entre applications sont nécessaires pour l'édition de documents composite (OLE, Kpart, …) ; + * Si l'application ne sait pas gérer un certain protocole (http, ouverture de fichiers à l'intérieur de fichiers compressés, …), elle ne pourra pas ouvrir les documents accessibles via ce protocole. L'environnement de bureau KDE apporte une solution en permettant le partage de ces protocoles via les KIOSlaves. + +Une approche orientée document apporte des solutions à ces problèmes : + * Lorsqu'un des outils greffés autour du document plante, il suffit de le redémarrer. Et quand bien même cela serait impossible, ou si c'est le programme chargé de l'affichage du document qui plante, il est toujours possible de proposer à l'utilisateur d'enregistrer son document pour éviter des pertes de données. + * L'édition de documents composites se fait sans encombre : selon la portion du document considérée, les outils qui viennent se greffer changent. + * Les outils ne gèrent pas l'ouverture du document, on a des blocs différents pour le chargement en mémoire, le décodage, la visualisation, la modification, l'encodage et l'enregistrement, chacun fonctionnant indépendemment des autres. + +== Génération semi-automatique == + +L'Interface Homme-Machine (IHM) de gruntnetwork est générée semi-automatiquement à partir d'une spécification déclarative. Cette spécification indique au système quelles sont les informations qui sont les plus importantes (et donc devraient être affichées à l'écran), quelles sont les informations secondaires (accessibles par exemple au travers d'une boîte de dialogue de propriétés), etc. + +De même, cette spécification liste les actions qu'il est possible d'effectuer, les plus importantes s'affichant sous forme d'icône par exemple, les autres étant rangées dans des menus ou bien accessibles via des raccourcis clavier. + +Plusieurs spécifications peuvent coexister, ce qui permet d'avoir très facilement des interfaces différentes pour les utilisateurs expérimentés et les novices. On peut aussi imaginer une spécification d'interface actualisée dynamiquement en fonction des actions les plus fréquentes de l'utilisateur. \ No newline at end of file diff --git a/historique/page/Interface Homme-2dMachine/6/log.txt b/historique/page/Interface Homme-2dMachine/6/log.txt new file mode 100644 index 0000000..3a5b626 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/6/log.txt @@ -0,0 +1 @@ +1260466435 js Creer Interface-20Homme-2dMachine 6 -vide -vide diff --git a/historique/page/Interface Homme-2dMachine/6/source.txt b/historique/page/Interface Homme-2dMachine/6/source.txt new file mode 100644 index 0000000..0c1ebcb --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/6/source.txt @@ -0,0 +1,27 @@ +page + += Interface Homme-Machine = + +== Interface orientée document == + +L'Interface Homme-Machine (IHM) de gruntnetwork est orientée document. Cela signifie que l'élément principal présenté à l'utilisateur est le document, autour duquel viennent se greffer des outils. + +Dans la plupart des sytèmes actuels, on présente à l'utilisateur la possibilité de lancer divers processus directement (via un menu d'applications), ou bien de lancer ces mêmes processus avec une certaine donnée en entrée (l'ouverture d'un fichier via son icône passe obligatoirement par le démarrage d'un processus, qui décide que faire de ce fichier). Cette approche présente plusieurs défauts : + + * Lorsque le processus plante, tous ses documents sont perdus ; + * Intuitivement, l'utilisateur a l'impression d'avoir ouvert un document, alors qu'en réalité il vient de démarrer une application. L'utilisateur a donc une vision erronnée du système, ce qui est en général mauvais, car moins il comprend le système, moins il est efficace ; + * Des mécanismes complexes de dialogue entre applications sont nécessaires pour l'édition de documents composite (OLE, Kpart, …) ; + * Si l'application ne sait pas gérer un certain protocole (http, ouverture de fichiers à l'intérieur de fichiers compressés, …), elle ne pourra pas ouvrir les documents accessibles via ce protocole. L'environnement de bureau KDE apporte une solution en permettant le partage de ces protocoles via les KIOSlaves. + +Une approche orientée document apporte des solutions à ces problèmes : + * Lorsqu'un des outils greffés autour du document plante, il suffit de le redémarrer. Et quand bien même cela serait impossible, ou si c'est le programme chargé de l'affichage du document qui plante, il est toujours possible de proposer à l'utilisateur d'enregistrer son document pour éviter des pertes de données. + * L'édition de documents composites se fait sans encombre : selon la portion du document considérée, les outils qui viennent se greffer changent. + * Les outils ne gèrent pas l'ouverture du document, on a des blocs différents pour le chargement en mémoire, le décodage, la visualisation, la modification, l'encodage et l'enregistrement, chacun fonctionnant indépendemment des autres. + +== Génération semi-automatique == + +L'Interface Homme-Machine (IHM) de gruntnetwork est générée semi-automatiquement à partir d'une spécification déclarative. Cette spécification indique au système quelles sont les informations qui sont les plus importantes (et donc devraient être affichées à l'écran), quelles sont les informations secondaires (accessibles par exemple au travers d'une boîte de dialogue de propriétés), etc. + +De même, cette spécification liste les actions qu'il est possible d'effectuer, les plus importantes s'affichant sous forme d'icône par exemple, les autres étant rangées dans des menus ou bien accessibles via des raccourcis clavier. + +Plusieurs spécifications peuvent coexister, ce qui permet d'avoir très facilement des interfaces différentes pour les utilisateurs expérimentés et les novices. On peut aussi imaginer une spécification d'interface actualisée dynamiquement en fonction des actions les plus fréquentes de l'utilisateur. \ No newline at end of file diff --git a/historique/page/Interface Homme-2dMachine/version.txt b/historique/page/Interface Homme-2dMachine/version.txt new file mode 100644 index 0000000..62f9457 --- /dev/null +++ b/historique/page/Interface Homme-2dMachine/version.txt @@ -0,0 +1 @@ +6 \ No newline at end of file diff --git a/historique/page/Langage/0/log.txt b/historique/page/Langage/0/log.txt new file mode 100644 index 0000000..a715121 --- /dev/null +++ b/historique/page/Langage/0/log.txt @@ -0,0 +1 @@ +1259278974 js Creer Langage 0 -vide -vide diff --git a/historique/page/Langage/0/source.txt b/historique/page/Langage/0/source.txt new file mode 100644 index 0000000..1556607 --- /dev/null +++ b/historique/page/Langage/0/source.txt @@ -0,0 +1,15 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants,suivant le pradigme du dataflow. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte; ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits. + +== Composants == + diff --git a/historique/page/Langage/1/log.txt b/historique/page/Langage/1/log.txt new file mode 100644 index 0000000..87f80a1 --- /dev/null +++ b/historique/page/Langage/1/log.txt @@ -0,0 +1 @@ +1259280194 js Creer Langage 1 -vide -vide diff --git a/historique/page/Langage/1/source.txt b/historique/page/Langage/1/source.txt new file mode 100644 index 0000000..1619940 --- /dev/null +++ b/historique/page/Langage/1/source.txt @@ -0,0 +1,17 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants,suivant le pradigme du dataflow. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte; ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits. + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments. + * La '''Métaprogrammation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + diff --git a/historique/page/Langage/10/log.txt b/historique/page/Langage/10/log.txt new file mode 100644 index 0000000..f6720a8 --- /dev/null +++ b/historique/page/Langage/10/log.txt @@ -0,0 +1 @@ +1259755367 js Creer Langage 10 -vide -vide diff --git a/historique/page/Langage/10/source.txt b/historique/page/Langage/10/source.txt new file mode 100644 index 0000000..300d3e4 --- /dev/null +++ b/historique/page/Langage/10/source.txt @@ -0,0 +1,46 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent représenter un objet, une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), une fonction, un document, une règle (par ex. logique ou de filtrage), … + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +== Preuves == \ No newline at end of file diff --git a/historique/page/Langage/11/log.txt b/historique/page/Langage/11/log.txt new file mode 100644 index 0000000..b2b6370 --- /dev/null +++ b/historique/page/Langage/11/log.txt @@ -0,0 +1 @@ +1259767145 js Creer Langage 11 -vide -vide diff --git a/historique/page/Langage/11/source.txt b/historique/page/Langage/11/source.txt new file mode 100644 index 0000000..aa23e3f --- /dev/null +++ b/historique/page/Langage/11/source.txt @@ -0,0 +1,52 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + + + +== Preuves == + +== Liens Externes == + + * http://lambda-the-ultimate.org/ : Excelent blog collectif sur la théorie des langages de programmation. \ No newline at end of file diff --git a/historique/page/Langage/12/log.txt b/historique/page/Langage/12/log.txt new file mode 100644 index 0000000..96464ad --- /dev/null +++ b/historique/page/Langage/12/log.txt @@ -0,0 +1 @@ +1259770272 js Creer Langage 12 -vide -vide diff --git a/historique/page/Langage/12/source.txt b/historique/page/Langage/12/source.txt new file mode 100644 index 0000000..24e6014 --- /dev/null +++ b/historique/page/Langage/12/source.txt @@ -0,0 +1,55 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +== Preuves == + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/]] : Excelent blog collectif sur la théorie des langages de programmation. + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents pradigmes de programmation et leurs principes. + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] \ No newline at end of file diff --git a/historique/page/Langage/13/log.txt b/historique/page/Langage/13/log.txt new file mode 100644 index 0000000..2a79864 --- /dev/null +++ b/historique/page/Langage/13/log.txt @@ -0,0 +1 @@ +1259784652 js Creer Langage 13 -vide -vide diff --git a/historique/page/Langage/13/source.txt b/historique/page/Langage/13/source.txt new file mode 100644 index 0000000..be2a6f2 --- /dev/null +++ b/historique/page/Langage/13/source.txt @@ -0,0 +1,58 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +Le pradigme de programmation dominant du langage est le dataflow non-déterministe. Le dataflow est un pradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. + +== Preuves == + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/]] : Excelent blog collectif sur la théorie des langages de programmation. + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents pradigmes de programmation et leurs principes. + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] + * [[http://portal.acm.org/citation.cfm?id=834420|BDL - A Nondeterministic Data Flow Programming Language with Backtracking]] \ No newline at end of file diff --git a/historique/page/Langage/14/log.txt b/historique/page/Langage/14/log.txt new file mode 100644 index 0000000..46d08c7 --- /dev/null +++ b/historique/page/Langage/14/log.txt @@ -0,0 +1 @@ +1259784950 js Creer Langage 14 -vide -vide diff --git a/historique/page/Langage/14/source.txt b/historique/page/Langage/14/source.txt new file mode 100644 index 0000000..ba18928 --- /dev/null +++ b/historique/page/Langage/14/source.txt @@ -0,0 +1,58 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certains écueils de la programmation textuelle : + * '''Conflits de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante des identifiants précédemments définis ; + * '''Encombrement visuel''', lorsque le code important est noyé par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou bien certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toutefois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, une imbrication visuelle, ... De plus, on peut représenter les nouvelles syntaxes étendant le langage par des modèles de fonctions dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardu. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construits en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +Le pradigme de programmation dominant du langage est le dataflow non-déterministe. Le dataflow est un pradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. + +== Preuves == + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/]] : Excelent blog collectif sur la théorie des langages de programmation. + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents pradigmes de programmation et leurs principes. + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] + * [[http://portal.acm.org/citation.cfm?id=834420|BDL - A Nondeterministic Data Flow Programming Language with Backtracking]] \ No newline at end of file diff --git a/historique/page/Langage/15/log.txt b/historique/page/Langage/15/log.txt new file mode 100644 index 0000000..690e4de --- /dev/null +++ b/historique/page/Langage/15/log.txt @@ -0,0 +1 @@ +1259785546 js Creer Langage 15 -vide -vide diff --git a/historique/page/Langage/15/source.txt b/historique/page/Langage/15/source.txt new file mode 100644 index 0000000..1952360 --- /dev/null +++ b/historique/page/Langage/15/source.txt @@ -0,0 +1,60 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certains écueils de la programmation textuelle : + * '''Conflits de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante des identifiants précédemments définis ; + * '''Encombrement visuel''', lorsque le code important est noyé par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou bien certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toutefois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, une imbrication visuelle, ... De plus, on peut représenter les nouvelles syntaxes étendant le langage par des modèles de fonctions dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardu. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construits en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +Le pradigme de programmation dominant du langage est le dataflow non-déterministe. Le dataflow est un pradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. + +Le non-déterminisme est obligatoire pour pouvoir programmer des applications réactives à l'utilisateur. Par exemple, lorsque l'utilisateur applique un filtre à une image, il peut décider d'effectuer + +== Preuves == + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/]] : Excelent blog collectif sur la théorie des langages de programmation. + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents pradigmes de programmation et leurs principes. + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] + * [[http://portal.acm.org/citation.cfm?id=834420|BDL - A Nondeterministic Data Flow Programming Language with Backtracking]] \ No newline at end of file diff --git a/historique/page/Langage/16/log.txt b/historique/page/Langage/16/log.txt new file mode 100644 index 0000000..81e7f13 --- /dev/null +++ b/historique/page/Langage/16/log.txt @@ -0,0 +1 @@ +1259792637 js Creer Langage 16 -vide -vide diff --git a/historique/page/Langage/16/source.txt b/historique/page/Langage/16/source.txt new file mode 100644 index 0000000..e48aeb7 --- /dev/null +++ b/historique/page/Langage/16/source.txt @@ -0,0 +1,69 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certains écueils de la programmation textuelle : + * '''Conflits de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante des identifiants précédemments définis ; + * '''Encombrement visuel''', lorsque le code important est noyé par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou bien certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, …), ce mécanisme n'est toutefois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, une imbrication visuelle, ... De plus, on peut représenter les nouvelles syntaxes étendant le langage par des modèles de fonctions dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardu. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construits en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +Le pradigme de programmation dominant du langage est le dataflow. Le dataflow est un pradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. + +Ce pradigme est souvent utilisé par les langages de programmation graphiques car il découle assez simplement de la représentation des programmes (des sortes de filtres transformant l'information reçue et la passant au filtre suivant). + +== Preuves == + +Les blocs seront écrits en vue d'être prouvés, si possible les preuves devraient être rédigées dans le même temps que les blocs, de manière similaire à ce qui se fait dans la méthode B. Plusieurs types de preuves devront être écrites et vérifiées avant exécution : + + * Correction, indiquant que le bloc fait bien ce qu'il annonce faire (de manière formelle, dans sa signature) ; + * Terminaison, si nécessaire ; + * Absence de fuites mémoires ; + * Absence d'opérations pour lesquelles le bloc ne dispose pas de privilèges (accès à la mémoire d'autres blocs, altération de données, …); + +Ces preuves permettent au système d'exécuter un bloc sans aucune contrainte (pas de nécessité d'isoler les processus, pas de vérification de droit d'accès), après en avoir vérifié les preuves. Cela permet aussi de prouver des blocs plus gros en se basant sur les preuves des blocs utilisés dans sa construction, et ainsi de s'assurer de l'absence d'erreurs de programmation. + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/]] : Excelent blog collectif sur la théorie des langages de programmation. + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents pradigmes de programmation et leurs principes. + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] + * [[http://portal.acm.org/citation.cfm?id=834420|BDL - A Nondeterministic Data Flow Programming Language with Backtracking]] \ No newline at end of file diff --git a/historique/page/Langage/17/log.txt b/historique/page/Langage/17/log.txt new file mode 100644 index 0000000..858ba91 --- /dev/null +++ b/historique/page/Langage/17/log.txt @@ -0,0 +1 @@ +1259837196 js Creer Langage 17 -vide -vide diff --git a/historique/page/Langage/17/source.txt b/historique/page/Langage/17/source.txt new file mode 100644 index 0000000..9066b80 --- /dev/null +++ b/historique/page/Langage/17/source.txt @@ -0,0 +1,69 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le paradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certains écueils de la programmation textuelle : + * '''Conflits de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante des identifiants précédemments définis ; + * '''Encombrement visuel''', lorsque le code important est noyé par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou bien certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, …), ce mécanisme n'est toutefois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, une imbrication visuelle, ... De plus, on peut représenter les nouvelles syntaxes étendant le langage par des modèles de fonctions dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardu. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construits en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +Le paradigme de programmation dominant du langage est le dataflow. Le dataflow est un paradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. + +Ce paradigme est souvent utilisé par les langages de programmation graphiques car il découle assez simplement de la représentation des programmes (des sortes de filtres transformant l'information reçue et la passant au filtre suivant). + +== Preuves == + +Les blocs seront écrits en vue d'être prouvés, si possible les preuves devraient être rédigées dans le même temps que les blocs, de manière similaire à ce qui se fait dans la méthode B. Plusieurs types de preuves devront être écrites et vérifiées avant exécution : + + * Correction, indiquant que le bloc fait bien ce qu'il annonce faire (de manière formelle, dans sa signature) ; + * Terminaison, si nécessaire ; + * Absence de fuites mémoires ; + * Absence d'opérations pour lesquelles le bloc ne dispose pas de privilèges (accès à la mémoire d'autres blocs, altération de données, …); + +Ces preuves permettent au système d'exécuter un bloc sans aucune contrainte (pas de nécessité d'isoler les processus, pas de vérification de droit d'accès), après en avoir vérifié les preuves. Cela permet aussi de prouver des blocs plus gros en se basant sur les preuves des blocs utilisés dans sa construction, et ainsi de s'assurer de l'absence d'erreurs de programmation. + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/]] : Excelent blog collectif sur la théorie des langages de programmation. + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents paradigmes de programmation et leurs principes. + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] + * [[http://portal.acm.org/citation.cfm?id=834420|BDL - A Nondeterministic Data Flow Programming Language with Backtracking]] \ No newline at end of file diff --git a/historique/page/Langage/18/log.txt b/historique/page/Langage/18/log.txt new file mode 100644 index 0000000..6f83ad7 --- /dev/null +++ b/historique/page/Langage/18/log.txt @@ -0,0 +1 @@ +1259839115 js Creer Langage 18 -vide -vide diff --git a/historique/page/Langage/18/source.txt b/historique/page/Langage/18/source.txt new file mode 100644 index 0000000..8255b0b --- /dev/null +++ b/historique/page/Langage/18/source.txt @@ -0,0 +1,70 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le paradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certains écueils de la programmation textuelle : + * '''Conflits de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante des identifiants précédemments définis ; + * '''Encombrement visuel''', lorsque le code important est noyé par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou bien certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, …), ce mécanisme n'est toutefois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, une imbrication visuelle, ... De plus, on peut représenter les nouvelles syntaxes étendant le langage par des modèles de fonctions dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardu. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construits en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +Le paradigme de programmation dominant du langage est le dataflow. Le dataflow est un paradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. + +Ce paradigme est souvent utilisé par les langages de programmation graphiques car il découle assez simplement de la représentation des programmes (des sortes de filtres transformant l'information reçue et la passant au filtre suivant). + +== Preuves == + +Les blocs seront écrits en vue d'être prouvés, si possible les preuves devraient être rédigées dans le même temps que les blocs, de manière similaire à ce qui se fait dans la méthode B. Plusieurs types de preuves devront être écrites et vérifiées avant exécution : + + * Correction, indiquant que le bloc fait bien ce qu'il annonce faire (de manière formelle, dans sa signature) ; + * Terminaison, si nécessaire ; + * Absence de fuites mémoires ; + * Absence d'opérations pour lesquelles le bloc ne dispose pas de privilèges (accès à la mémoire d'autres blocs, altération de données, …); + +Ces preuves permettent au système d'exécuter un bloc sans aucune contrainte (pas de nécessité d'isoler les processus, pas de vérification de droit d'accès), après en avoir vérifié les preuves. Cela permet aussi de prouver des blocs plus gros en se basant sur les preuves des blocs utilisés dans sa construction, et ainsi de s'assurer de l'absence d'erreurs de programmation. + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/]] : Excelent blog collectif sur la théorie des langages de programmation ; + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents paradigmes de programmation et leurs principes ; + * [[http://en.wikipedia.org/wiki/Flow-based_programming|Flow-based programming]] (wikipedia). + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] ; + * [[http://portal.acm.org/citation.cfm?id=834420|BDL - A Nondeterministic Data Flow Programming Language with Backtracking]]. \ No newline at end of file diff --git a/historique/page/Langage/19/log.txt b/historique/page/Langage/19/log.txt new file mode 100644 index 0000000..61888a5 --- /dev/null +++ b/historique/page/Langage/19/log.txt @@ -0,0 +1 @@ +1259839143 js Creer Langage 19 -vide -vide diff --git a/historique/page/Langage/19/source.txt b/historique/page/Langage/19/source.txt new file mode 100644 index 0000000..5ae7cc0 --- /dev/null +++ b/historique/page/Langage/19/source.txt @@ -0,0 +1,70 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le paradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certains écueils de la programmation textuelle : + * '''Conflits de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante des identifiants précédemments définis ; + * '''Encombrement visuel''', lorsque le code important est noyé par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou bien certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, …), ce mécanisme n'est toutefois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, une imbrication visuelle, ... De plus, on peut représenter les nouvelles syntaxes étendant le langage par des modèles de fonctions dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardu. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construits en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +Le paradigme de programmation dominant du langage est le dataflow. Le dataflow est un paradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. + +Ce paradigme est souvent utilisé par les langages de programmation graphiques car il découle assez simplement de la représentation des programmes (des sortes de filtres transformant l'information reçue et la passant au filtre suivant). + +== Preuves == + +Les blocs seront écrits en vue d'être prouvés, si possible les preuves devraient être rédigées dans le même temps que les blocs, de manière similaire à ce qui se fait dans la méthode B. Plusieurs types de preuves devront être écrites et vérifiées avant exécution : + + * Correction, indiquant que le bloc fait bien ce qu'il annonce faire (de manière formelle, dans sa signature) ; + * Terminaison, si nécessaire ; + * Absence de fuites mémoires ; + * Absence d'opérations pour lesquelles le bloc ne dispose pas de privilèges (accès à la mémoire d'autres blocs, altération de données, …); + +Ces preuves permettent au système d'exécuter un bloc sans aucune contrainte (pas de nécessité d'isoler les processus, pas de vérification de droit d'accès), après en avoir vérifié les preuves. Cela permet aussi de prouver des blocs plus gros en se basant sur les preuves des blocs utilisés dans sa construction, et ainsi de s'assurer de l'absence d'erreurs de programmation. + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/|lambda-the-ultimate.org]] : Excelent blog collectif sur la théorie des langages de programmation ; + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents paradigmes de programmation et leurs principes ; + * [[http://en.wikipedia.org/wiki/Flow-based_programming|Flow-based programming]] (wikipedia). + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] ; + * [[http://portal.acm.org/citation.cfm?id=834420|BDL - A Nondeterministic Data Flow Programming Language with Backtracking]]. \ No newline at end of file diff --git a/historique/page/Langage/2/log.txt b/historique/page/Langage/2/log.txt new file mode 100644 index 0000000..1f7561c --- /dev/null +++ b/historique/page/Langage/2/log.txt @@ -0,0 +1 @@ +1259299917 js Creer Langage 2 -vide -vide diff --git a/historique/page/Langage/2/source.txt b/historique/page/Langage/2/source.txt new file mode 100644 index 0000000..421ca82 --- /dev/null +++ b/historique/page/Langage/2/source.txt @@ -0,0 +1,24 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitive fixe, et suivant le pradigme du dataflow. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte; ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits. + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments. + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments principaux du langage sont : + * '''Les blocs''', qui sont les composants + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres + * '''Les connexions'''. + diff --git a/historique/page/Langage/20/log.txt b/historique/page/Langage/20/log.txt new file mode 100644 index 0000000..28b0738 --- /dev/null +++ b/historique/page/Langage/20/log.txt @@ -0,0 +1 @@ +1260009744 js Creer Langage 20 -vide -vide diff --git a/historique/page/Langage/20/source.txt b/historique/page/Langage/20/source.txt new file mode 100644 index 0000000..5ae7cc0 --- /dev/null +++ b/historique/page/Langage/20/source.txt @@ -0,0 +1,70 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le paradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certains écueils de la programmation textuelle : + * '''Conflits de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante des identifiants précédemments définis ; + * '''Encombrement visuel''', lorsque le code important est noyé par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou bien certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, …), ce mécanisme n'est toutefois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, une imbrication visuelle, ... De plus, on peut représenter les nouvelles syntaxes étendant le langage par des modèles de fonctions dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardu. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construits en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +Le paradigme de programmation dominant du langage est le dataflow. Le dataflow est un paradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. + +Ce paradigme est souvent utilisé par les langages de programmation graphiques car il découle assez simplement de la représentation des programmes (des sortes de filtres transformant l'information reçue et la passant au filtre suivant). + +== Preuves == + +Les blocs seront écrits en vue d'être prouvés, si possible les preuves devraient être rédigées dans le même temps que les blocs, de manière similaire à ce qui se fait dans la méthode B. Plusieurs types de preuves devront être écrites et vérifiées avant exécution : + + * Correction, indiquant que le bloc fait bien ce qu'il annonce faire (de manière formelle, dans sa signature) ; + * Terminaison, si nécessaire ; + * Absence de fuites mémoires ; + * Absence d'opérations pour lesquelles le bloc ne dispose pas de privilèges (accès à la mémoire d'autres blocs, altération de données, …); + +Ces preuves permettent au système d'exécuter un bloc sans aucune contrainte (pas de nécessité d'isoler les processus, pas de vérification de droit d'accès), après en avoir vérifié les preuves. Cela permet aussi de prouver des blocs plus gros en se basant sur les preuves des blocs utilisés dans sa construction, et ainsi de s'assurer de l'absence d'erreurs de programmation. + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/|lambda-the-ultimate.org]] : Excelent blog collectif sur la théorie des langages de programmation ; + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents paradigmes de programmation et leurs principes ; + * [[http://en.wikipedia.org/wiki/Flow-based_programming|Flow-based programming]] (wikipedia). + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] ; + * [[http://portal.acm.org/citation.cfm?id=834420|BDL - A Nondeterministic Data Flow Programming Language with Backtracking]]. \ No newline at end of file diff --git a/historique/page/Langage/21/log.txt b/historique/page/Langage/21/log.txt new file mode 100644 index 0000000..9ea4157 --- /dev/null +++ b/historique/page/Langage/21/log.txt @@ -0,0 +1 @@ +1260466430 js Creer Langage 21 -vide -vide diff --git a/historique/page/Langage/21/source.txt b/historique/page/Langage/21/source.txt new file mode 100644 index 0000000..5ae7cc0 --- /dev/null +++ b/historique/page/Langage/21/source.txt @@ -0,0 +1,70 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le paradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certains écueils de la programmation textuelle : + * '''Conflits de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante des identifiants précédemments définis ; + * '''Encombrement visuel''', lorsque le code important est noyé par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou bien certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, …), ce mécanisme n'est toutefois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, une imbrication visuelle, ... De plus, on peut représenter les nouvelles syntaxes étendant le langage par des modèles de fonctions dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardu. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construits en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage [[http://en.wikipedia.org/wiki/Homoiconicity|homoiconique]]. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. + +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : + * Des «primitives» définies en termes du langage, donc plus compréhensibles ; + * La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. + +== Dataflow == + +Le paradigme de programmation dominant du langage est le dataflow. Le dataflow est un paradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. + +Ce paradigme est souvent utilisé par les langages de programmation graphiques car il découle assez simplement de la représentation des programmes (des sortes de filtres transformant l'information reçue et la passant au filtre suivant). + +== Preuves == + +Les blocs seront écrits en vue d'être prouvés, si possible les preuves devraient être rédigées dans le même temps que les blocs, de manière similaire à ce qui se fait dans la méthode B. Plusieurs types de preuves devront être écrites et vérifiées avant exécution : + + * Correction, indiquant que le bloc fait bien ce qu'il annonce faire (de manière formelle, dans sa signature) ; + * Terminaison, si nécessaire ; + * Absence de fuites mémoires ; + * Absence d'opérations pour lesquelles le bloc ne dispose pas de privilèges (accès à la mémoire d'autres blocs, altération de données, …); + +Ces preuves permettent au système d'exécuter un bloc sans aucune contrainte (pas de nécessité d'isoler les processus, pas de vérification de droit d'accès), après en avoir vérifié les preuves. Cela permet aussi de prouver des blocs plus gros en se basant sur les preuves des blocs utilisés dans sa construction, et ainsi de s'assurer de l'absence d'erreurs de programmation. + +== Liens Externes == + + * [[http://lambda-the-ultimate.org/|lambda-the-ultimate.org]] : Excelent blog collectif sur la théorie des langages de programmation ; + * [[http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf|Programming Paradigms for Dummies]] : Un résumé des différents paradigmes de programmation et leurs principes ; + * [[http://en.wikipedia.org/wiki/Flow-based_programming|Flow-based programming]] (wikipedia). + +=== À étudier === + + * [[http://books.google.ca/books?id=Q_J4Lnmfjx4C&dq=jay+%22pattern+calculus%22&printsec=frontcover&source=bl&ots=LMLAmh2f4J&sig=qVb9lGsY-cWLpB4ogu53-YlGmnE&hl=en&ei=HkwRS5frGYGOlAfbzuSUBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAgQ6AEwAA#v=onepage&q=&f=false|Pattern Calculus]] ; + * [[http://portal.acm.org/citation.cfm?id=834420|BDL - A Nondeterministic Data Flow Programming Language with Backtracking]]. \ No newline at end of file diff --git a/historique/page/Langage/3/log.txt b/historique/page/Langage/3/log.txt new file mode 100644 index 0000000..e7a2e0f --- /dev/null +++ b/historique/page/Langage/3/log.txt @@ -0,0 +1 @@ +1259300699 js Creer Langage 3 -vide -vide diff --git a/historique/page/Langage/3/source.txt b/historique/page/Langage/3/source.txt new file mode 100644 index 0000000..22fb1e2 --- /dev/null +++ b/historique/page/Langage/3/source.txt @@ -0,0 +1,24 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitive fixe, et suivant le pradigme du dataflow. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits. + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments. + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments principaux du langage sont : + * '''Les blocs''', qui sont les composants + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres + * '''Les connexions'''. + diff --git a/historique/page/Langage/4/log.txt b/historique/page/Langage/4/log.txt new file mode 100644 index 0000000..941528e --- /dev/null +++ b/historique/page/Langage/4/log.txt @@ -0,0 +1 @@ +1259311081 js Creer Langage 4 -vide -vide diff --git a/historique/page/Langage/4/source.txt b/historique/page/Langage/4/source.txt new file mode 100644 index 0000000..bdd410a --- /dev/null +++ b/historique/page/Langage/4/source.txt @@ -0,0 +1,28 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitive fixe, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent représenter un objet, une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), une fonction, un document, une règle (par ex. logique ou de filtrage), … + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. \ No newline at end of file diff --git a/historique/page/Langage/5/log.txt b/historique/page/Langage/5/log.txt new file mode 100644 index 0000000..659b488 --- /dev/null +++ b/historique/page/Langage/5/log.txt @@ -0,0 +1 @@ +1259314263 js Creer Langage 5 -vide -vide diff --git a/historique/page/Langage/5/source.txt b/historique/page/Langage/5/source.txt new file mode 100644 index 0000000..6722700 --- /dev/null +++ b/historique/page/Langage/5/source.txt @@ -0,0 +1,32 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitive fixe, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent représenter un objet, une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), une fonction, un document, une règle (par ex. logique ou de filtrage), … + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitive fixe == \ No newline at end of file diff --git a/historique/page/Langage/6/log.txt b/historique/page/Langage/6/log.txt new file mode 100644 index 0000000..f41ece1 --- /dev/null +++ b/historique/page/Langage/6/log.txt @@ -0,0 +1 @@ +1259314280 js Creer Langage 6 -vide -vide diff --git a/historique/page/Langage/6/source.txt b/historique/page/Langage/6/source.txt new file mode 100644 index 0000000..29643c7 --- /dev/null +++ b/historique/page/Langage/6/source.txt @@ -0,0 +1,36 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitive fixe, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent représenter un objet, une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), une fonction, un document, une règle (par ex. logique ou de filtrage), … + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitive fixe == + +== Dataflow == + +== Preuves == \ No newline at end of file diff --git a/historique/page/Langage/7/log.txt b/historique/page/Langage/7/log.txt new file mode 100644 index 0000000..e6e0849 --- /dev/null +++ b/historique/page/Langage/7/log.txt @@ -0,0 +1 @@ +1259323264 js Creer Langage 7 -vide -vide diff --git a/historique/page/Langage/7/source.txt b/historique/page/Langage/7/source.txt new file mode 100644 index 0000000..29643c7 --- /dev/null +++ b/historique/page/Langage/7/source.txt @@ -0,0 +1,36 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitive fixe, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent représenter un objet, une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), une fonction, un document, une règle (par ex. logique ou de filtrage), … + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitive fixe == + +== Dataflow == + +== Preuves == \ No newline at end of file diff --git a/historique/page/Langage/8/log.txt b/historique/page/Langage/8/log.txt new file mode 100644 index 0000000..4d5692c --- /dev/null +++ b/historique/page/Langage/8/log.txt @@ -0,0 +1 @@ +1259521261 js Creer Langage 8 -vide -vide diff --git a/historique/page/Langage/8/source.txt b/historique/page/Langage/8/source.txt new file mode 100644 index 0000000..29643c7 --- /dev/null +++ b/historique/page/Langage/8/source.txt @@ -0,0 +1,36 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitive fixe, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent représenter un objet, une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), une fonction, un document, une règle (par ex. logique ou de filtrage), … + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitive fixe == + +== Dataflow == + +== Preuves == \ No newline at end of file diff --git a/historique/page/Langage/9/log.txt b/historique/page/Langage/9/log.txt new file mode 100644 index 0000000..65307db --- /dev/null +++ b/historique/page/Langage/9/log.txt @@ -0,0 +1 @@ +1259603152 js Creer Langage 9 -vide -vide diff --git a/historique/page/Langage/9/source.txt b/historique/page/Langage/9/source.txt new file mode 100644 index 0000000..3bc7220 --- /dev/null +++ b/historique/page/Langage/9/source.txt @@ -0,0 +1,40 @@ +page + += Langage = + +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le pradigme du dataflow, et dont les programmes sont destinés à être prouvés. + +== Graphique == + +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. + +La programmation graphique permet d'éviter certain écueil de la langage de la programmation textuelle : + * '''Conflis de nommage''', résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante desidentifiants précédements définits ; + * '''Encombrement visuel''', lorsque le code important est noyé dans par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, ...), ce mécanisme n'est toute fois pas pratique et il ne permet pas de masquer de petits éléments ; + * La '''méta-programmation''' est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, ... De plus, on peut représenter les nouvelles syntaxes par des modèles dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardus. + +== Composants == + +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construis en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. + +Les éléments syntaxiques principaux du langage sont : + * '''Les blocs''', qui sont les composants ; + * '''Les ports''', qui sont les points permettant la connexion d'un bloc aux autres ; + * '''Les connexions'''. + +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : + * Les blocs peuvent représenter un objet, une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), une fonction, un document, une règle (par ex. logique ou de filtrage), … + * Les ports peuvent contenir les informations de typage, et des contraintes ; + * Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. + +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. + +== Sans primitives fixées == + +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. + +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. + +== Dataflow == + +== Preuves == \ No newline at end of file diff --git a/historique/page/Langage/version.txt b/historique/page/Langage/version.txt new file mode 100644 index 0000000..b5045cc --- /dev/null +++ b/historique/page/Langage/version.txt @@ -0,0 +1 @@ +21 \ No newline at end of file diff --git a/historique/page/Licence/0/log.txt b/historique/page/Licence/0/log.txt new file mode 100644 index 0000000..5a1b0fb --- /dev/null +++ b/historique/page/Licence/0/log.txt @@ -0,0 +1 @@ +1260009715 js Creer Licence 0 -vide -vide diff --git a/historique/page/Licence/0/source.txt b/historique/page/Licence/0/source.txt new file mode 100644 index 0000000..8eacaed --- /dev/null +++ b/historique/page/Licence/0/source.txt @@ -0,0 +1,18 @@ +page + += Licence = + +Ci-dessous, «ce travail» désigne à la fois, sauf mention explicite du contraire : + * le contenu du site web http://gruntnetwork.com/ ; + * sa mise en page ; + * sa mise en forme ; + * le code source du logiciel «fastiki» permettant le fonctionnement de ce site web ; + * le code source du projet gruntnetwork, ainsi que toutes les données relatives à ce projet (images, polices de caractère, version compilée, …) . + +== Termes de la licence == + +Vous êtes autorisé à redistribuer ce travail sous n'importe quelle licence (y compris le libérer dans le domaine public, lorsque c'est possible), sous n'importe quelle forme, et vous n'êtes pas obligé de mentionner l'auteur original pour le faire. + +Ce travail est fourni SANS AUCUNE GARANTIE, dans les limites imposées par la loi. En particulier, l'auteur ne saurait être tenu responsable de tout dommage ou préjudice découlant de l'utilisation de ce travail ou des informations qu'il contient, y compris, mais sans se limiter à ces cas particuliers : + * Dommages financiers ou matériels ; + * Informations erronnées. \ No newline at end of file diff --git a/historique/page/Licence/1/log.txt b/historique/page/Licence/1/log.txt new file mode 100644 index 0000000..cbb7d01 --- /dev/null +++ b/historique/page/Licence/1/log.txt @@ -0,0 +1 @@ +1260025956 js Creer Licence 1 -vide -vide diff --git a/historique/page/Licence/1/source.txt b/historique/page/Licence/1/source.txt new file mode 100644 index 0000000..20de07f --- /dev/null +++ b/historique/page/Licence/1/source.txt @@ -0,0 +1,28 @@ +page + += Licence = + +Ci-dessous, «ce travail» désigne à la fois, sauf mention explicite du contraire : + * le contenu du site web http://gruntnetwork.com/ ; + * sa mise en page ; + * sa mise en forme ; + * le code source du logiciel «fastiki» permettant le fonctionnement de ce site web ; + * le code source du projet gruntnetwork, ainsi que toutes les données relatives à ce projet (images, polices de caractère, version compilée, …) . + +== Termes de la licence == + +Vous êtes autorisé à redistribuer ce travail sous n'importe quelle licence (y compris le libérer dans le domaine public, lorsque c'est possible), sous n'importe quelle forme, et vous n'êtes pas obligé de mentionner l'auteur original pour le faire. + +== Absence de garantie == + +'''Ce travail est fourni ''SANS AUCUNE GARANTIE'', ni exprimée, ni sous-entendue, dans les limites imposées par la loi. Entre autres, aucune garantie n'est donnée qualifiant ce travail comme commercialisable, ou comme adapté à un usage en particulier, ou comme compatible avec l'utilisation d'autres travaux.''' + +== Absence de responsabilité == + +'''En particulier, l'auteur ne saurait être tenu responsable de tout dommage ou préjudice découlant directement ou indirectement de l'utilisation de ce travail ou des informations qu'il contient, y compris, mais sans se limiter à ces cas particuliers, des dommages financiers ou matériels, la perte ou la modification d'informations, ou la présence d'informations erronnées dans ce travail.''' + +'''En utilisant ce travail, vous acceptez entièrement de le faire à vos risques et périls. Quand bien même ce travail contiendrait des défauts, vous assumerez vous-même les coûts de réparation du problème.''' + +== Lorsque ces termes ne sont pas appliquables == + +Si les termes de la licence ou décrivant l'absence de responsabilité ne pouvaient être appliqués conformément aux législations locales, les cours de justice examinant le cas doivent appliquer les lois locales se rapprochant le plus d'une absence totale de droit d'auteur sur le travail, et d'une absence totale de garantie et de responsabilité, quelles qu'elles soient, sur le travail. \ No newline at end of file diff --git a/historique/page/Licence/2/log.txt b/historique/page/Licence/2/log.txt new file mode 100644 index 0000000..556418c --- /dev/null +++ b/historique/page/Licence/2/log.txt @@ -0,0 +1 @@ +1260026797 js Creer Licence 2 -vide -vide diff --git a/historique/page/Licence/2/source.txt b/historique/page/Licence/2/source.txt new file mode 100644 index 0000000..37b3003 --- /dev/null +++ b/historique/page/Licence/2/source.txt @@ -0,0 +1,30 @@ +page + += Licence = + +Ci-dessous, «ce travail» désigne à la fois, sauf mention explicite du contraire : + * le contenu du site web http://gruntnetwork.com/ ; + * sa mise en page ; + * sa mise en forme ; + * le code source du logiciel «fastiki» permettant le fonctionnement de ce site web ; + * le code source du projet gruntnetwork, ainsi que toutes les données relatives à ce projet (images, polices de caractère, version compilée, …) . + +== Termes de la licence == + +Vous êtes autorisé à redistribuer tout ou partie de ce travail, ainsi que des travaux dérivés ou des versions ayant subi des modifications d'une quelconque importance, sous n'importe quelle licence (y compris le libérer dans le domaine public, lorsque c'est possible), sous n'importe quelle forme, et vous n'êtes pas obligé de mentionner l'auteur original pour le faire. + +Lorsque vous apportez des modifications à ce travail, il sera grandement apprécié que toute référence à l'auteur original soit supprimée, ou bien soit accompagnée d'une indication claire et sans équivoque expliquant que d'autres personnes ont apporté des modifications, et que l'auteur original n'est pas responsable de défauts découlant de ces modifications. + +== Absence de garantie == + +'''Ce travail est fourni ''SANS AUCUNE GARANTIE'', ni exprimée, ni sous-entendue, dans les limites imposées par la loi. Entre autres, aucune garantie n'est donnée qualifiant ce travail comme commercialisable, ou comme adapté à un usage en particulier, ou comme compatible avec l'utilisation d'autres travaux.''' + +== Absence de responsabilité == + +'''En particulier, l'auteur ne saurait être tenu responsable de tout dommage ou préjudice découlant directement ou indirectement de l'utilisation de ce travail ou des informations qu'il contient, quand bien même il aurait une connaissance préalable du risque, y compris, mais sans se limiter à ces cas particuliers, des dommages financiers ou matériels, la perte ou la modification d'informations, ou la présence d'informations erronnées dans ce travail.''' + +'''En utilisant ce travail, vous acceptez entièrement de le faire à vos risques et périls. Quand bien même ce travail contiendrait des défauts, vous assumerez vous-même les coûts de réparation du problème.''' + +== Lorsque ces termes ne sont pas appliquables == + +Si les termes de la licence ou décrivant l'absence de responsabilité ne pouvaient être appliqués conformément aux législations locales, les cours de justice examinant le cas doivent appliquer les lois locales se rapprochant le plus d'une absence totale de droit d'auteur sur le travail, et d'une absence totale de garantie et de responsabilité, quelles qu'elles soient, sur le travail. \ No newline at end of file diff --git a/historique/page/Licence/3/log.txt b/historique/page/Licence/3/log.txt new file mode 100644 index 0000000..d7a3283 --- /dev/null +++ b/historique/page/Licence/3/log.txt @@ -0,0 +1 @@ +1260026929 js Creer Licence 3 -vide -vide diff --git a/historique/page/Licence/3/source.txt b/historique/page/Licence/3/source.txt new file mode 100644 index 0000000..69f5810 --- /dev/null +++ b/historique/page/Licence/3/source.txt @@ -0,0 +1,30 @@ +page + += Licence = + +Ci-dessous, «ce travail» désigne à la fois, sauf mention explicite du contraire : + * le contenu du site web http://gruntnetwork.com/ ; + * sa mise en page ; + * sa mise en forme ; + * le code source du logiciel «fastiki» permettant le fonctionnement de ce site web ; + * le code source du projet gruntnetwork, ainsi que toutes les données relatives à ce projet (images, polices de caractère, version compilée, …) . + +== Termes de la licence == + +Vous êtes autorisé à redistribuer tout ou partie de ce travail, ainsi que des travaux dérivés ou des versions ayant subi des modifications d'une quelconque importance, sous n'importe quelle licence (y compris le libérer dans le domaine public, lorsque c'est possible), sous n'importe quelle forme, et vous n'êtes pas obligé de mentionner l'auteur original pour le faire. + +Lorsque vous apportez des modifications à ce travail, il sera grandement apprécié que toute référence à l'auteur original soit supprimée, ou bien soit accompagnée d'une indication claire et sans équivoque expliquant que d'autres personnes ont apporté des modifications, et que l'auteur original n'est pas responsable de défauts découlant de ces modifications. + +== Absence de garantie == + +'''Ce travail est mis à disposition du public dans l'espoir qu'il sera utile, mais ''SANS AUCUNE GARANTIE'', ni exprimée, ni sous-entendue, dans les limites imposées par la loi. Entre autres, aucune garantie n'est donnée qualifiant ce travail comme commercialisable, ou comme adapté à un usage en particulier, ou comme compatible avec l'utilisation d'autres travaux.''' + +== Absence de responsabilité == + +'''En particulier, l'auteur ne saurait être tenu responsable de tout dommage ou préjudice découlant directement ou indirectement de l'utilisation de ce travail ou des informations qu'il contient, quand bien même il aurait une connaissance préalable du risque, y compris, mais sans se limiter à ces cas particuliers, des dommages financiers ou matériels, la perte ou la modification d'informations, ou la présence d'informations erronnées dans ce travail.''' + +'''En utilisant ce travail, vous acceptez entièrement de le faire à vos risques et périls. Quand bien même ce travail contiendrait des défauts, vous assumerez vous-même les coûts de réparation du problème.''' + +== Lorsque ces termes ne sont pas appliquables == + +Si les termes de la licence ou décrivant l'absence de responsabilité ne pouvaient être appliqués conformément aux législations locales, les cours de justice examinant le cas doivent appliquer les lois locales se rapprochant le plus d'une absence totale de droit d'auteur sur le travail, et d'une absence totale de garantie et de responsabilité, quelles qu'elles soient, sur le travail. \ No newline at end of file diff --git a/historique/page/Licence/4/log.txt b/historique/page/Licence/4/log.txt new file mode 100644 index 0000000..249c1c5 --- /dev/null +++ b/historique/page/Licence/4/log.txt @@ -0,0 +1 @@ +1260027054 js Creer Licence 4 -vide -vide diff --git a/historique/page/Licence/4/source.txt b/historique/page/Licence/4/source.txt new file mode 100644 index 0000000..134790f --- /dev/null +++ b/historique/page/Licence/4/source.txt @@ -0,0 +1,34 @@ +page + += Licence = + +Ci-dessous, «ce travail» désigne à la fois, sauf mention explicite du contraire : + * le contenu du site web http://gruntnetwork.com/ ; + * sa mise en page ; + * sa mise en forme ; + * le code source du logiciel «fastiki» permettant le fonctionnement de ce site web ; + * le code source du projet gruntnetwork, ainsi que toutes les données relatives à ce projet (images, polices de caractère, version compilée, …) . + +== Termes de la licence == + +Vous êtes autorisé à redistribuer tout ou partie de ce travail, ainsi que des travaux dérivés ou des versions ayant subi des modifications d'une quelconque importance, sous n'importe quelle licence (y compris le libérer dans le domaine public, lorsque c'est possible), sous n'importe quelle forme, et vous n'êtes pas obligé de mentionner l'auteur original pour le faire. + +Lorsque vous apportez des modifications à ce travail, il sera grandement apprécié que toute référence à l'auteur original soit supprimée, ou bien soit accompagnée d'une indication claire et sans équivoque expliquant que d'autres personnes ont apporté des modifications, et que l'auteur original n'est pas responsable de défauts découlant de ces modifications. + +== Absence de garantie == + +'''Ce travail est mis à disposition du public dans l'espoir qu'il sera utile, mais ''SANS AUCUNE GARANTIE'', ni exprimée, ni sous-entendue, dans les limites imposées par la loi. Entre autres, aucune garantie n'est donnée qualifiant ce travail comme commercialisable, ou comme adapté à un usage en particulier, ou comme compatible avec l'utilisation d'autres travaux.''' + +== Absence de responsabilité == + +'''En particulier, l'auteur ne saurait être tenu responsable de tout dommage ou préjudice découlant directement ou indirectement de l'utilisation de ce travail ou des informations qu'il contient, quand bien même il aurait une connaissance préalable du risque, y compris, mais sans se limiter à ces cas particuliers, des dommages financiers ou matériels, la perte ou la modification d'informations, ou la présence d'informations erronnées dans ce travail.''' + +'''En utilisant ce travail, vous acceptez entièrement de le faire à vos risques et périls. Quand bien même ce travail contiendrait des défauts, vous assumerez vous-même les coûts de réparation du problème.''' + +== Lorsque ces termes ne sont pas appliquables == + +Si les termes de la licence ou décrivant l'absence de responsabilité ne pouvaient être appliqués conformément aux législations locales, les cours de justice examinant le cas doivent appliquer les lois locales se rapprochant le plus d'une absence totale de droit d'auteur sur le travail, et d'une absence totale de garantie et de responsabilité, quelles qu'elles soient, sur le travail. + +== Intention == + +Ce travail est mis à disposition du public dans l'espoir qu'il sera utile, mais l'auteur ne souhaite pas être importuné par une quelconque responsabilité ou obligation. L'auteur ne souhaite pas particulièrement qu'on lui attribue son travail, et n'a rien contre la ré-utilisation de son travail. \ No newline at end of file diff --git a/historique/page/Licence/5/log.txt b/historique/page/Licence/5/log.txt new file mode 100644 index 0000000..0fb4839 --- /dev/null +++ b/historique/page/Licence/5/log.txt @@ -0,0 +1 @@ +1260027296 js Creer Licence 5 -vide -vide diff --git a/historique/page/Licence/5/source.txt b/historique/page/Licence/5/source.txt new file mode 100644 index 0000000..97c667a --- /dev/null +++ b/historique/page/Licence/5/source.txt @@ -0,0 +1,35 @@ +page + += Licence = + +Ci-dessous, «ce travail» désigne à la fois, sauf mention explicite du contraire : + * le contenu du site web http://gruntnetwork.com/ ; + * sa mise en page ; + * sa mise en forme ; + * le code source du logiciel «fastiki» permettant le fonctionnement de ce site web ; + * le code source du projet gruntnetwork, ainsi que toutes les données relatives à ce projet (images, polices de caractère, version compilée, …) ; + * la licence de ce projet elle-même. + +== Termes de la licence == + +Vous êtes autorisé à redistribuer tout ou partie de ce travail, ainsi que des travaux dérivés ou des versions ayant subi des modifications d'une quelconque importance, sous n'importe quelle licence (y compris le libérer dans le domaine public, lorsque c'est possible), sous n'importe quelle forme, et vous n'êtes pas obligé de mentionner l'auteur original pour le faire. + +Lorsque vous apportez des modifications à ce travail, il sera grandement apprécié que toute référence à l'auteur original soit supprimée, ou bien soit accompagnée d'une indication claire et sans équivoque expliquant que d'autres personnes ont apporté des modifications, et que l'auteur original n'est pas responsable de défauts découlant de ces modifications. + +== Absence de garantie == + +'''Ce travail est mis à disposition du public dans l'espoir qu'il sera utile, mais ''SANS AUCUNE GARANTIE'', ni exprimée, ni sous-entendue, dans les limites imposées par la loi. Entre autres, aucune garantie n'est donnée qualifiant ce travail comme commercialisable, ou comme adapté à un usage en particulier, ou comme compatible avec l'utilisation d'autres travaux.''' + +== Absence de responsabilité == + +'''En particulier, l'auteur ne saurait être tenu responsable de tout dommage ou préjudice découlant directement ou indirectement de l'utilisation de ce travail ou des informations qu'il contient, quand bien même il aurait une connaissance préalable du risque, y compris, mais sans se limiter à ces cas particuliers, des dommages financiers ou matériels, la perte ou la modification d'informations, ou la présence d'informations erronnées dans ce travail.''' + +'''En utilisant ce travail, vous acceptez entièrement de le faire à vos risques et périls. Quand bien même ce travail contiendrait des défauts, vous assumerez vous-même les coûts de réparation du problème.''' + +== Lorsque ces termes ne sont pas appliquables == + +Si les termes de la licence ou décrivant l'absence de responsabilité ne pouvaient être appliqués conformément aux législations locales, les cours de justice examinant le cas doivent appliquer les lois locales se rapprochant le plus d'une absence totale de droit d'auteur sur le travail, et d'une absence totale de garantie et de responsabilité, quelles qu'elles soient, sur le travail. + +== Intention == + +Ce travail est mis à disposition du public dans l'espoir qu'il sera utile, mais l'auteur ne souhaite pas être importuné par une quelconque responsabilité ou obligation. L'auteur ne souhaite pas particulièrement qu'on lui attribue son travail, et n'a rien contre la ré-utilisation de son travail. \ No newline at end of file diff --git a/historique/page/Licence/version.txt b/historique/page/Licence/version.txt new file mode 100644 index 0000000..7813681 --- /dev/null +++ b/historique/page/Licence/version.txt @@ -0,0 +1 @@ +5 \ No newline at end of file diff --git a/historique/page/Nouvelle page/0/log.txt b/historique/page/Nouvelle page/0/log.txt new file mode 100644 index 0000000..8890d09 --- /dev/null +++ b/historique/page/Nouvelle page/0/log.txt @@ -0,0 +1 @@ +1259271912 js RenomerVers Nouvelle-20page 0 Accueil 0 diff --git a/historique/page/Nouvelle page/version.txt b/historique/page/Nouvelle page/version.txt new file mode 100644 index 0000000..c227083 --- /dev/null +++ b/historique/page/Nouvelle page/version.txt @@ -0,0 +1 @@ +0 \ No newline at end of file diff --git a/historique/page/Systeme de fichiers.html/0/log.txt b/historique/page/Systeme de fichiers.html/0/log.txt new file mode 100644 index 0000000..b8a7ed8 --- /dev/null +++ b/historique/page/Systeme de fichiers.html/0/log.txt @@ -0,0 +1 @@ +1259863232 js Creer Systeme-20de-20fichiers.html 0 -vide -vide diff --git a/historique/page/Systeme de fichiers.html/0/source.txt b/historique/page/Systeme de fichiers.html/0/source.txt new file mode 100644 index 0000000..7b20a2b --- /dev/null +++ b/historique/page/Systeme de fichiers.html/0/source.txt @@ -0,0 +1,30 @@ +page + += Systeme de fichiers.html = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +== Vues et versions parallèles == + +== Caches et données temporaires == + diff --git a/historique/page/Systeme de fichiers.html/1/log.txt b/historique/page/Systeme de fichiers.html/1/log.txt new file mode 100644 index 0000000..33bf307 --- /dev/null +++ b/historique/page/Systeme de fichiers.html/1/log.txt @@ -0,0 +1 @@ +1259863251 js Creer Systeme-20de-20fichiers.html 1 -vide -vide diff --git a/historique/page/Systeme de fichiers.html/1/source.txt b/historique/page/Systeme de fichiers.html/1/source.txt new file mode 100644 index 0000000..7b20a2b --- /dev/null +++ b/historique/page/Systeme de fichiers.html/1/source.txt @@ -0,0 +1,30 @@ +page + += Systeme de fichiers.html = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +== Vues et versions parallèles == + +== Caches et données temporaires == + diff --git a/historique/page/Systeme de fichiers.html/2/log.txt b/historique/page/Systeme de fichiers.html/2/log.txt new file mode 100644 index 0000000..ab37f35 --- /dev/null +++ b/historique/page/Systeme de fichiers.html/2/log.txt @@ -0,0 +1 @@ +1259867335 js Creer Systeme-20de-20fichiers.html 2 -vide -vide diff --git a/historique/page/Systeme de fichiers.html/2/source.txt b/historique/page/Systeme de fichiers.html/2/source.txt new file mode 100644 index 0000000..57f551d --- /dev/null +++ b/historique/page/Systeme de fichiers.html/2/source.txt @@ -0,0 +1,47 @@ +page + += Systeme de fichiers.html = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Systeme de fichiers.html/3/log.txt b/historique/page/Systeme de fichiers.html/3/log.txt new file mode 100644 index 0000000..bdb7d56 --- /dev/null +++ b/historique/page/Systeme de fichiers.html/3/log.txt @@ -0,0 +1 @@ +1259869519 js Creer Systeme-20de-20fichiers.html 3 -vide -vide diff --git a/historique/page/Systeme de fichiers.html/3/source.txt b/historique/page/Systeme de fichiers.html/3/source.txt new file mode 100644 index 0000000..7cf722d --- /dev/null +++ b/historique/page/Systeme de fichiers.html/3/source.txt @@ -0,0 +1,47 @@ +page + += Systeme de fichiers.html = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Systeme de fichiers.html/4/log.txt b/historique/page/Systeme de fichiers.html/4/log.txt new file mode 100644 index 0000000..9270f08 --- /dev/null +++ b/historique/page/Systeme de fichiers.html/4/log.txt @@ -0,0 +1 @@ +1259869533 js RenomerVers Systeme-20de-20fichiers.html 4 Système-20de-20fichiers.html 0 diff --git a/historique/page/Systeme de fichiers.html/version.txt b/historique/page/Systeme de fichiers.html/version.txt new file mode 100644 index 0000000..bf0d87a --- /dev/null +++ b/historique/page/Systeme de fichiers.html/version.txt @@ -0,0 +1 @@ +4 \ No newline at end of file diff --git a/historique/page/Système de fichiers.html/0/log.txt b/historique/page/Système de fichiers.html/0/log.txt new file mode 100644 index 0000000..8774ed5 --- /dev/null +++ b/historique/page/Système de fichiers.html/0/log.txt @@ -0,0 +1 @@ +1259869533 js RenomerDepuis Système-20de-20fichiers.html 0 Systeme-20de-20fichiers.html 3 diff --git a/historique/page/Système de fichiers.html/0/source.txt b/historique/page/Système de fichiers.html/0/source.txt new file mode 100644 index 0000000..7cf722d --- /dev/null +++ b/historique/page/Système de fichiers.html/0/source.txt @@ -0,0 +1,47 @@ +page + += Systeme de fichiers.html = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Système de fichiers.html/1/log.txt b/historique/page/Système de fichiers.html/1/log.txt new file mode 100644 index 0000000..79b48cc --- /dev/null +++ b/historique/page/Système de fichiers.html/1/log.txt @@ -0,0 +1 @@ +1259869730 js RenomerVers Système-20de-20fichiers.html 1 Système-20de-20fichiers 0 diff --git a/historique/page/Système de fichiers.html/version.txt b/historique/page/Système de fichiers.html/version.txt new file mode 100644 index 0000000..56a6051 --- /dev/null +++ b/historique/page/Système de fichiers.html/version.txt @@ -0,0 +1 @@ +1 \ No newline at end of file diff --git a/historique/page/Système de fichiers/0/log.txt b/historique/page/Système de fichiers/0/log.txt new file mode 100644 index 0000000..5a990ca --- /dev/null +++ b/historique/page/Système de fichiers/0/log.txt @@ -0,0 +1 @@ +1259869730 js RenomerDepuis Système-20de-20fichiers 0 Système-20de-20fichiers.html 0 diff --git a/historique/page/Système de fichiers/0/source.txt b/historique/page/Système de fichiers/0/source.txt new file mode 100644 index 0000000..7cf722d --- /dev/null +++ b/historique/page/Système de fichiers/0/source.txt @@ -0,0 +1,47 @@ +page + += Systeme de fichiers.html = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Système de fichiers/1/log.txt b/historique/page/Système de fichiers/1/log.txt new file mode 100644 index 0000000..307fcc8 --- /dev/null +++ b/historique/page/Système de fichiers/1/log.txt @@ -0,0 +1 @@ +1259869760 js Creer Système-20de-20fichiers 1 -vide -vide diff --git a/historique/page/Système de fichiers/1/source.txt b/historique/page/Système de fichiers/1/source.txt new file mode 100644 index 0000000..006d7f4 --- /dev/null +++ b/historique/page/Système de fichiers/1/source.txt @@ -0,0 +1,47 @@ +page + += Système de fichiers = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Système de fichiers/2/log.txt b/historique/page/Système de fichiers/2/log.txt new file mode 100644 index 0000000..9ca5813 --- /dev/null +++ b/historique/page/Système de fichiers/2/log.txt @@ -0,0 +1 @@ +1259966078 js Creer Système-20de-20fichiers 2 -vide -vide diff --git a/historique/page/Système de fichiers/2/source.txt b/historique/page/Système de fichiers/2/source.txt new file mode 100644 index 0000000..4e66504 --- /dev/null +++ b/historique/page/Système de fichiers/2/source.txt @@ -0,0 +1,55 @@ +page + += Système de fichiers = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Structuration et archivage == + +Par défaut, au lieu de structurer l'ensemble des données avec des dossiers, le système propose une structuration en projets (et si nécessaire sous-projets) et bibliothèques. Les bibliothèques contiennent les données qui n'ont pas été créées par l'utilisateur, par exemple sa bibliothèque musicale, un recueil de documentations, etc. Les projets contiennent les documents créés par l'utilisateur, groupés, comme leur nom l'indique, lorsqu'ils font partie du même projet. + +L'écran d'accueil liste les projets actifs sur lesquels l'utilisateur est suceptible de vouloir travailler, ainsi que divers points d'accès à ses bibliothèques, et une liste de tâches courantes de maintenance (effectuer des sauvegardes, archiver un projet, ajouter des outils, gérer les utilisateurs du système, …). + +Lorsqu'un utilisateur a terminé son activité sur un projet, il peut l'archiver (tous les [#Caches et données temporaires|caches] (voir plus bas), sauf les plus suceptibles d'être utilisés sont supprimés, une sauvegarde est automatiquement proposée et le projet n'apparaît plus dans la liste des projets actifs). Après un certain temps d'archivage sans visualisation, tout ou partie du projet peut être compressé, tous les caches effacés et, dans un système à grande échelle, le projet pourraît être déplacé vers une zone de stockage secondaire (sur bande par exemple). + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Système de fichiers/3/log.txt b/historique/page/Système de fichiers/3/log.txt new file mode 100644 index 0000000..9e951f2 --- /dev/null +++ b/historique/page/Système de fichiers/3/log.txt @@ -0,0 +1 @@ +1260009780 js Creer Système-20de-20fichiers 3 -vide -vide diff --git a/historique/page/Système de fichiers/3/source.txt b/historique/page/Système de fichiers/3/source.txt new file mode 100644 index 0000000..4e66504 --- /dev/null +++ b/historique/page/Système de fichiers/3/source.txt @@ -0,0 +1,55 @@ +page + += Système de fichiers = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Structuration et archivage == + +Par défaut, au lieu de structurer l'ensemble des données avec des dossiers, le système propose une structuration en projets (et si nécessaire sous-projets) et bibliothèques. Les bibliothèques contiennent les données qui n'ont pas été créées par l'utilisateur, par exemple sa bibliothèque musicale, un recueil de documentations, etc. Les projets contiennent les documents créés par l'utilisateur, groupés, comme leur nom l'indique, lorsqu'ils font partie du même projet. + +L'écran d'accueil liste les projets actifs sur lesquels l'utilisateur est suceptible de vouloir travailler, ainsi que divers points d'accès à ses bibliothèques, et une liste de tâches courantes de maintenance (effectuer des sauvegardes, archiver un projet, ajouter des outils, gérer les utilisateurs du système, …). + +Lorsqu'un utilisateur a terminé son activité sur un projet, il peut l'archiver (tous les [#Caches et données temporaires|caches] (voir plus bas), sauf les plus suceptibles d'être utilisés sont supprimés, une sauvegarde est automatiquement proposée et le projet n'apparaît plus dans la liste des projets actifs). Après un certain temps d'archivage sans visualisation, tout ou partie du projet peut être compressé, tous les caches effacés et, dans un système à grande échelle, le projet pourraît être déplacé vers une zone de stockage secondaire (sur bande par exemple). + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Système de fichiers/4/log.txt b/historique/page/Système de fichiers/4/log.txt new file mode 100644 index 0000000..04809c7 --- /dev/null +++ b/historique/page/Système de fichiers/4/log.txt @@ -0,0 +1 @@ +1260466445 js Creer Système-20de-20fichiers 4 -vide -vide diff --git a/historique/page/Système de fichiers/4/source.txt b/historique/page/Système de fichiers/4/source.txt new file mode 100644 index 0000000..4e66504 --- /dev/null +++ b/historique/page/Système de fichiers/4/source.txt @@ -0,0 +1,55 @@ +page + += Système de fichiers = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Structuration et archivage == + +Par défaut, au lieu de structurer l'ensemble des données avec des dossiers, le système propose une structuration en projets (et si nécessaire sous-projets) et bibliothèques. Les bibliothèques contiennent les données qui n'ont pas été créées par l'utilisateur, par exemple sa bibliothèque musicale, un recueil de documentations, etc. Les projets contiennent les documents créés par l'utilisateur, groupés, comme leur nom l'indique, lorsqu'ils font partie du même projet. + +L'écran d'accueil liste les projets actifs sur lesquels l'utilisateur est suceptible de vouloir travailler, ainsi que divers points d'accès à ses bibliothèques, et une liste de tâches courantes de maintenance (effectuer des sauvegardes, archiver un projet, ajouter des outils, gérer les utilisateurs du système, …). + +Lorsqu'un utilisateur a terminé son activité sur un projet, il peut l'archiver (tous les [#Caches et données temporaires|caches] (voir plus bas), sauf les plus suceptibles d'être utilisés sont supprimés, une sauvegarde est automatiquement proposée et le projet n'apparaît plus dans la liste des projets actifs). Après un certain temps d'archivage sans visualisation, tout ou partie du projet peut être compressé, tous les caches effacés et, dans un système à grande échelle, le projet pourraît être déplacé vers une zone de stockage secondaire (sur bande par exemple). + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Système de fichiers/5/log.txt b/historique/page/Système de fichiers/5/log.txt new file mode 100644 index 0000000..e1a6b8e --- /dev/null +++ b/historique/page/Système de fichiers/5/log.txt @@ -0,0 +1 @@ +1260637053 js Creer Système-20de-20fichiers 5 -vide -vide diff --git a/historique/page/Système de fichiers/5/source.txt b/historique/page/Système de fichiers/5/source.txt new file mode 100644 index 0000000..12dcd5c --- /dev/null +++ b/historique/page/Système de fichiers/5/source.txt @@ -0,0 +1,55 @@ +page + += Système de fichiers = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Structuration et archivage == + +Par défaut, au lieu de structurer l'ensemble des données avec des dossiers, le système propose une structuration en projets (et si nécessaire sous-projets) et bibliothèques. Les bibliothèques contiennent les données qui n'ont pas été créées par l'utilisateur, par exemple sa bibliothèque musicale, un recueil de documentations, etc. Les projets contiennent les documents créés par l'utilisateur, groupés, comme leur nom l'indique, lorsqu'ils font partie du même projet. + +L'écran d'accueil liste les projets actifs sur lesquels l'utilisateur est suceptible de vouloir travailler, ainsi que divers points d'accès à ses bibliothèques, et une liste de tâches courantes de maintenance (effectuer des sauvegardes, archiver un projet, ajouter des outils, gérer les utilisateurs du système, …). + +Lorsqu'un utilisateur a terminé son activité sur un projet, il peut l'archiver (tous les [#Caches et données temporaires|caches] (voir plus bas), sauf les plus suceptibles d'être utilisés sont supprimés, une sauvegarde est automatiquement proposée et le projet n'apparaît plus dans la liste des projets actifs). Après un certain temps d'archivage sans visualisation, tout ou partie du projet peut être compressé, tous les caches effacés et, dans un système à grande échelle, le projet pourraît être déplacé vers une zone de stockage secondaire (sur bande par exemple). + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). Cel De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Système de fichiers/6/log.txt b/historique/page/Système de fichiers/6/log.txt new file mode 100644 index 0000000..5cc3733 --- /dev/null +++ b/historique/page/Système de fichiers/6/log.txt @@ -0,0 +1 @@ +1260637302 js Creer Système-20de-20fichiers 6 -vide -vide diff --git a/historique/page/Système de fichiers/6/source.txt b/historique/page/Système de fichiers/6/source.txt new file mode 100644 index 0000000..fd8f115 --- /dev/null +++ b/historique/page/Système de fichiers/6/source.txt @@ -0,0 +1,57 @@ +page + += Système de fichiers = + +Le système de fichiers de gruntnetwork est une base de données orientée document. + +== Méta-données == + +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. + +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : + + * noms des personnes présentes dans une photo associés à leur position dans l'image ; + * Notes de marge dans un texte ; + * Tâches à effectuer sur certaines parties du document (TODO) ; + * Commentaires dans programme, explications approfondies dans un texte ; + * Citations et références hypertextes à d'autres documents (locaux ou non). + +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. + +== Versions == + +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. + +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). + +Ceci est facile à mettre en place grâce au côté [Interface Homme-Machine#Interface orientée document|orientée document] du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. + +== Structuration et archivage == + +Par défaut, au lieu de structurer l'ensemble des données avec des dossiers, le système propose une structuration en projets (et si nécessaire sous-projets) et bibliothèques. Les bibliothèques contiennent les données qui n'ont pas été créées par l'utilisateur, par exemple sa bibliothèque musicale, un recueil de documentations, etc. Les projets contiennent les documents créés par l'utilisateur, groupés, comme leur nom l'indique, lorsqu'ils font partie du même projet. + +L'écran d'accueil liste les projets actifs sur lesquels l'utilisateur est suceptible de vouloir travailler, ainsi que divers points d'accès à ses bibliothèques, et une liste de tâches courantes de maintenance (effectuer des sauvegardes, archiver un projet, ajouter des outils, gérer les utilisateurs du système, …). + +Lorsqu'un utilisateur a terminé son activité sur un projet, il peut l'archiver (tous les [#Caches et données temporaires|caches] (voir plus bas), sauf les plus suceptibles d'être utilisés sont supprimés, une sauvegarde est automatiquement proposée et le projet n'apparaît plus dans la liste des projets actifs). Après un certain temps d'archivage sans visualisation, tout ou partie du projet peut être compressé, tous les caches effacés et, dans un système à grande échelle, le projet pourraît être déplacé vers une zone de stockage secondaire (sur bande par exemple). + +== Vues et versions parallèles == + +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. + +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. + +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. + +== Caches et données temporaires == + +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. + +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. + +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. + +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). Cela apporte aussi une plus grande sécurité des données à peu de coût : les documents des utilisateurs pourraient être stockés de manière redondante (RAID, …), tandis que les données temporaires ne le seront pas. Lors de la suppression, les documents utilisateur pourraient nécessiter une confirmation explicite, à l'inverse des données temporaires. + +De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). + +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. \ No newline at end of file diff --git a/historique/page/Système de fichiers/version.txt b/historique/page/Système de fichiers/version.txt new file mode 100644 index 0000000..62f9457 --- /dev/null +++ b/historique/page/Système de fichiers/version.txt @@ -0,0 +1 @@ +6 \ No newline at end of file diff --git a/historique/page/commentaires/0/log.txt b/historique/page/commentaires/0/log.txt new file mode 100644 index 0000000..eed6348 --- /dev/null +++ b/historique/page/commentaires/0/log.txt @@ -0,0 +1 @@ +1259966234 js Creer commentaires 0 -vide -vide diff --git a/historique/page/commentaires/0/source.txt b/historique/page/commentaires/0/source.txt new file mode 100644 index 0000000..546c070 --- /dev/null +++ b/historique/page/commentaires/0/source.txt @@ -0,0 +1,5 @@ +page + += commentaires = + +Insérez vos commentaires ici. \ No newline at end of file diff --git a/historique/page/commentaires/1/log.txt b/historique/page/commentaires/1/log.txt new file mode 100644 index 0000000..d0e4bf4 --- /dev/null +++ b/historique/page/commentaires/1/log.txt @@ -0,0 +1 @@ +1260009853 js Creer commentaires 1 -vide -vide diff --git a/historique/page/commentaires/1/source.txt b/historique/page/commentaires/1/source.txt new file mode 100644 index 0000000..61328ae --- /dev/null +++ b/historique/page/commentaires/1/source.txt @@ -0,0 +1,5 @@ +page + += commentaires = + +Insérez vos commentaires ici. Sachez qu'ils seront publiés sous les termes de la licence du site web (cliquez sur le lien en bas de page pour en prendre connaissance). \ No newline at end of file diff --git a/historique/page/commentaires/2/log.txt b/historique/page/commentaires/2/log.txt new file mode 100644 index 0000000..9751042 --- /dev/null +++ b/historique/page/commentaires/2/log.txt @@ -0,0 +1 @@ +1260466465 js Creer commentaires 2 -vide -vide diff --git a/historique/page/commentaires/2/source.txt b/historique/page/commentaires/2/source.txt new file mode 100644 index 0000000..61328ae --- /dev/null +++ b/historique/page/commentaires/2/source.txt @@ -0,0 +1,5 @@ +page + += commentaires = + +Insérez vos commentaires ici. Sachez qu'ils seront publiés sous les termes de la licence du site web (cliquez sur le lien en bas de page pour en prendre connaissance). \ No newline at end of file diff --git a/historique/page/commentaires/version.txt b/historique/page/commentaires/version.txt new file mode 100644 index 0000000..d8263ee --- /dev/null +++ b/historique/page/commentaires/version.txt @@ -0,0 +1 @@ +2 \ No newline at end of file diff --git a/site/diff/index.php b/site/diff/index.php new file mode 100644 index 0000000..e69de29 diff --git a/site/editer/index.php b/site/editer/index.php new file mode 100644 index 0000000..6c3a6a9 --- /dev/null +++ b/site/editer/index.php @@ -0,0 +1,9 @@ + \ No newline at end of file diff --git a/site/historique/index.php b/site/historique/index.php new file mode 100644 index 0000000..e69de29 diff --git a/site/image/editer.png b/site/image/editer.png new file mode 100644 index 0000000000000000000000000000000000000000..cea956cb8e6f3578e84850c905de66bc48b598d0 GIT binary patch literal 1169 zcmV;C1aA9@P)Px#V^B;~MQ8v3A{7TdCJi|(AXqyQV>u94J|cEJ5lTfpfk_&9R3egB6?9)hW@1=^ zXBwt$CYf?5f_rV6dQh=>Aaj^Au8JeLg+H~HXq=pk%ceQZs$ZJQSI)MIxxK5;!Be@@ zo6y+E55?eU00001bW%=J06^y0W&i*K&q+i&37@g*2TVu2xbI#A^@5asZwwch379)hPpdYLbYSQdOmdB^ob8|UujeQWJRp>;=!g^L& zIh(Wj3_i`Lb(_l+qzF!`USNilU7|20;eGzl4h?=zUJTilx4l1&o9QcKjUge<5Cdn>ewnyjym*F*L@rX4IAL^`p35k^k#4Q=UzzN zbsZ`M0=#O|Ta+7G8*`mwBD!3*Te?TOd86N7ujiMS^SRHv3@Ctb;&MR)M$E9WH+6{~ z7Cc?n*Y24&3uW_yxL&UZ{)F>;t1!`!6uHDSb|eB=!-~V{GU2ebe3td^&aKx2(dV0w z?5%k5&4Uxh~4(hQPTLSy8WBJg>ppv~&uoQ7Tup8Uf zI6XxF9){6ta9}~c!7sk4XAvI#q8|7Fw*qaiaG6sZy?Yq`K1+M+!gRW9OKU!^;d3vW zEE|P*xvb4Q)|qGE?`_acLGm~BVDj^iBI!_|O#_GROHaEUqX0TPx#V^B;~MQ8v3C>aq$CK6jG2Rbk*Z!!yLITU&}1yM;tTu3s4K@f;T2!Kx`b6-iC zSr=+%VW@95uyGfHes!&oam|r+pPi4(pFrN5bJwqW->Zth$hT8ud!);D|AJhEOJLi83o_inrG#`5! zeBJX_|0)i*-nbAtysuk_;w4ZRiZMzUb`DiO^!*vOo)${F3{L?<2@Y;1b zfF!2^!7y}<)u^ieGm2aENOz?wWzQJ2ZPyk3^o0uH+S*3JMrh-wDd`;~D63Q<2wh3% z-GjEhwhibrh53YG_Mte?oJq*(e}pu&(-0uAQpC{y*&H|1QUo3XG8z>~PE}TDm$nvc zD!*;x{%DRK`21IpfI;BAA?xd^Kg z)MYO!m%{hmqX-$Reg~+f!}ULa^?&>5q;4iT*X@L{cfSOps)B zu5E1T)J&i~81~utWw~Cdkk;M|D?)*ZYPz7%8L*GSl(`FWgBeGyTUwRc-5EKKmjME( z42dC4m&-WGK4GenagmF?zIQUUa&<3r%7?4B@iM{w1ur6i{b@UDPtIn%2E*g7=_8`3 z?45xc$^hWU5yj(Bl*@(?ZXn?_ld=Nxp?))v^Xwx1MTpRKlyw@0VVWq6ql|PP4BX|3 zQ8c{0>=MnxVxLM0?C1xS%y#Bs9FxR&(T;{}fh*p>p9haSg;If9VrSWAipzNPi~>(- z62*u5!ye=)4SC*CM+V8Zqc9M`beWEt6HpZaLdy?>eU`ZxZKlA;;C?CuMZx6&0dV&K z2;P6Zm)!GKBL&7!(~gSHE=-qkBLaZW5C|sUjl@(tN8Le1UKn&eP18o@yTU#^I2bvg z?h4q4#Vtu1ySbZkQ(GlbdlQlm^BJF5uD|L|@bP|~YZMomDAib59yb6df)oCboZwXn zA{X+LeN>!>R6+tr9=C}c0lX)C=0B^b{_}?4BiG__&{3$yywmhivJ5{j1X5t)XN%+P zIe*F^A)GO~Q$z`!dJu?s`+UzyK(I61miqq9PxT0(;9oAT>2yM!^NrRGWy`D(_cj25 z{A&A7PMxtjtIFEPmHWgaf?pBLMxCi_a$%R@KuqGU0Jkibi?7zro4lK&4FxShbHe6L z>)u5WV7}RUJt{hnmAoO9ExD{|;z983!^7;IJ!jjUplpiw03fI4+qIh*?(pzX@gU$# z^YoW}-|O>|d844Y>qlMv{n@3~W!bO~Cmsoud)@!!F^}nB%Zf}C;b9+h_(#u9w-o(A zj~Qn&-r#?HQcP__w@CABK{o&D$t~4Byief#+h<1%N@Oye0@$zdnF7(QXvr1w_HU2P lNdnA0GyjOs55eC${~wd9c;&)8h|B;0002ovPDHLkV1i+`Aua#_ literal 0 HcmV?d00001 diff --git a/site/image/tache.png b/site/image/tache.png new file mode 100644 index 0000000000000000000000000000000000000000..92c5818829f37b5d932e09a25b3f8e7a79c804af GIT binary patch literal 1335 zcmV-71<3k|P)Px#V^B;~MQ8v3B^(wsB^NX+B}g$BR6iwNKpjj;L55HpeONCpaxqe8MrCJTM2bG1 zdQXysJb;FIe3W%zs56G1Wu2mwgT+Fd%`lqHXSKqrxxc@s&9JT2R100001bW%=J06^y0W&i*LbxA})R9M5MSBsXTDi92U;)7(-U<5_v|G)B9 zgPA0AcOGu~BoikmT~<{$4W3RvhKr}S!oCa8h4%o=Fuw1KUN2; zHDz0rzdsLK*lv?PL;>Wjio_yG2)Fe%9qJ|eF-V-EArn_m0Eb*4zUE{ME@C?@%WYk! zppQsM0Az*M-Eg}Bz)$^wUa&yGE2?>R-FXDS=5Jmf>48WF8Z*zcI)lRMmv!t9x1)9d z&@BK!05<6OPXOH+43NLx?9s7c2*CAZ0s$N@Gtt1CWNZ`jLVys<3 z08w~$~bqa?g%JLQC=MSF<@t~#wHHSGCl7! z=%gaMAnG(voT~-p69oKam@N?qv}J2UGEk1EohB;A>GotpE$Hj$8q`FjTHyP%r9{;` zy0GX<6m%N>eWx*!X9G4;J_P=!B5HT&7{)u@%eN>CHqf=ycOmRFb3t z67F^xB}v7}q-u;IuL(&%B@43%K_#qHJ`{)&7xJ-eqRnS7wNOih)X|0s0>}!|eMz{; zeGQ0$slQC0Kh#vAOWh=SS>zxRoMlEumDBk{!E*$S5i#Xcw4rIhQc~iUl|}G|oTrHJp;) zoeDx5%Ey0_k?D-x5#%opRoA|In3~JSG|m{*6_^V@1BCvGpaMWs&=)p|k?J>3h5Ds6 tq{w}%m=NE(_muPL|9$C8<$n9j{vQ|XU&alp@}~d*002ovPDHLkV1gh+TZaGu literal 0 HcmV?d00001 diff --git a/site/image/tuxfamily.png b/site/image/tuxfamily.png new file mode 100644 index 0000000000000000000000000000000000000000..1ce0409db377dadda0007f8638db1e3d58194a41 GIT binary patch literal 1382 zcmV-s1)2JZP)Px#V^B;~MQ8v3AQ~4X978TEI!ZMfJ2PuSIW=HK6$NUDUsqOLScPs~M5(7_s-Lu^1 z^!51itpSYu00001bW%=J06^y0W&i*Lq)9|UR9M5MSB;XhDh#cnC?HA|7ikfE|EK&C z)YiZ4-8)UYJMHeAlar8yc)R_@{Afpi`^x-i?D!qU&1&MoDY#=Y%2YUKp=>M_Z2@) zLFUo88l>n^g8d+X1%ODD%w?Dfrk3Oj#h_>p5~|Mv!o*Z?PR;@z;UxhX1}dTi|C<0n zJVGmj8={tQzuzBIo30G`;8=kY#_LS>a(V!wmCm&?#t&cb!MzD`HPEW6#?k&30s2IO zC4xvek$l78Xi*t|c@&<4Y*yY&^(J5m5U@PoX(+0(xypivxXXl;bWsoE_skS^eBvA(tw+hl%AUI}-T4 zd$5{H#$;KRVRGbzPvxGV&*}sI*(Ea06Bufgp9#`kQ}?2N9<9qH43RjEq~d1+vr*vB z{$~b~Fu)Ik8~B+(Z}HD7>$*Bg*wFrb&B=xU1aNa55W0&etp+s;Mkr5Jnt?&pFbaxt}400biDaI^FD34m*ack?+E zOd@{v@4|3U&>OsBt=+ByJ>06OBg+J3vUMASTjFpA7y+OzmL@n13W(tF6|wl~r68RN z+NBDNzMSntm~G)fQ-?A%vv{xVb`l=0V^BM%oNGR$EBUg0@|FZB|jmJuXl8Q|UAW`~Q>|5Qx_ z&AsA@jEl&|KURQTYnda#HVNR|0)vMBAJTMD5Z6NJ1-?{oO4b~}KeB3108e!zOd_)4 z6MmRq@vl_!IfN6z%^PjUK2wU!1VkRX9}TZazA899HjEHKV@OJl3epwcTT@WRdAe*D z$ARkMX$A%=O-Pau!V$wcU(kfL*1~>T!R`dRyCl`sgUbkyGr%DzFaRirO}~{9-CJw4 zHX1#^{zY+kH_*}RD0Iq(PkBG)g$p8QV07*qoM6N<$g4$q;y8r+H literal 0 HcmV?d00001 diff --git a/site/login/index.php b/site/login/index.php new file mode 100644 index 0000000..e69de29 diff --git a/site/page/Accueil.html b/site/page/Accueil.html new file mode 100644 index 0000000..dbe188f --- /dev/null +++ b/site/page/Accueil.html @@ -0,0 +1,49 @@ + + + + + Accueil + + + + +

    + Gruntnetwork ⁃ + + Accueil ⁃ + Éditer + +

    +
    +
    +

    Gruntnetwork

    +

    +Gruntnetwork est un projet de système d'expoitation, avec les particularités suivantes : +

    +
      +
    • +Il est construit (et programmable) avec un langage de programmation graphique ; +
      • +
    • +L'interface homme-machine orientée document, et non processus, est générée semi-automatiquement ; +
      • +
    • +Son système de fichiers est une base de données, et la gestion des fichiers rend des tâches telles que l'archivage ou la recherche particulièrement faciles ; +
      • +
    • +Sa gestion des ressources matérielles est suffisamment souple pour permettre à des programmes en cours d'exécution d'être sauvegardés dans leur état courant, déplacés sur une autre machine avec des ressources matérielles différentes, … De plus la mise en veille devient triviale à implémenter, et fonctionne à tous les coups. +
      • +
    +

    +Vous pouvez laisser des commentaires si vous en avez. +

    +
    +
    +

    + Hébergé par tuxfamily. + Licence + Màj : Tue, 26 Jan 2010 19:26:21 +0000 + +

    + + diff --git a/site/page/Gestion des ressources.html b/site/page/Gestion des ressources.html new file mode 100644 index 0000000..eadaec1 --- /dev/null +++ b/site/page/Gestion des ressources.html @@ -0,0 +1,49 @@ + + + + + Gestion des ressources + + + + +

    + Gruntnetwork ⁃ + + Accueil ⁃ + Éditer + +

    +
    +
    +

    Gestion des ressources

    +

    +Les programmes fonctionnant sous le système d'exploitation gruntnetwork doivent faire une demmande d'allocation de ressource auprès du système d'exploitation lorsqu'ils ont besoin de mémoire, d'une sortie sonore, d'une portion d'affichage graphique, voire de temps de calcul. +

    +

    +Cette ressource n'est pas allouée définitivement par le système et l'accès à celle-ci peut être révoqué à tout moment. Un signal est alors envoyé à l'application qui peut traiter cette disparition de ressource. +

    +

    +La ressource peut être reprise de plusieurs manières (l'application en est informé) : +

    +
      +
    • +Accès temporairement désactivé, lors de la mise en veille par exemple. La ressource sera ré-allouée au réveil ; +
      • +
    • +Accès révoqué de manière permanente, lors de l'arrêt de la machine, ou lors de la déconnexion d'un périphérique ; +
      • +
    +

    +Cette gestion des ressources permet des choses étonemment pratiques, comme la mise en hibernation d'un processus (accès temporairement désactivé), puis son réveil sur une autre machine (accès restitué, mais avec une ressource légèrement différente). Cela permet de déplacer des processus en cours d'exécution d'une machine à l'autre, ou de les enregistrer en vue de les relancer plus tard, … +

    +
    +
    +

    + Hébergé par tuxfamily. + Licence + Màj : Thu, 10 Dec 2009 17:34:20 +0000 + +

    + + diff --git a/site/page/Interface Homme-2dMachine.html b/site/page/Interface Homme-2dMachine.html new file mode 100644 index 0000000..812d61e --- /dev/null +++ b/site/page/Interface Homme-2dMachine.html @@ -0,0 +1,74 @@ + + + + + Interface Homme-Machine + + + + +

    + Gruntnetwork ⁃ + + Accueil ⁃ + Éditer + +

    +
    +
    +

    Interface Homme-Machine

    +

    Interface orientée document

    +

    +L'Interface Homme-Machine (IHM) de gruntnetwork est orientée document. Cela signifie que l'élément principal présenté à l'utilisateur est le document, autour duquel viennent se greffer des outils. +

    +

    +Dans la plupart des sytèmes actuels, on présente à l'utilisateur la possibilité de lancer divers processus directement (via un menu d'applications), ou bien de lancer ces mêmes processus avec une certaine donnée en entrée (l'ouverture d'un fichier via son icône passe obligatoirement par le démarrage d'un processus, qui décide que faire de ce fichier). Cette approche présente plusieurs défauts : +

    +
      +
    • +Lorsque le processus plante, tous ses documents sont perdus ; +
      • +
    • +Intuitivement, l'utilisateur a l'impression d'avoir ouvert un document, alors qu'en réalité il vient de démarrer une application. L'utilisateur a donc une vision erronnée du système, ce qui est en général mauvais, car moins il comprend le système, moins il est efficace ; +
      • +
    • +Des mécanismes complexes de dialogue entre applications sont nécessaires pour l'édition de documents composite (OLE, Kpart, …) ; +
      • +
    • +Si l'application ne sait pas gérer un certain protocole (http, ouverture de fichiers à l'intérieur de fichiers compressés, …), elle ne pourra pas ouvrir les documents accessibles via ce protocole. L'environnement de bureau KDE apporte une solution en permettant le partage de ces protocoles via les KIOSlaves. +
      • +
    +

    +Une approche orientée document apporte des solutions à ces problèmes : +

    +
      +
    • +Lorsqu'un des outils greffés autour du document plante, il suffit de le redémarrer. Et quand bien même cela serait impossible, ou si c'est le programme chargé de l'affichage du document qui plante, il est toujours possible de proposer à l'utilisateur d'enregistrer son document pour éviter des pertes de données. +
      • +
    • +L'édition de documents composites se fait sans encombre : selon la portion du document considérée, les outils qui viennent se greffer changent. +
      • +
    • +Les outils ne gèrent pas l'ouverture du document, on a des blocs différents pour le chargement en mémoire, le décodage, la visualisation, la modification, l'encodage et l'enregistrement, chacun fonctionnant indépendemment des autres. +
      • +
    +

    Génération semi-automatique

    +

    +L'Interface Homme-Machine (IHM) de gruntnetwork est générée semi-automatiquement à partir d'une spécification déclarative. Cette spécification indique au système quelles sont les informations qui sont les plus importantes (et donc devraient être affichées à l'écran), quelles sont les informations secondaires (accessibles par exemple au travers d'une boîte de dialogue de propriétés), etc. +

    +

    +De même, cette spécification liste les actions qu'il est possible d'effectuer, les plus importantes s'affichant sous forme d'icône par exemple, les autres étant rangées dans des menus ou bien accessibles via des raccourcis clavier. +

    +

    +Plusieurs spécifications peuvent coexister, ce qui permet d'avoir très facilement des interfaces différentes pour les utilisateurs expérimentés et les novices. On peut aussi imaginer une spécification d'interface actualisée dynamiquement en fonction des actions les plus fréquentes de l'utilisateur. +

    +
    +
    +

    + Hébergé par tuxfamily. + Licence + Màj : Thu, 10 Dec 2009 17:33:55 +0000 + +

    + + diff --git a/site/page/Langage.html b/site/page/Langage.html new file mode 100644 index 0000000..d9c699e --- /dev/null +++ b/site/page/Langage.html @@ -0,0 +1,156 @@ + + + + + Langage + + + + +

    + Gruntnetwork ⁃ + + Accueil ⁃ + Éditer + +

    +
    +
    +

    Langage

    +

    +Le langage de programmation de gruntnetwork est un langage graphique, à composants, sans primitives fixées, suivant le paradigme du dataflow, et dont les programmes sont destinés à être prouvés. +

    +

    Graphique

    +

    +«Langage de programmation graphique» signifie que la programmation s'effectue en mannipulant des éléments graphiques et non en tappant du texte ; Ainsi, des langages tels que Visual Basic (r) ne sont pas «graphiques» en ce sens. +

    +

    +La programmation graphique permet d'éviter certains écueils de la programmation textuelle : +

    +
      +
    • +Conflits de nommage, résolus par l'utilisation de références internes au système et d'un moteur de recherche permettant de sélectionner la valeur souhaitée parmis des homonymes, au lieu d'identifiants associés à une valeur par une liaison statique ou dynamique dépendante des identifiants précédemments définis ; +
      • +
    • +Encombrement visuel, lorsque le code important est noyé par des détails syntaxiques, résolu par la possibilité de masquer les opérations inutiles à la compréhension du programme ou bien certains commentaires, en ne les affichant qu'à la demande. Les éditeurs de programmation textuels proposent souvent de masquer une struture de contrôle entière (boucle, fonction, …), ce mécanisme n'est toutefois pas pratique et il ne permet pas de masquer de petits éléments ; +
      • +
    • +La méta-programmation est rendue plus facile par la possibilité de distinguer facilement les niveaux d'abstraction par des couleurs différentes, une imbrication visuelle, ... De plus, on peut représenter les nouvelles syntaxes étendant le langage par des modèles de fonctions dont certains éléments proviennent de l'extérieur, alors que dans les langages textuels l'échappement de telles structures est très ardu. +
      • +
    +

    Composants

    +

    +La programmation par composant est une analogie des circuits electroniques. Les programmes sont construits en connectant entre eux divers coposants, représentant des fonctionnalités déjà présentes, eux-mêmes construits par des connexions entre des composants plus élémentaires. +

    +

    +Les éléments syntaxiques principaux du langage sont : +

    +
      +
    • +Les blocs, qui sont les composants ; +
      • +
    • +Les ports, qui sont les points permettant la connexion d'un bloc aux autres ; +
      • +
    • +Les connexions. +
      • +
    +

    +L'avantage de ces représentations est que les blocs, ports et connexions contiennent beaucoup plus d'informations que ce qui est directement visible : +

    +
      +
    • +Les blocs peuvent sont la structure de base du langage, et peuvent autant représenter un objet ou une structure de donnée statique (dont la représentation en mémoire est peut-être complexe), qu'une fonction ou une macro. Ceci fait de gruntnetwork un langage homoiconique. Cette représentation est extensible, car chaque objet peut décider de sa représentation en tant que bloc, par exemple un document ou une règle (logique ou de filtrage) pourraient fournir un modèle de représentation en tant que bloc. +
      • +
    • +Les ports peuvent contenir les informations de typage, et des contraintes ; +
      • +
    • +Les connexions contiennent les transtypages, et par exemple dans le cas de la connexion d'un flux de type «liste» à un un bloc acceptant des valeurs uniques, la transformation automatique en une appliquation du bloc à chaque élément de la liste est inscrite dans la connexion. +
      • +
    +

    +L'utilisation de blocs pour représenter les fonctions permet aussi une représentation agréable des fonctions récursives : Soit l'appel récursif est représenté par des connexions internes avec bloc identique à celui en cours de définition (le bloc «factorielle» est composé du bloc «multiplication» et du bloc «factorielle» lui-même), dans le cas de récursivité non terminale. Dans le cas de la récursivité terminale, la sortie du bloc est simplement re-connectée à son entrée. +

    +

    Sans primitives fixées

    +

    +Ce langage ne possède pas de primitives (telles que les opérations arithmétiques ou d'entrée-sortie) qui ne seraient pas implémentées avec le langage lui-même. +

    +

    +Afin de fournir des éléments de base pour le langage, la machine destinée à exécuter les programmes sera modélisée sous la forme d'opérations qu'elle est capable de faire et leur impact sur l'état de la machine. En terme de programmation orientée objet, on peut considérer la machine comme un gigantesque objet, dont on ne connaît pas l'implémentation, mais dont on connaît les effets de bord. +

    +

    +Afin d'assurer la portabilité des programmes, différents modules d'abstraction sont définis, chacun étant composé d'un ensemble de fonctions, structures, etc. dont seules les signatures sont définies, mais dont l'implémentation varie selon la machine, etc. +

    +

    +Les avantages de cette architecture par rapport aux classiques primitives fixes et bibliothèques de fonctions sont : +

    +
      +
    • +Des «primitives» définies en termes du langage, donc plus compréhensibles ; +
      • +
    • +La possibilité de programmer pour des machines radicalement différentes de celles pour lesquelles le langage a été conçu, par exemple pour une machine de prototypage rapide (robot construisant un objet par dépôt de couches successives du matériau de base), on définira les primitives comme étant les actions de déplacement du bras ou de dépôt de matérieau, et leurs effets de bord seront des modifications sur l'état du bras articulé (position) ou de l'objet en cours de construction. +
      • +
    +

    Dataflow

    +

    +Le paradigme de programmation dominant du langage est le dataflow. Le dataflow est un paradigme de programmation qui se focalise sur le cheminement des données dans le programme, contrairement à la programmation impérative focalisée sur la suite des actions effectuées, ou à la programmation fonctionnelle pure, axée autour de l'application de fonctions. +

    +

    +Ce paradigme est souvent utilisé par les langages de programmation graphiques car il découle assez simplement de la représentation des programmes (des sortes de filtres transformant l'information reçue et la passant au filtre suivant). +

    +

    Preuves

    +

    +Les blocs seront écrits en vue d'être prouvés, si possible les preuves devraient être rédigées dans le même temps que les blocs, de manière similaire à ce qui se fait dans la méthode B. Plusieurs types de preuves devront être écrites et vérifiées avant exécution : +

    +
      +
    • +Correction, indiquant que le bloc fait bien ce qu'il annonce faire (de manière formelle, dans sa signature) ; +
      • +
    • +Terminaison, si nécessaire ; +
      • +
    • +Absence de fuites mémoires ; +
      • +
    • +Absence d'opérations pour lesquelles le bloc ne dispose pas de privilèges (accès à la mémoire d'autres blocs, altération de données, …); +
      • +
    +

    +Ces preuves permettent au système d'exécuter un bloc sans aucune contrainte (pas de nécessité d'isoler les processus, pas de vérification de droit d'accès), après en avoir vérifié les preuves. Cela permet aussi de prouver des blocs plus gros en se basant sur les preuves des blocs utilisés dans sa construction, et ainsi de s'assurer de l'absence d'erreurs de programmation. +

    +

    Liens Externes

    + +

    À étudier

    + + +
    +
    +

    + Hébergé par tuxfamily. + Licence + Màj : Thu, 10 Dec 2009 17:33:50 +0000 + +

    + + diff --git a/site/page/Licence.html b/site/page/Licence.html new file mode 100644 index 0000000..d1f4e6c --- /dev/null +++ b/site/page/Licence.html @@ -0,0 +1,77 @@ + + + + + Licence + + + + +

    + Gruntnetwork ⁃ + + Accueil ⁃ + Éditer + +

    +
    +
    +

    Licence

    +

    +Ci-dessous, «ce travail» désigne à la fois, sauf mention explicite du contraire : +

    +
      +
    • +le contenu du site web http://gruntnetwork.com/ ; +
      • +
    • +sa mise en page ; +
      • +
    • +sa mise en forme ; +
      • +
    • +le code source du logiciel «fastiki» permettant le fonctionnement de ce site web ; +
      • +
    • +le code source du projet gruntnetwork, ainsi que toutes les données relatives à ce projet (images, polices de caractère, version compilée, …) ; +
      • +
    • +la licence de ce projet elle-même. +
      • +
    +

    Termes de la licence

    +

    +Vous êtes autorisé à redistribuer tout ou partie de ce travail, ainsi que des travaux dérivés ou des versions ayant subi des modifications d'une quelconque importance, sous n'importe quelle licence (y compris le libérer dans le domaine public, lorsque c'est possible), sous n'importe quelle forme, et vous n'êtes pas obligé de mentionner l'auteur original pour le faire. +

    +

    +Lorsque vous apportez des modifications à ce travail, il sera grandement apprécié que toute référence à l'auteur original soit supprimée, ou bien soit accompagnée d'une indication claire et sans équivoque expliquant que d'autres personnes ont apporté des modifications, et que l'auteur original n'est pas responsable de défauts découlant de ces modifications. +

    +

    Absence de garantie

    +

    +Ce travail est mis à disposition du public dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE, ni exprimée, ni sous-entendue, dans les limites imposées par la loi. Entre autres, aucune garantie n'est donnée qualifiant ce travail comme commercialisable, ou comme adapté à un usage en particulier, ou comme compatible avec l'utilisation d'autres travaux. +

    +

    Absence de responsabilité

    +

    +En particulier, l'auteur ne saurait être tenu responsable de tout dommage ou préjudice découlant directement ou indirectement de l'utilisation de ce travail ou des informations qu'il contient, quand bien même il aurait une connaissance préalable du risque, y compris, mais sans se limiter à ces cas particuliers, des dommages financiers ou matériels, la perte ou la modification d'informations, ou la présence d'informations erronnées dans ce travail. +

    +

    +En utilisant ce travail, vous acceptez entièrement de le faire à vos risques et périls. Quand bien même ce travail contiendrait des défauts, vous assumerez vous-même les coûts de réparation du problème. +

    +

    Lorsque ces termes ne sont pas appliquables

    +

    +Si les termes de la licence ou décrivant l'absence de responsabilité ne pouvaient être appliqués conformément aux législations locales, les cours de justice examinant le cas doivent appliquer les lois locales se rapprochant le plus d'une absence totale de droit d'auteur sur le travail, et d'une absence totale de garantie et de responsabilité, quelles qu'elles soient, sur le travail. +

    +

    Intention

    +

    +Ce travail est mis à disposition du public dans l'espoir qu'il sera utile, mais l'auteur ne souhaite pas être importuné par une quelconque responsabilité ou obligation. L'auteur ne souhaite pas particulièrement qu'on lui attribue son travail, et n'a rien contre la ré-utilisation de son travail. +

    +
    +
    +

    + Hébergé par tuxfamily. + Licence + Dernière mise à jour : Sat, 05 Dec 2009 15:34:56 +0000 +

    + + diff --git a/site/page/Système de fichiers.html b/site/page/Système de fichiers.html new file mode 100644 index 0000000..a06995d --- /dev/null +++ b/site/page/Système de fichiers.html @@ -0,0 +1,108 @@ + + + + + Système de fichiers + + + + +

    + Gruntnetwork ⁃ + + Accueil ⁃ + Éditer + +

    +
    +
    +

    Système de fichiers

    +

    +Le système de fichiers de gruntnetwork est une base de données orientée document. +

    +

    Méta-données

    +

    +Lorsqu'un document est stocké, il est analysé pour en retirer un maximum de méta-données, telles que celles contenues dans les balises des fichiers JPEG ou OGG. Dans le cas d'un document textuel, les différents titres et sous-titres, ainsi que la fréquence d'apparition des mots sont récupérés. Expérimentalement, une fouille de texte et une analyse automatique de l'image pourront être effectuées. +

    +

    +L'utilisateur peut lui-même ajouter des méta-données telles que des tags identifiant le sujet du document, des informations en sur-couche sur le document, par exemple : +

    +
      +
    • +noms des personnes présentes dans une photo associés à leur position dans l'image ; +
      • +
    • +Notes de marge dans un texte ; +
      • +
    • +Tâches à effectuer sur certaines parties du document (TODO) ; +
      • +
    • +Commentaires dans programme, explications approfondies dans un texte ; +
      • +
    • +Citations et références hypertextes à d'autres documents (locaux ou non). +
      • +
    +

    +Ces informations sont stockées et indexées dans la base de données pour permettre une recherche rapide selon divers critères. +

    +

    Versions

    +

    +Lorsqu'un document évolue, la base de données peut stocker un historique de ses versions. Ainsi, lorsqu'on édite un document, les différents niveaux d'annulations sont directement gérés par le système de fichiers. +

    +

    +Pour gagner de l'espace disque, ou simplement pour avoir un historique complet, il est possible de stocker un arbre contenant toutes les actions effectuées sur le document (chaque nouvelle branche étant créée lors de l'annulation de sa voisine). +

    +

    +Ceci est facile à mettre en place grâce au côté orientée document du système, qui rend les outils dépendants du document. Dans un modèle orienté processus, il faudrait que chaque programme implémente la possibilité d'enregistrer l'arbre des modifications. Ici, c'est au moment où l'utilisateur indique vouloir effectuer telle ou telle action, que celle-ci est enregistrée dans l'historique, indépendemment de l'exécution de cette action. +

    +

    Structuration et archivage

    +

    +Par défaut, au lieu de structurer l'ensemble des données avec des dossiers, le système propose une structuration en projets (et si nécessaire sous-projets) et bibliothèques. Les bibliothèques contiennent les données qui n'ont pas été créées par l'utilisateur, par exemple sa bibliothèque musicale, un recueil de documentations, etc. Les projets contiennent les documents créés par l'utilisateur, groupés, comme leur nom l'indique, lorsqu'ils font partie du même projet. +

    +

    +L'écran d'accueil liste les projets actifs sur lesquels l'utilisateur est suceptible de vouloir travailler, ainsi que divers points d'accès à ses bibliothèques, et une liste de tâches courantes de maintenance (effectuer des sauvegardes, archiver un projet, ajouter des outils, gérer les utilisateurs du système, …). +

    +

    +Lorsqu'un utilisateur a terminé son activité sur un projet, il peut l'archiver (tous les caches (voir plus bas), sauf les plus suceptibles d'être utilisés sont supprimés, une sauvegarde est automatiquement proposée et le projet n'apparaît plus dans la liste des projets actifs). Après un certain temps d'archivage sans visualisation, tout ou partie du projet peut être compressé, tous les caches effacés et, dans un système à grande échelle, le projet pourraît être déplacé vers une zone de stockage secondaire (sur bande par exemple). +

    +

    Vues et versions parallèles

    +

    +Plusieurs vues d'un document peuvent être stockées dans la base de données, sous l'intitulé d'un seul document, vu de l'extérieur. Par exemple, pour un document textuel, on aura une vue «source», qui sera une représentation what-you-see-is-what-you-mean (ce que vous voyez est ce que vous voulez dire), contennant les réelles informations du document, que l'on peut éditer, et une vue «finale», représentant le document tel qu'il serait imprimé ou vu par un tiers après publication. Cette vue serait le résultat d'une sorte de compilation de la vue source. Il pourrait aussi bien y avoir une vue «PDF», résultat d'une compilation différente. +

    +

    +Ceci est assez souvent mal géré dans les systèmes actuels, l'exemple typique étant un document LaTeX : à sa compilation, plusieurs fichiers sont générés, qui viennent polluer visuellement le dossier contennant. NTFS propose toutefois d'associer plusieurs flux à un nom de fichier, mais quasiment aucune application n'utilise cette fonctionnalité, et le système d'exploitation lui-même ne propose pas d'outil pour manipuler ces flux. +

    +

    +Parfois, il n'y a pas de dépendance directe d'une vue à l'autre, comme dans le cas version source / versions compilées, mais seulement un tronc commun, par exemple lors d'un conflit d'édition lors de la modification simultanée d'un document par deux personnes, ou encore dans le cas d'un «fork» d'un logiciel. Le système pourra alors conserver à jour les parties communes aux différentes versions parallèles du document pour peu que l'utilisateur lui indique quelles parties sont communes et quelles parties subiront les modifications séparément. +

    +

    Caches et données temporaires

    +

    +Lorsqu'un document possède plusieurs vues qui dérivent d'une même source, il n'est pas toujours nécessaire de toutes les conserver - puisqu'elles peuvent être régénérées à la demmande depuis leur source. D'un autre côté il serait idiot de les reconstruire à chaque visualisation alors que la source n'a pas changé. Il en est de même pour des documents situés sur une machine distante : une copie locale est souhaitable pendant un certain temps, mais elle devrait disparaître par la suite. +

    +

    +C'est là qu'intervient le mécanisme de cache du système de fichiers : lorsqu'un document qui peut être facilement re-créé est stocké, il est marqué comme étant un cache, et reçoit comme méta-données sa source et le programme permettant de le régénérer. Une méta-donnée supplémentaire peut être ajoutée : le coût de sa génération. Les caches les moins coûteux et les moins utilisés sont libérés en premier, les plus coûteux et les plus fréquemment utilisés en dernier. +

    +

    +Lorsqu'un programme a besoin de stocker des données temporaires, il demmande au système une ressource de stockage de données temporaires. Selon l'état de la mémoire, cette zone peut être allouée dans la mémoire vive ou sur le disque dur. +

    +

    +L'avantage de marquer explicitement ces zones comme temporaires vient lors du nettoyage : si le programme plante, la zone sera automatiquement libérée (c'est le cas de la mémoire vive allouée dans les systèmes actuels, mais pas des fichiers temporaires). Cela apporte aussi une plus grande sécurité des données à peu de coût : les documents des utilisateurs pourraient être stockés de manière redondante (RAID, …), tandis que les données temporaires ne le seront pas. Lors de la suppression, les documents utilisateur pourraient nécessiter une confirmation explicite, à l'inverse des données temporaires. +

    +

    +De plus, une place privilégiée pourra être allouée, puisqu'on sait que ces données sont vouées à disparaître sous peu : une zone rapide du disque dur (la densité d'informations et donc la vitesse de lecture n'est pas homogène sur un disque dur), une zone proche des données en cours de traitement (pour limiter le déplaçage des têtes de lecture). +

    +

    +La mémoire virtuelle, ou mémoire d'échange (portion du disque dur utilisée comme extension de la mémoire vive) est par exemple déclarée comme zone temporaire, ce qui lui permet d'être située sur un endroit privilégié du disque, et de ne pas occuper de place lorsqu'on ne s'en sert pas, contrairement à la partition «swap» utilisée dans certains systèmes UNIX actuellement. +

    +
    +
    +

    + Hébergé par tuxfamily. + Licence + Màj : Sat, 12 Dec 2009 17:01:42 +0000 + +

    + + diff --git a/site/page/commentaires.html b/site/page/commentaires.html new file mode 100644 index 0000000..3b93b97 --- /dev/null +++ b/site/page/commentaires.html @@ -0,0 +1,32 @@ + + + + + commentaires + + + + +

    + Gruntnetwork ⁃ + + Accueil ⁃ + Éditer + +

    +
    +
    +

    commentaires

    +

    +Insérez vos commentaires ici. Sachez qu'ils seront publiés sous les termes de la licence du site web (cliquez sur le lien en bas de page pour en prendre connaissance). +

    +
    +
    +

    + Hébergé par tuxfamily. + Licence + Màj : Thu, 10 Dec 2009 17:34:25 +0000 + +

    + + diff --git a/site/style/logo.js b/site/style/logo.js new file mode 100644 index 0000000..7b272c1 --- /dev/null +++ b/site/style/logo.js @@ -0,0 +1,34 @@ +/* function statrtOnLoad() { +} */ + +function connect(el, ev, f, capture) { + if (el == document && window.addEventListener) + return window.addEventListener(ev, f, capture || false); + if (el.addEventListener) + return el.addEventListener(ev, f, capture || false); + else if (el.attachEvent) + return el.attachEvent('on' + ev, f); + else + return false; +} + +rolloverOriginalImages = new Array(); + +function rollover(aId, imgId, overHref) { + a = document.getElementById(aId); + img = document.getElementById(imgId); + + connect(a, 'mouseout', function (e) { + img.setAttribute('src', rolloverOriginalImages["" + a + img]); + }); + connect(a, 'mouseover', function (e) { + rolloverOriginalImages["" + a + img] = img.getAttribute('src'); + img.setAttribute('src', overHref); + }); +} + +connect(document, 'load', function (e) { + rollover('lien-accueil', 'logo-grunt', 'http://gruntnetwork.com/site/image/logo.png'); + rollover('lien-editer', 'logo-grunt', 'http://gruntnetwork.com/site/image/editer.png'); + rollover('lien-tuxfamily', 'logo-grunt', 'http://gruntnetwork.com/site/image/tuxfamily.png'); +}); \ No newline at end of file diff --git a/site/style/style.css b/site/style/style.css new file mode 100644 index 0000000..203b763 --- /dev/null +++ b/site/style/style.css @@ -0,0 +1,147 @@ +#entete { + margin: 0; +} + +#liens { + display: block; +} + +#liens, #pied { + background-color: #efd; + border-bottom: thin solid #8a8; +} + +#liens { + height: 1.3em; + padding : 0.3em 0.3em 0.1em; +} + +h1 { + margin-top: 0; +} + +#pied { + margin: 0; + padding: 0.5em; + border-top: thin solid #8a8; +} + +img#logo-grunt { + float:left; + height: 4em; + width: 4em; + + background-color: #efd; + border-right: thin solid #8a8; + border-bottom: thin solid #8a8; + padding: 0 0.4em 0.3em 0.2em; + margin-right: 0.5em; +} + +#liens a, #pied a { + color: #242; +} + +#liens a { + font-size: small; + letter-spacing: 0.2em; + margin: auto 1em; +} + +#liens a:hover, #pied a:hover { + color: #8a4; +} + +#pied { + text-align: center; + font-size: small; +} + +#hebergeur { + display: block; + float: left; +} + +#lien-licence { + display: block; + float: right; +} + +#maj { + display: block; +} + +.barriere-float { + display: block; + clear: both; +} + + + +#contenu { + margin: 0; + padding: 0.3em; +} + +html, body { + padding: 0; + margin: 0; +} + +h1 { + color: #8b4; +} + +h2 { + color: #4a4; +} + +h3 { + color: #484; +} + +h4 { + color: #784; +} + +h5 { + color: #874; +} + +h6 { + color: #854; +} + +hr { + display: none; +} + +a { + color: #975; +} + +a:visited { + color: #543; +} + +a:hover { + color: #c86; +} + + + +dd { + float:left; + margin-left: 1em; +} + +dt { + float: left; + clear: both; + font-weight: bold; +} + +h2#tache-description { + padding-top: 0.3em; + clear:both; +}