Editer Vrac du vrac



Pages des trucs qui n'ont pas assez de matière pour avoir leur propre page.

Education



Le modèle transmissif consiste à donner des informations à l'élève, comme s'il était un contenant à remplir. Ca fonctionne chez certains élèves, qui apprennent par coeur des faits et sont capables de les sortir par la suite, mais ce n'est pas très intéressant car l'élève se contente de répéter ce qu'il a appris. Il faut que la communication prof->élève soit parfaite, ce qui semble impossible car la langue est ambigüe. L'élève peut aussi déformer les informations reçues en fonction de ses conceptions préalables du sujet.

Le modèle constructiviste suppose que le savoir doit être reconstruit, reformulé par l'élève pour être assimilé. Popularisé par Jean Piaget qui parlait également de "schèmes" : une action (ou suite d'action) reproductible et combinable avec d'autres schèmes. Ils peuvent évoluer avec le temps. D'après ce que je comprends, ce sont des outils qu'on acquière et qu'on l'on va utiliser par la suite (il peut s'agir d'un réflexe face à une certaine situation, une manière de faire quelque chose...). Il faudra parfois aider les élèves à secouer d'anciens schèmes, c'est à dire, leur faire remettre en question les outils qu'ils utilisent si on les juge mauvais.


Le socioconstructivisme ajoute l'idée de l'importance de l'environnement social : on apprend mieux entouré d'élèves (entraide, émulation...).

L'étayage, c'est l'assistance du formateur permettant à la personne formée d'arriver seule à résoudre un problème qu'elle ne savait pas résoudre au départ. Autrement dit, aider pour que la personne devienne autonome.



Conduite de projet


PMI : Project Management Institute (certifiant les gestionnaires de projets -informatiques et autres).

Il faut se poser la question : pourquoi est-on en train de programmer ? Chaque développeur doit se la poser. Tout d'abord, il faut comprendre ce qu'on a à faire puis mettre en place la méthode (agile ou autre). Tout ce qu'on fait en informatique, c'est pour une raison. On peut conduire une voiture avec un passager qui donne les directions sans savoir où on va, mais on ne sera pas à l'aise. Il faut une vision globale (quelle est la destination...). En tant que développeur on doit faire appel à notre bon sens et se mettre à la place de l'utilisateur au delà du cahier des charges. Il donne la ligne directrice de ce qu'on doit faire. Ne pas oublier que les utilisateurs se considèrent comme des informaticiens et on tendance à empiéter sur notre domaine d'exercice alors qu'ils devraient se limiter à ce qu'ils souhaitent obtenir. Le programmeur doit comprendre l'entreprise avant de programmer.

Système d'information : l'ensemble des composants physiques ou logiques interconnectés afin de produire de l'information pour la prise de décisions. Ceux pour qui on travaille ne pense pas en terme d'affichage, de réseau, de processeur... Matériel+logiciel+données+procédures+acteurs.
Par exemple : le système financier d'une entreprise qui va constituer le compte de charge, de produits.

L'entreprise va ainsi voir si elle a atteint ses objectifs avec des éléments factuels, ce qui va lui permettre de prendre des décisions.

Pour le développeur, il faut être objectif : quels sont les tests unitaire, de non-regression, combien de temps ça a pris pour faire telle ou telle chose... On doit donner des chiffre, pouvoir faire un rapport synthétique.

CASSIOPEE : logiciel développé pour centraliser la gestion de la justice (synchroniser les juridictions), voir le rapport de l'assemblée nationale 3177. Les projets informatiques respectent rarement les délais et aboutissent rarement correctement.

Ce n'est pas un programmeur qui décide où placer les boutons de l'application, ça doit se faire avec l'utilisateur.

Pourquoi on le fait, à qui on s'adresse, quels sont les enjeux.

Pour Cassiopee ils ont utilisé une méthode de gestion de projet en V, sans écouter les clients pendant le développement du projet. La structure était pas suffisamment souple pour prendre en compte les constants changements legislatifs.

Les commerciaux vont travailler contre nous. Il faut mettre les commerciaux devant leurs responsabilités et prévenir quand ils ont vendu des choses impossibles.

Tierce maintenance applicative : des personnes vont maintenir le code.

L'utilisateur est incapable d'écrire un cahier des charges. En général il énonce ce qu'il veut et quelqu'un va rédiger le cahier des charges à sa place (il y a des entreprises spécialisés). Il faut se méfier du cahier des charges, prendre du recul, analyser les interactions possibles, voir au delà. Penser à la documentation et la formation utilisateur.

Voir aussi projet CHORUS (informatique financière). La France est un des rares pays à être géré comme une entreprise, on sait exactement ce qui entre et sort.

Un projet s'intègre dans la stratégie de l'entreprise pour lui permettre d'atteindre ses objectifs. Un projet est limité par rapport à un domaine spécifique qu'il convient d'identifier. Par exemple pour la gestion de la bibliothèque (la ville).

Conférence sympa sur kanban :
https://www.infoq.com/fr/presentations/inversion-controle

UML


Langage de modélisation unifié, proposant de nombreux types de diagrammes couvrant différents aspects du développement logiciel. L'écriture de code n'est qu'une petite partie de la réalisation d'une application, il existe d'autres étapes comme : comprendre le besoin, définir l'architecture de l'application, tester, suivre les besoins, effectuer la maintenance, écrire la documentation d'installation/d'utilisation/pour les développeurs...
Modèle : représentation, à différents niveaux d'abstraction et selon plusieurs vues, de l'information nécessaire à la production et à l'évolution des applications.(UML 2 pour les développeurs) Plusieurs vues pour une même application (vue des utilisateurs, vue technique, vue des données par exemple). L'ensemble doit être cohérent.
Dans l'idéal, le modèle devrait permettre la génération de code, il devra donc être aussi détailé que celui-ci. Mais il contient des informations qui vont au delà du code (cas d'utilisation, déploiment...) donc le modèle devra être davantage détaillé que le code.

Diagramme de classe


Modéliser la structure des différentes classes d'une application orienté objet ainsi que leurs relations.

Classe : définit la structure d'un objet et permet la construction d'instances. Se représente avec le nom de la classe dans un rectangle.

Pour les attributs et les méthodes, la visibilité peut être indiquée :

+ Public - Private # Protected ~ Package

Souligné = statique, italique = abstraite, tout en majuscule=constante (ce sont des conventions UML 1.4, en UML 2.0 c'est laissé libre).

Propriété/attribut : se représente dans le rectangle, sous un trait qui sépare du nom de la classe, de la forme nomAttribut : typeAttribut. S'il s'agit d'un tableau, d'une liste, ou généralement d'un ntre crochets à côté du type (certains le mettent à côté du nom de l'attribut), on peut indiquer le nombre maximal/minimal.

Méthode : se représente dans le rectangle, sous un trait qui sépare des attributs. [visibilité] nomDeLaMethode(parametre) : typeRetourné.

Interface : définit un contrat que doivent respecter les classes. Généralement représneté de la même façon qu'une classe mais avec <> noté au dessus (sinon, elle peut se représenter comme un cercle où est noté le nom de l'interface).

Implémentation d'une interface : un trait pointillé entre la classe et l'interface avec une pointe de flèche blanche touchant l'interface.

Héritage : flèche à la tête blanche, au trait continu, entre la classe qui hérite et la classe mère. La tête de la flèche est collée à la classe mère.

Package : un rectangle avec un onglet en haut à gauche où est indiqué le nom du package.

Importation de package : une flèche en pointillée entre 2 packages, la tête de la flèche n'est pas pleine. La flèche pointe vers ce qui est importé. Si A import B : A -----> B

Note : un rectangle au coin droit corné attaché à un élément par une ligne pointillée, contenant un commentaire sous forme de texte. On peut écrire "<>" sur la ligne.

BOUML


Pour générer un diagramme de classe avec BOUML :
Nouveau projet, utiliser Java, créer package, créer un class view, class diagram, faire ses classes. Créer une deployement view. Double cliquer sur la class view et choisir le deployement view. Clic droit sur une classe, créer un source artefact. Clic droit sur projet, generation setting, onglet directory.
Choisir repertoire de génération. Clic droit sur le package, propriétés, onglet java, y mettre le répertoire de génération sélectionné et le nom du package. Puis tools, generate java.

Tests


http://www.vogella.com/tutorials/JUnit/article.html

-Test unitaire : un morceau de code servant à vérifier le bon fonctionnement d'une partie précise d'un programme et attendant un résultat précis. Exemple pour android : un bouton est pressé, un intent doit être envoyé.
-Test fixture : morceau de code pour fixer les conditions initiales du test (variables pré-remplies par exemple).
-Test coverage : la quantité de lignes de code sur lesquels des tests ont été mis en place.
-Test d'intégration / fonctionnel : vérifie le bon fonctionnement de plusieurs composants ensemble. Ce sont les users stories transformées en tests.
-Test de comportement : vérifie qu'une partie du code est appelé (on ne vérifie pas le résultat).
-Test d'état : on vérifie l'état après un appel de fonction.

TestNG et surtout JUnit sont des frameworks de test java.

Les tests JUnit sont des classes à part, dans src/test/java, notés avec l'annotation @Test. On va utiliser une methode assert, par exemple assertEquals(6, tester.multiply(2, 3), "2 fois 3 doivent faire 6");.

Android


http://www.vogella.com/tutorials/AndroidTesting/article.html#androidtesting

2 types de tests pour les applis Android : ceux qui nécessitent de faire appel à l'OS Android (dans app/src/test/java ) et ceux qui ont juste besoin de la JVM (beaucoup plus rapide, dans app/src/test/java).
Conseil 70% de tests unitaire, 20% fonctionnels et 10% cross fonctionnels (intégration avec d'autres apps).

Google fourni la librairie ATSL (Android Testing Support Library).



Github


Un repository contient en général les fichiers (texte, images, vidéos...) d'un seul projet.
Il peut avoir plusieurs versions qui existent en même temps : la branche master est la branche principale d'un projet. Si on veut faire différents tests sans affecter la branche master, on peut créer une nouvelle branche (par exemple "branche-test").
Une sauvegarde d'un changement de repository s'appelle un "commit" (un "commit message" est un commentaire expliquant le commit).
Lorsqu'on a fait un "commit" sur une branche, on peut demander un "pull request" sur la branche principale, c'est à dire qu'on propose (request) que la personne en charge de la branche principale récupère (pull) nos changements.

Subversion avec Netbeans


Subversion ("SVN") est un gestionnaire de version pour des projets collaboratifs. Le site riouxsvn.com donne 50mo d'espace gratuit et 4 projets par utilisateurs. L'intégration de SVN est bien faite dans Netbeans.
Sur RiouxSVN, vous devrez créer un repository et récupérer son URL.

Pour mettre un projet sur riouxsvn, clic droit, "versioning", "import into subversion directory". Indiquez l'url et vos informations d'authentification.

Pour récupérer un projet de riouxSVN initialisé par quelqu'un d'autre, dans Netbeans Team->Subversion->Checkout.

Après avoir fait des modifs, clic droit "commit" pour envoyer les informations sur riouxsvb. Si un conflit est détecté, un message vous demandant d'updater s'affichera.
Clic droit sur le projet "update" va récupérer les fichiers de riouxsvn et les mettre dans votre projet. Mieux, si un fichier est modifié des 2 côtés, une fusion de fichiers sera effectuée. Si la fusion est impossible, cela sera indiqué dans le fichier :

<h:body> <<<<<<< .mine mamodif ======= modifrecuperee >>>>>>> .r5 <h:link outcome="welcomePrimefaces" value="Primefaces welcome page" />


Un clic droit "resolve conflit" permet de traiter les problèmes.

SVN est beaucoup plus simple à utiliser que GIT.

Symfony


Notes persos basées sur le cours https://openclassrooms.com/courses/developpez-votre-site-web-avec-le-framework-symfony

Installation


php -b dans une invite de commande doit indiquer la version de php.
php peut décompresser des fichiers "phar" (équivalent des jar en java, des bibliothèques/liens vers les bibliothèques).

Pour installer symfony, on récupèrera donc le phar présent sur https://symfony.com/installer puis on le met dans "C:\xampp\htdocs" par exemple puis :
C:\xampp\htdocs>php symfony.phar new Symfony 3.3.2

/app -> config de notre site web
/bin -> executables utilitaires (on peut manipuler depuis l'invite de commande pour effectuer diverses tâches comme génération de code, création d'utilisateurs, vider le cache -à faire avant de publier le site : php bin/console cache:clear --env=prod, etc)
/src -> code source de notre site
/tests -> tests unitaires etc
/var -> repertoire où symfony écrira des fichiers temporaires
/vendor -> bibliothèques externes
/web -> ce qui sera exposé au visiteur. Le controleur point d'entrée est "app.php", il y a également "app_dev.php" qui fait la même chose mais propose en plus des infos de débugs etc.

MVC : Modèle (en gros ce qui concerne la BDD), Vues (mise en forme -les pages html/css), Controleurs (analyse la requête et renvoie une réponse).

Bundle : une brique applicative. On peut imaginer un bundle "blog", "utilisateur", "boutique"... on peut les développer soi-même où en récupérer des déjà faits (http://knpbundles.com/). Les bundles doivent être renseignés dans app/AppKernel.php et le chemin d'accès dans app/config/routing.yml.

/Controller
/DependencyInjection -> informations sur la configuration des dépendances du bundle.
/Entity -> modèles
/Form ->formulaires Contient vos éventuels formulaires
/Resources
-- /config -> config du bundle (routes etc)
-- /public -> css, javascript, images...
-- /views -> vues, templates Twig

Chaque partie du site est un bundle, php bin/console generate:bundle pour lancer l'utilitaire de création de bundle (création des repertoires, templates et ajout dans AppKernel et de la route dans routing.yml.

Pour créer une page, il faut créer sa route. Le kernel envoie le chemin au "routeur" et celui-ci va vérifier si le chemin correspond à une route qu'il a en stock. Si oui, il renvoie des paramètres.
La route se déifnie dans le répertoire du bundle, dans "Resources\config\routing.yml". On aurait pu ajouter la route directement dans app/config/routing.yml mais mieux vaut la mettre dans le bundle, de plus il est déjà configuré pour analyser les routes de notre bundle comme vu plus haut. Par contre on peut ajouter prefix: /chemin_que_je_veux_pour_mon_appli pour préfixer toutes les routes correspondant au bundle.

Exemple de route (il pourrait s'agir d'un fichier routing.yml complet) :

nom_arbitraire_de_ma_route: path: /chemin_dans_barre_d_adresse defaults: { _controller: MonBeauBundle:MonControleur:methodeAExecuter}



Dans "path", on peut également indiquer une variable, exemple : path: /consulterPost/{id}, la variable sera envoyée à la méthode "consulterPostAction". On peut séparer plusieurs variables avec des points ou de slashs (pour simuler des sous répertoires). On peut aussi forcer le format des variables avec le mot clef "requirements:". Il existe des variables systèmes (par exemple {_format} va changer le header renvoyé lors du rendu de la page pour y mettre le format spécifié).

Autre exemple de route, ci dessous on attends un numéro (entre 1 et 4 chiffres comme indiqué par \d{1,4}) de page (monsite.com/3). Sans ce numéro la page par défaut sera la 1 :

nom_arbitraire_de_ma_route: path: /{page} defaults: _controller: MonBeauBundle:MonControleur:methodeAExecuter page: 1 requirements: page: \d{1,4}



Ensuite, il faut créer le controleur dans le dossier "Controller", ici il devra s'appeler "MonControleurController" et contenir une méthode "methodeAExecuterAction". Voici ce que devrait maintenant afficher l'adresse http://localhost/Symfony/web/app_dev.php/chemin_dans_barre_d_adresse (notez que la réponse est renvoyée brut, l'objet réponse permet de renvoyer une vraie réponse http, on pourrait aussi renvoyer une vrai réponse d'erreur 404 en faisant $response->setStatusCode(Response::HTTP_NOT_FOUND); si on voulait):

<?php namespace Mon\BeauBundle\Controller; use Symfony\Component\HttpFoundation\Response; class MonControleurController { public function methodeAExecuterAction() { return new Response("Bleuh :-p"); } }


On peut aussi renvoyer une page html. Symfony 2 et 3 utilisent le système de template Twig. Il faut tout d'abord écrire une page twig dans Resources/views/(adresse que l'on veut, MonControleur pour rester cohérent)/index.html.twig :

{# src/Mon\BeauBundle/Resources/views/MonControleur/index.html.twig #} <!DOCTYPE html> <html> <head> <title>Ma page twig</title> </head> <body> <h1>Hello {{ nom }} !</h1> <p> <h1>BLEUH !</H1> </p> </body> </html>


Ci-dessous, une page twig avec des arguments (ici, le nom) :

namespace Mon\BeauBundle\Controller; use Symfony\Bundle\FrameworkBundle\Controller\Controller; use Symfony\Component\HttpFoundation\Response; class MonControleurController extends Controller { public function methodeAExecuterAction() { $content = $this->get('templating')->render('OCPlatformBundle:MonControleur:index.html.twig', array('nom' <big>&rArr;</big> 'lolou')); return new Response($content); } }


Autre façon de faire avec this->render() qui est une façon de raccourcir get('templating etc: :

namespace Mon\BeauBundle\Controller; use Symfony\Bundle\FrameworkBundle\Controller\Controller; use Symfony\Component\HttpFoundation\Response; class MonControleurController extends Controller { public function methodeAExecuterAction() { return $this->render('OCPlatformBundle:MonControleur:index.html.twig', array('nom' <big>&rArr;</big> $monparam)); } }




Ci-dessous, pour la route path: /chemin_dans_barre_d_adresse/{monparam}, on affiche le paramètre :

public function methodeAExecuterAction($monparam) { $content = $this->get('templating')->render('OCPlatformBundle:MonControleur:index.html.twig', array('nom' <big>&rArr;</big> $monparam)); return new Response($content); }


Il est également possible de récupérer les variables de l'URL passées en paramètre en GET (post/5?monparamalancienne=mavaleur), elles se retrouveront dans un objet de type "Request" envoyé en paramètre à la fonction dans le controleur. L'url est http://localhost/Symfony/web/app_dev.php/platform/chemin_dans_barre_d_adresse/param?monparam=mavaleur, l'exemple suivant affichera "mavaleur" sur la page :

use Symfony\Bundle\FrameworkBundle\Controller\Controller; use Symfony\Component\HttpFoundation\Response; use Symfony\Component\HttpFoundation\Request; class MonControleurController extends Controller { public function methodeAExecuterAction($monparam, Request $request) { $tag = $request->query->get('monparam'); $content = $this->get('templating')->render('OCPlatformBundle:MonControleur:index.html.twig', array('nom' <big>&rArr;</big> $tag)); return new Response($content); } }


Un objet de type Request permet de récupérer les paramètres GET mais aussi POST ($request->request->get('tag')), les cookies ($request->cookies->get('tag')), les variables de serveur ($request->server->get('REQUEST_URI')), les variables d'entête ($request->headers->get('USER_AGENT')), les paramètres de route ($request->attributes->get('id')) et beaucoup d'autres choses.
On peut aussi utiliser cet objet pour manipuler les sessions (et les voir en cliquant sur la barre d'outil en bas en mode dev) :

$session = $request->getSession(); // Récupération de la session $userId = $session->get('user_id'); // On récupère le contenu de la variable user_id $session->set('user_id', 12); // On définit une nouvelle valeur pour cette variable user_id



Pour générer des url dans le contrôleur, par exemple un lien vers la page "contact", on lui indique le nom de la route et il génère l'url à partir du fichier de routing (ce qui permet de ne pas les écrire en dur et devoir modifier 2000 url) : $this->get('router')->generate('oc_platform_home') ou $url = $this->generateUrl('oc_platform_home');. Pour URL absolue, ajouter l'argument UrlGeneratorInterface::ABSOLUTE_URL.

Pour le faire depuis Twig : {{ path('oc_platform_view', { 'id': advert_id }) }}

Redirection (pour que les directions soient pluis détaillées en mode dev passer intercept_redirects à true dans app/config/config_dev.yml) :

return $this->redirectToRoute('nom_de_la_route_vers_laquelle_rediriger');


Il est possible de mémoriser une variable qui sera utilisée en cas de redirection. On appelle ça des "messages flash" :

$session = $request->getSession(); $session->getFlashBag()->add('info', 'Ce message sera affiché une fois arrivé sur la page vers laquelle vous êtes redirigé. Il disparaitra si vous faites F5 ou bien y arrivez directement, sans passer par cette redirection.'); return $this->redirectToRoute('nom_de_la_route_vers_laquelle_rediriger');


Pour afficher tous les messages flash dans Twig :

<div> {# On affiche tous les messages flash dont le nom est « info » #} {% for message in app.session.flashbag.get('info') %} <p>Message flash : {{ message }}</p> {% endfor %} </div>




Retourner du JSON :

use Symfony\Component\HttpFoundation\JsonResponse; // ... public function viewAction($id) { return new JsonResponse(array('id' <big>&rArr;</big> $id)); }


Les messages d'erreur dans Symfony sont dans \vendor\symfony\symfony\src\Symfony\Bundle\TwigBundle\Resources\views\Exception. En cas d'erreur html une page html est affichée (error.html.twig), en cas d'erreur json un json vide est renvoyé, en cas d'erreur css un css vide est renvoyé etc...
En mettant un fichier error.html.twig dans \app\Resources\TwigBundle\views\Exception, celui-ci aura priorité sur celui de Symfony (on pourrait aussi modifier directement les messages d'erreur mais en cas de mise à jour le dossier vendor/symfony est susceptible d'être écrasé), penser à vider le cache de prod.

Twig


Moteur de template utilisé par Symfony. Entre "" pour afficher quelque chose, "{%" et "%}" pour exécuter une commande, "{#" et "#}" pour les commentaires. Pour concaténer : {{ nom ~ " " ~ prenom }}. On peut aussi mettre en majuscule, mettre la première lettre en amjuscule, etc. Avant d'afficher une valeur, twig converti en entités html.
Voir la doc de twig pour les boucles, les if else, les tableaux...

Pour récupérer le contenu d'un template en texte :

$contenu = $this->renderView('MonBeauBundle:Advert:email.txt.twig', array( 'var1' <big>&rArr;</big> $var1, 'var2' <big>&rArr;</big> $var2 )); mail('adressemail@quienvoyer.com', 'Voici la page html envoyée comme mail', $contenu);


On peut évidemment utiliser des layouts (avec le mot clef "block" qui indique où vont se placer les éléments). Il est conseillé de les faire sur 3 niveaux : layout général du site (à mettre dans app/Resources/views/layout.html.twig), layout de la section (dans src/nomdubundle/resources/views/), layout de la page (dans src/nomdubundle/resources/views/nomdelasection).

Exemple de bloc formant le layout général d'un site :

<!DOCTYPE html> <html> <head> {% block head %} <link rel="stylesheet" href="style.css" /> <title>{% block title %}{% endblock %} - My Webpage</title> {% endblock %} </head> <body> <div id="content">{% block content %}{% endblock %}</div> <div id="footer"> {% block footer %} © Copyright 2011 by <a href="http://domain.invalid/">you</a>. {% endblock %} </div> </body> </html>


Et une page qui utiliserait le layout "base.html" ci-dessus, notez qu'il hérite (extends) de base.html :

{% extends "base.html" %} {% block title %}Index{% endblock %} {% block head %} {{ parent() }} <style type="text/css"> .important { color: #336699; } </style> {% endblock %} {% block content %} <h1>Index</h1> <p class="important"> Welcome on my awesome homepage. </p> {% endblock %}


On peut aussi inclure une page sans qu'elle n'hérite d'une autre : {{ include("MonbeauBundle:monSousD:maPageAInclure.html.twig") }}

Exemple qui récupère le contenu d'un tableau et l'affiche :

{% for article in monTableauDarticles %} <a href="{{ path('chemin_de_mon_lien', {'id': article.id}) }}"> {{ article.titre }} </a> {% else %} Aucun article dans ce tableau ! {% endfor %}


On peut également appeler une méthode d'un controleur avec render() :

<div id="menu"> {{ render(controller("MonBeauBundle:MonSousDosser:maMethode")) }} //dans la méthode on trouvera un "return $this->render(..." </div>



Pour que l'exemple ci-dessus fonctionne, il faudra alimenter la page twig avec le controleur :

$monTableauDarticles = array( array('id' <big>&rArr;</big> 2, 'titre' <big>&rArr;</big> 'Titre de mon article numero deux'), array('id' <big>&rArr;</big> 5, 'titre' <big>&rArr;</big> 'Titre de mon article numero cinq'), array('id' <big>&rArr;</big> 9, 'titre' <big>&rArr;</big> 'Le 9e article') ); //on utilise la page twig return $this->render('OCPlatformBundle:Advert:menu.html.twig', array( // on y passe la tableau d'article 'monTableauDarticles' <big>&rArr;</big> $monTableauDarticles ));


Services Symfony


doc
Des objets php accessibles depuis n'importe où (pour envoyer un mail par exemple) : il suffit de créer la classe et de l'enregistrer dans le conteneur de service (le fichier var/cache/dev/appDevDebugProjectContainer.php, qui va s'occuper d'instancier les services -une seule fois, en instanciant éventuellement d'autres services nécessaires, càd service A avant service B qui le nécessite). Pour enregistrer un service, ça se passe dans src/Mon/BeauBundle/Ressources/config/services.yml qui sera chargé par OCPlatformExtension dans le dossier DependencyInjection du bundle.

Ci-dessous un service renseigné dans services.yml, avec des arguments (un autre service, un paramètre de l'appli, un nombre) qui seront récupérés dans la méthode de construction de la classe public function __construct(\Swift_Mailer $mailer, $locale, $minLength):

services: mon_beau.nomarbitraireduservice: class: Le\Namespace\De\Mon\Service arguments: - "@mailer" - %locale% - 12


On peut aussi stocker des variables dans le fichier services.yml ($container->getParameter('nomParametre'); pour y accéder ou bien %mon_parametre% pour y faire référence dans une autre section de services.yml):

parameters: mon_parametre: ma_valeur


php bin/console debug:container pour lister les services. Depuis un contrôleur, pour appeler un service mailer par exemple : $this->container->get('mailer');.

Doctrine


Un ORM php qui fait le lien entre nos classes modèles avec notre base de donnée grâce à des annotations (entre /** et */, exemple :

/** * @ORM\Column(name="id", type="integer") * @ORM\Id * @ORM\GeneratedValue(strategy="AUTO") */


Comme en Java, ces annotations peuvent être générées automatiquement.
Il peut être intéressant d'installer le package doctrinebundle.

L'accès à la BDD se configure dans "app\config\parameters.yml", puis, on lance la création de la base avec php bin/console doctrine:database:create.
Les entités se créent avec un configurateur qui va poser quelques questions. Il se lance avec php bin/console doctrine:generate:entity puis les questions suivantes seront posées :
Entity shortcut name nom de la classe/(de la table généralement) : MonBundle:MaClasse
Configuration format façon dont sont mappés les attributs de la classe avec les colonnes : annotation
New field name (press to stop adding fields) nom de l'attribut (la colonne): date
Field type [string]: datetime
Is nullable [false]:
Unique [false]:

Le champ "id" est créé automatiquement. Bien sûr vous pouvez modifier le code source php entité (dans src/votre/bundle/Entity) pour y mettre un constructeur par exemple ou modifier le mapping (voir la doc de doctrine) puis php bin/console doctrine:generate:entities MonBeauBundle:MonEntite pour générer les getters et les setters.

Une fois les classes php générées, on se base sur elles pour créer nos tables dans notre base :
php bin/console doctrine:schema:update --dump-sql pour voir le SQL qui sera exécuté.

php bin/console doctrine:schema:update --force pour créer concrètement nos tables en base.

On peut également faire l'inverse : créer ses tables puis les importer dans doctrine.

Php



Création de tableau avec la fonction array :$noms = array ('Bob', 'Bill', 'Joe');.
Directement : $noms[0] = 'Bob';
Tableau associatif (par exemple, les variables superglobales $_GET ou $_POST sont des tableaux associatifs) avec la fonction array : $coordonnees = array ('nom' <big>&rArr;</big> 'Bob','ville' <big>&rArr;</big> 'Paris');
Tableau associatif directement : $coordonnees['prenom'] = 'bob';

Pour parcourir avec foreach : foreach($noms as $element)
Avec les clefs : foreach($coordonnees as $cle <big>&rArr;</big> $element)
Boucle for : for ($i=0; $i<10; $i++) {}

empty($var) returne true si var est nul, false, à 0, contient "", "0", un tableau vide.
isset return true si la variable contient quelque chose (si on lui a assigné null, elle ne contient rien).
tableau comparatif

Les variables peuvent changer de type selon ce qu'on met dedans, mais on peut forcer un type avec "settype" ou en faisant un cast, comme en java : $_GET['nbr'] = (int) $_GET['nbr'];

htmlspecialchars ou strip_tags pour éviter l'injection de code html dans les formulaires.

Pour démarrer une session session_start() au tout début de chaque page php où on veut utiliser les infos stockés en session (ou bien session.auto_start dans php.ini pour ne pas avoir à le préciser à chaque page). Une fois la session démarrée, il est possible de stocker des variables dans le tableau associatif superglobal $SESSION: $_SESSION['nom'] = 'Bob';. Le visiteur est identifié par une chaine de caractère (ex : 7bbba5d25cdfde422d7ac4be71ae7f91) stockée soit dans un cookie soit dans l'url (?PHPSESSID=...) ce qui est appelé "trans_id". On peut forcer à l'utiliser ou non de la façon suivante : ini_set("session.use_trans_sid",false); Attention, si on stocke l'identifiant de session dans l'url, il est facile de la voler (en recopiant l'url, en écoutant le réseau et récupérant les requêtes...).

Pour mettre un cookie en place, tout en haut de la page setcookie('nom', 'Bob', time() + 365*24*3600, null, null, false, true);, puis $_COOKIE['Bob'] pour l'afficher.

Pour exécuter une requète,il vaut mieux utiliser des requêtes préparées qui permettent d'éviter l'injection decode:

$req = $bdd->prepare('SELECT * FROM table_employes WHERE nom = ?'); $req->execute(array($nomRecherche));


Balises echo courtes


Activé par défaut depuis PHP 5.4, on peut faire un <?= $maVariable ?> qui sera équivalent à <?php echo $maVariable; ?>.

Dans les vues, on pourra donc faire des choses du genre :

<span id="msgBienvenueHeader">Bienvenue <?= $membre->getPrenom();?></span> <span id="msgInfoHeader">Il te reste <?= $abonnement->getNbrCoursRestant();?> cours sur ta carte.</span>


Eviter d'utiliser la balise d'ouverture <?, car elle est également utilisée en xml.
Attention aussi à ne pas faire des choses du type <?= include "mon_fichier.php" ?>, car sinon un 1 viendra se rajouter derrière le contenu de la page que vous voulez inclure.

Les namespaces permettent d'avoir des classes ou des fonctions du même nom : il suffit d'écrire namespace monnamespace; tout en haut du fichier et les fonctions qui seront crées ici seront propres à ce namespace (on peut aussi utiliser des accolades, namespace A{...}). Ils fonctionnent comme des dossier : mon\beau\namespace Pour appeler une fonction du namespace global, la faire précéder de \, ça fonctionne avec tous les namespace pas seulement celui racine. Il y a également le même genre de notion chemin relatif et absolu lorsqu'on veut appeler une fonction d'un autre namespace. La constante NAMESPACE permet d'afficher le namespace en cours. On peut donner des alias : use mon\beau\namespace as mbn;. On peut mettre plusieurs "use" dans un même fichier pour importer des classes (pas des fonctions, uniquement des classes) d'autres namespaces.
Généralement on sépare les fichiers php dans des dossiers et on donne comme namespace le chemin relatif des fichiers.

Tableau associatif


Pour déclarer :
$monTableauAssociatif = array("maClef1"<big>&rArr;</big>"maValeur1", "maClef2"<big>&rArr;</big>"maValeur2", "maClef3"<big>&rArr;</big>"maValeur3");

Pour ajouter :
$monTableauAssociatif += array($maNouvelleClef <big>&rArr;</big> $maNouvelleValeur);

XDebug


Permet de mettre des points d'arrêt etc.

Copier coller la vue html sur https://xdebug.org/wizard.php pour obtenir les instructions d'installation.

Composer


Gestion de dépendance en php, les paquets sont sur //packagist.org/.
Il a besoin d'un fichier json, exemple :

{ "require": { "monolog/monolog": "1.0.*" } }


...puis, dans la console, on va taper composer update pour qu'il télécharge les librairies demandées.
Un fichier autoload.php va faire charger automatiquement ces librairies à php mais attention, il est écrasé par composer à chaque demande d'upate.

On peut ajouter sa propre librairie à l'autoload de la façon suivante :
"autoload": {

"psr-4": {

"": "src/",

"VotreNamespace": "chemin/vers/la/bibliotheque"

},

"files": [ "app/AppKernel.php" ]

},

==== Modélisation mathématique des langues naturelles ==== D'après la conférence de [[http://www.canal-u.tv/producteurs/universite_de_tous_les_savoirs/dossier_programmes/les_conferences_de_l_annee_2002/les_interfaces/la_modelisation_mathematique_des_langues_naturelles|KAHANE Sylvain]]. Une formule peut donner les relations entre les différents éléments de sens : "Félix veut parler à Zoé." Félix définit comme a ; Zoé comme b; Premier prédicat "vouloir", qui prend deux argument (Vouloir 1)QUI ? et 2)QUOI ?) :\\ Vouloir(a,e -e comme "évènement"). Deuxième prédicat "parler" avec trois arguments :\\ Parler(e,a,b) //pourquoi remettre e et a ici ?// La formule complête est : Deux évènements, e1 et e2. Vouloir(e1,a,e2) et parler(e2,a,b). //pas compris// Quand on formalise une phrase, on isole différents éléments de sens, on exprime leur relation et le sens de certains éléments. On a pas décrit tous les mots dans cette phrase. Exemple avec l'adjectif sec, beaucoup de sens différents (pas mouillé, maigre, froid). Comment comprendre ça de façon abstraite ? Il existe l'approche du dictionnaire de synonyme Sabine Ploux and Bernard Victorri. Cette approche, c'est de voir que les mots qui représentent un même sens de "sec", parmis ses 56 synonymes, sont synonymes entre eux. sec=aride=décharné=maigre. Autre exemple : autoritaire=brusque=cassant=sec=tranchant. Ils appellent ces groupements de mots des cliques. Il y en a 75 pour le mot sec. Grâce à ça, on va essayer de représenter le sens global du mot sec. On va construire un espace à 56 dimensions (pour chaque synonyme) dans lequel on va placer les cliques. Pas d'explication mathématique sur comment ça se passe... Il nous montre ce que ça donne, il a mis au milieu le sens pas mouillé, il y a dans un coin le sens psychologique insensible, autre coin squelettique décharné, dans un autre coin les sens temporels court, bref. Ensuite, tentative de retrouver le sens de sec lorsqu'il est donné avec un nom. Pour cela, on utilise un corpus de texte. On cherche dans tous ces textes avec quels mots le mot "foin" est associé et à quelle clique ça correspond. Par exemple, foin séché, foin mouillé, foin desseché etc. Ca correspond à la clique d'un certain sens. On aura pas de foin squelettique, ni de foin rapide. On sait donc que lorsque foin est associé avec sec il a le sens de "pas mouillé". Si on fait la même opération avec "homme", on a deux sens, décharné et sens psycho. Note perso : Je comprends pas pourquoi il a besoin de représentation à 56 dimensions, ça me semble assez simple. on doit pouvoir programmer facilement un détecteur de sens d'adjectif selon le mot avec lequel il est associé. Il faut d'une part déterminer les cliques, puis les associer avec une définition du dico (via mots clefs dans ces cliques). Puis : Si dans un corpus (ou sur google tant qu'à faire) le mot clef est souvent associé à tel groupe d'adjectif, alors, sa définition la plus vraissemblable est trouvée dans le dictionnaire d'après les adjectifs en question. Pourquoi 56 dimensions ? Ceci dit, l'approche du dico des synonymes est très intelligente. Je suis étonné qu'on trouve pas encore d'application. ==== Chatterbot apprenant ==== Apprend des mots liés à des stimulis. Exemples de stimulis : quelqu'un arrive, quelqu'un part, quelqu'un reste au délà d'une certaine limite, il est midi, le bot a faim, le bot a soif, on vient de dire un mot précis au bot, on tire la tronche, on va faire une action. Chaque fois que le bot a faim, on demande "tu as faim ? tu as envie de manger ? C'est l'heure de manger ? il a faim le petit ?" exactement comme quand une mère parle à son bébé. Le bot doit associer les mots qui reviennent souvent "faim" et "manger" à la sensation de faim, puis les réutiliser par la suite. Il doit également pouvoir (mais peut être est-ce inutile dans un premier temps ?). Il est fort simple de programmer une longue liste de stimuli, mais pour que ça soit de la vraie auto apprentissage, les stimulis doivent être détectés par le bot. Quelle est la définition la plus simple d'un stimuli ? Un changement d'un état. Le simple fait que le temps passe est un stimuli. Avoir faim au delà d'un certain point est un stimuli. Le robot doit donc être capable d'associer un changement d'état à un mot, puis réutiliser ce mot lorsque le changement d'état survient. Ce serait déjà une étape importante, bien que très peu spectaculaire. "Bot : Faim. -NON. J'ai faim. -J'ai faim." <big>&rArr;</big>on donne à manger. "User : J'ai faim." <big>&rArr;</big>Il faudrait que le bot nous donne à manger ? L'étape suivant serait de ne pas connaitre uniquement les mots, mais les stimulus suivant un stimulus, en distinguant les acteurs... ==== Lojban ==== Grammaire : http://jerome.desquilbet.org/pages/85/#2_1 Utilise l'alphabet latin sauf les lettres "h" "w" et "q". Il existe une lettre en plus : "'", qui se prononce comme ahead. Elle sert à séparer clairement deux voyelles. La ponctuation se prononce, il y a juste "," (indique exception d'une syllabe) et "." (pause). Le "e" se prononce "é", le "y" se prononce "e", le c se prononce "sh", le g est toujours dur (ga, gu, go), le x se prononce du fond de la gorge, comme la jota espagnole. Les mots prennent un certains nombre d'arguments (sumti), comme pour une fonction dans un programme. Par exemple avec klama (venir/aller) en a 5 : x1 va à la destination x2 depuis x3 par la route x4 en utilisant x5. Pour omettre un argument on utilise zo'e ("qui n'est pas important"). Il y a des petits mots à utiliser pour modifier l'ordre des arguments de klama pour éviter d'utiliser 4 zo'e par exemple. On peut laisser tomber les derniers arguments. ==== Anglais ==== Principalement tiré du programme [[http://www.canal-u.tv/producteurs/les_amphis_de_france_5/dossier_programmes/anglais/news_busters_le_j_t_en_v_o/lotto|News Buster sur Canal U]]. Les nombres 13 à 19 sont accentués sur la dernière syllabe (thir**teen**), les dizaines sont accentuées sur la première (**thir**ty). Syndicate : Groupe de personne. Un syndicat = “trade union”. ten millions-plus jackpot : Le plus signifie ici "plus de dix millions", pas "10 millions plus un jackpot". “The 3 types of terror: The Gross-out: the sight of a severed head tumbling down a flight of stairs, it's when the lights go out and something green and slimy splatters against your arm. The Horror: the unnatural, spiders the size of bears, the dead waking up and walking around, it's when the lights go out and something with claws grabs you by the arm. And the last and worse one: Terror, when you come home and notice everything you own had been taken away and replaced by an exact substitute. It's when the lights go out and you feel something behind you, you hear it, you feel its breath against your ear, but when you turn around, there's nothing there...”