Architecture et représentation/structuration des informations
Module GL : pour le logiciel

1. Structures de données
   • Distinction des types de données [data types] suivant leur structure :
     - atomique : entier, charactère, ...
     - composite : chaîne de caractères, collection, objet, e.g., JSON-LD objects.
     
   • Itération/génération/parcours/recherche/sélection & exploitation [Search & Perform]
     d'éléments dans 1/des structure(s)
     • Utilisations :
       - application indépendante de fonctions sur chaque item (copie, modification, ...)
       - aggrégation (somme, concaténation, produit, moyenne, maximum, nombre, ...)
       - transformation globale (tri, ...)
     • Fonctions génériques (buts : modularité, généricité, parallélisme, efficacité, ...) :
       mapReduce [mapReduce], structureMap, select&exploit, ...
   • Exemples à étudier : les objects de Javascript et leurs méthodes,  e.g. :
     - Object (et autres "keyed collections") : keys, observe, create, toString,
           les itérateurs for...in(/for...of) ;   les autres classes d'objets héritent de Object
     - String (+ RegExp) : length,   indexOf/substr/substring/match/search,
                                       +/slice/split, trim/replace/toLowerCase
     - Array (et autres "indexed collections") : length,   indexOf/includes,
           filter/forEach/map/reduce,   concat/slice/pop/push/shift/unshift/splice/sort
           (+ combinaisons,  e.g.,  mapReduce,  select&exploit,  algo. A*,  ...)
   • Distinction suivant l'immuabilité : les structures non éphémères sont
     - réellement immuable [immutable] ou bien
     - persistante (i.e., apparemment immuable et gérée automatiquement par un
       système, e.g., pour la programmation fonctionnelle, la logique monotone ou
       la "gestion des destructions par ajout")
     
   • Distinction suivant le type de stockage :
     - en mémoire : les références sont des pointeurs
     - sur disque, donc dans des fichiers (accès séquentiel/direct, à la fin, ... ;
       base de données ; les références sont des nombres/identifiants).
   TDs+TPs en Javascript avec ce modèle (les exercices à effectuer pour le cours
   suivant sont dans ce fichier ; il est mis à jour le soir après chaque cours) ;
   téléchargez aussi ce fichier dans un même répertoire sur votre machine; étudiez les;
   ne vous inspirez pas d'autres programmes Javascript sur le Web mais utilisez
   Mozilla Developper Network (MDN) ou, pour débuter,  w3schools (tutoriel / reference)  ou
   le tutoriel ici pointé (e.g., "Expressions, Operators") ;
   utilisez un éditeur de texte permettant de manipuler plusieurs vues/buffers,
   e.g., Sublime Text, Notepad++, xemacs (sur Unix), Emacs_for_Mac ou Emacs_Windows ;
   si votre éditeur de texte vous rajoute des tabulations automatiquement,
   changer d'éditeur ou configurez le pour qu'il ne rajoute rien automatiquement ou
   pour que des espaces soient insérés au lieu de tabulations.

2. Paradigmes, bonnes pratiques, principes, patrons logiciels, patrons architecturaux, ...

   • Paradigmes
   • Bonnes pratiques de présentation et, plus généralement, de programmation
     • pour l'indentation, cf. cette page et celle-ci ;
       Utilisez cette checklist !   Règles générales :
       - une sous-partie d'un élément doit être dans son élément parent
         (→ indentation de 2 espaces si retour à la ligne)
       - deux éléments de même niveau d'imbrication doivent débuter sur
         la même ligne/colonne
       - pas de tabulation, une fonction doit pouvoir être lue sur un petit écran de
         79 caractères et sans avoir à changer de fenêtre, utiliser un ascenseur, ...
     • pour savoir quand utiliser ou ne pas utiliser des commentaires pour
       représenter une information, suivez ces règles, au moins pour ce cours
       (si un autre enseignant vous demande — pour son cours — d'utiliser
       des commentaires en plus d'une représentation plus formelle, faites-le
       pour son cours, bien-sûr).
   • Principes
     • Séparation de la présentation et du contenu
     • Utilisation d'objets/entités de première classe
     • Idempotence
   • Critères fonctionnels/structurels de qualité logicielle
   • Patrons logiciels [design patterns in computer science]
     • Itérateurs [iterators]
   • Patrons architecturaux [architectural patterns] et répartition des traitements
     • Approches décentralisées, e.g., grid computing, architecture multi-agents, etc.
     • Approches plus ou moins centralisées
       • Blackboard
       • Pipeline [pipe+filter architecture]
       • Modèle client-serveur [client-server model] (e.g., client/serveur web/e-mail) :
         • Archi/niveaux :  2 (classique),  3 (→ serveur d'appli. [middleware]),
                     N (→ architecture 3-tiers, alias, multitier : couche présentation,
                                                 couche traitement, couche accès aux donnée persistantes)
           E.g.: Node.js
         • Pair à pair [peer-to-peer (P2P)] : chaque client peut aussi être serveur
       • Architecture orientée service [Service-oriented architecture] et protocoles
         de recherche/appel de procédures/services (→ Service Web [Web service]) :
         • RPC (et XML-RPC), CORBA, DCOM, DDS, Java RMI, JBoss Enterprise Middleware,
           SOAP, REST (style d'architecture REST), différences entre ces protocoles
           
         • WSDL (Web Services Description Language),
           UDDI (Universal Description Discovery and Integration)
   • Natural computing,   Green computing (voir aussi mapReduce pour l'écologie)