Définition du problème

Dans un jeux de société, nous avons 3 paquets de cartes (un bleu, un jaune et un rouge). Lorsque un joueurs tombe sur une certaine case du jeux (imaginez un monopoly) il doit recevoir une carte parmi les trois paquets. Cependant nous souhaitons qu’il pioche sa carte d’un des trois paquets selon des probabilités:

• 10% de chances de recevoir une carte venant du paquet bleu
• 25% de chances de recevoir une carte venant du paquet jaune
• 65% de chances de recevoir une carte venant du paquet rouge

Pour savoir dans quel paquet le joueur devra piocher, nous devons insérer une part de hasard: imaginons donc que nous avons un dès a 100 faces. Nous établissons a l’avance ces plages de nombres afin de savoir dans quel paquet piocher quand nous aurons lancé le dé:

• de 1 à 10: paquet bleu
• de 11 à 35: paquet jaune
• de 36 à 100: paquet rouge

Le défis va être d’écrire un algorithme capable de simuler ce jet de dés permettant le choix du paquet de carte.

Visualiser nos chiffres

Pour mieux visualiser ces plages de nombres, imaginez une règle de 100 graduations:

• Les 10 premières graduations, de 1 à 10, représentes les 10%.
• Les 25 prochaines graduations, de 11 à 35, représentes les 25%
• Les 65 prochaines graduations, de 36 à 100, représentes les 65%

En fonction du nombre donné par le dé a 100 faces et selon la graduation, nous savons quel paquet de carte choisir tout en restant fidèle aux probabilités de 10, 25 et 65%. Nous allons désormais représenter ces plages de nombres comme ceci:

10%   |   25%   |   65%

[1 → 10] [11 → 35] [36 → 100]

Le modèle logique

Nous allons maintenant essayer de trouver un modèle logique la dedans. Un modèle qui, quelque soit le nombre de paquets de cartes et quelque soit les probabilités que nous avons, puisse toujours s’appliquer. Dans un soucis de lecture nous allons appeler les 10% « A« , les 25% « B » et les 65% « C« . On constate en premier lieux ce modèle:

[1 → 10] [10+1 → 10+25] [10+25+1 → 10+25+65]

[1 → A] [A+1 → A+B] [A+B+1 → A+B+C]

Si nous rajoutions des paquets de cartes et modifions les probabilités, ce modèle fonctionnerais toujours. Vous pouvez essayez chez vous, succès garantis.

Le modèle logique: 2ème étape

Nous allons maintenant vouloir appliquer ce modèle à un algorithme informatique. Pour pouvoir le traiter de manière informatique il faut aller un peu plus loin: Nous devons trouver le modèle logique de chaque plage de nombre ([ ]) car notre algorithme devra répéter ce modèle pour chaque paquets de cartes (pourcentages). Car en effet un algorithme est une suite d’instructions qui ne dévira pas de ce pour quoi elle a été programmé. On doit donc trouver un modèle logique, c’est a dire comment trouver les nombres a l’intérieur d’une plage de nombres ([ ]), qui fonctionne a tout les coups.

Voici le modèle logique que nous cherchons:

[ Probabilités précédentes + 1 → Probabilités précédentes+Probabilité en cours ]

Pour mieux comprendre, rien de vaut une mise en pratique! Nous avons trois paquets de cartes: nous allons donc effectuer le « calcul » trois fois. La première fois pour la première plage de dates correspondant aux 10% ([1 → 10] [11 → 35] [36 → 100])

• Modèle: [ Prob. préc. + 1 → Prob. préc. + Prob. en cours ]
• Probabilités en cours: 10
• Probabilités précédentes: 0
• [0+1 → 0+10] [ ] [ ]
• soit [1 → 10] [ ] [ ]

La deuxième fois pour la deuxième plage de dates correspondant aux 25% ([1 → 10] [11 → 35] [36 → 100])

• Modèle: [ Prob. préc. + 1 → Prob. préc. + Prob. en cours ]
• Probabilités en cours: 25
• Probabilités précédentes: 10
• [ ] [10+1 → 10+25] [ ]
• soit [ ] [11 → 35] [ ]

La troisième fois pour la troisième plage de dates correspondant aux 65% ([1 → 10] [11 → 35] [36 → 100])

• Modèle: [ Prob. préc. + 1 → Prob. préc. + Prob. en cours ]
• Probabilités en cours: 65
• Probabilités précédentes: 10 + 25
• [ ] [ ] [10+25+1 → 10+25+65]
• soit [ ] [ ] [36 → 100]

Et voilà, nous constatons avec cette mise en pratique que le modèle logique fonctionne. Vous pouvez vérifier chez vous en ajoutant des paquets de cartes et probabilités si vous voulez.

L’algorithme de génération des plages de nombres

Tout ceci nous permet maintenant d’écrire notre premier algorithme ! Il s’agit ici de transformer le modèle logique vu précédemment en un algorithme « textuel », c’est à dire lisible par n’importe qui et respectant le modèle d’un programme informatique: Sa lecture se fait de gauche à droite et de haut en bas: comme pour la lecture !

"probabilités" contient 10%, 25% et 65%
"somme_probabilités_précédentes" vaut 0
"plages_de_nombres" est vide
pour chaque "probabilité_en_cours" dans les "probabilités":
  ajouter la plage ["somme_probabilités_précédentes"+1 → "somme_probabilités_précédentes"+"probabilité_en_cours"] aux "plages_de_nombres"
  "somme_probabilités_précédentes" vaut maintenant "somme_probabilités_précédentes" + "probabilité_en_cours"

Comprenez que pour les lignes avec un alinéa (dans le « pour ») il est effectué le processus autant de fois qu’il y a de probabilités (10%, 25%, 65%) de la même façon que nous l’avons mis en pratique dans la section « Le modèle logique: 2ème étape ». Voici la décomposition du code pour mieux comprendre ce qu’il se passe: Lors de la première passe:

pour chaque "probabilité_en_cours" dans les "probabilités":
  #note: Premier coup c'est la probabilité de 10%
  #note: et somme_probabilités_précédentes vaut 0
  ajouter la plage [0+1 → 0+10] aux "plages_de_nombres"
  "somme_probabilités_précédentes" vaut maintenant 0 + 10

Deuxième passe:

pour chaque "probabilité_en_cours" dans les "probabilités":
  #note: Deuxième coup c'est la probabilité de 25%
  #note: et somme_probabilités_précédentes vaut actuellement 10
  ajouter la plage [10+1 → 10+25] aux "plages_de_nombres"
  "somme_probabilités_précédentes" vaut maintenant 10 + 25

Troisième et dernière passe:

pour chaque "probabilité_en_cours" dans les "probabilités":
  #note: Troisième coup c'est la probabilité de 65%
  #note: et somme_probabilités_précédentes vaut actuellement 35
  ajouter la plage [35+1 → 35+65] aux "plages_de_nombres"
  "somme_probabilités_précédentes" vaut maintenant 35 + 65

Après avoir effectué les 3 passes nous avons bien nos plages de nombres:

[ 0 +1 → 0 + 10 ] [ 10 + 1 → 10 + 25 ] [ 35 + 1 → 35 + 65 ]

soit [1 → 10] [11 → 35] [36 → 100]

Code python

Nous pouvons maintenant rédiger notre premier script, c’est a dire notre premier « logiciel ». Nous allons rédiger ce code en python: C’est un langage de programmation propre et facilement lisible, donc bien adapté a ce petit cours. L’algorithme « textuel » vu précédemment devient:

probabilites = [10, 25, 65]
somme_probabilites_precedentes = 0
plages_de_nombres = []
for probabilite_en_cours in probabilites:
  plages_de_nombres.append([somme_probabilites_precedentes+1, somme_probabilites_precedentes+probabilite_en_cours]) 
  somme_probabilites_precedentes = somme_probabilites_precedentes + probabilite_en_cours

Et voilà! Ce code peut être compris par un ordinateur comprenant le langage python: pour une démonstration cliquez ici. Lorsque l’algorithme arrive a sa fin « plages_de_nombres » contient bien nos plages de nombres!

[ [1, 10], [11, 35], [36, 100] ]

Code python: simuler l’ensemble

Il nous faut maintenant ajouter du code pour simuler le jet du dés et le choix du paquet de carte dans lequel le joueur devra piocher. Cette ligne permet d’obtenir un nombre au hasard entre 1 et 100:

jet = random.randint(1, 100)

Pour savoir a quel paquet de carte correspond le jet de dés, nous allons, pour chaque plages de dates, voir si le nombre obtenu au dés s’y trouve. Si il s’y trouve, c’est le paquet de cartes, correspondant a cette plage de dates qui sera notre résultat. Commençons avec l’algorithme « textuel » (rappelons nous que « plages_de_nombres » contient « [[1,10] [11,35] [36,100]] »):

pour chaque plage_de_nombre dans les plages_de_nombres:
  Si le jet est supérieur ou égal au premier nombre de cette plage_de_nombres 
  ET si le jet est inférieur ou égal aux deuxième nombre de cette plage_de_nombres:
    c'est cette plage_de_nombre a laquelle correspond le jet

Illustrons cet algorithme « textuel » dans un cas pratique comme nous l’avons déjà fait la fois précédente. Imaginons que notre jet de dés à fait 49. Nous faisons trois fois ce qui est écrit dans le « pour » (puisque nous avons 3 « plages_de_nombres »):

pour chaque plage_de_nombre dans les plages_de_nombres:
  #note: Premier coup c'est la plage [1, 10]
  Si 49 est supérieur ou égal à 1 
  ET si 49 est inférieur ou égal à 10:
    c'est cette plage_de_nombre a laquelle correspond 49

Les conditions de la phrase « Si » ne sont pas remplis, on passe à la suivante:

pour chaque plage_de_nombre dans les plages_de_nombres:
  #note: Deuxième coup c'est la plage [11, 35]
  Si 49 est supérieur ou égal à 11 
  ET si 49 est inférieur ou égal à 35:
    c'est cette plage_de_nombre a laquelle correspond 49

Les conditions de la phrase « Si » ne sont toujours pas remplis, on passe à la suivante:

pour chaque plage_de_nombre dans les plages_de_nombres:
  #note: Troisème coup c'est la plage [36, 100]
  Si 49 est supérieur ou égal à 36 
  ET si 49 est inférieur ou égal à 100:
    c'est cette plage_de_nombre a laquelle correspond 49

A la troisième passe les conditions du « Si » sont remplis, c’est donc bien la plage de nombres du paquet de cartes rouges qui correspond à 49 ! Le code adapté au langage python est le suivant :

jet = random.randint(1, 100)
plage_de_nombre_correspondant = None
for plage_de_nombre in plages_de_nombres:
  if jet >= plage_de_nombre[0] and jet <= plage_de_nombre[1]:
    plage_de_nombre_correspondant = plage_de_nombre

Une fois les deux portions de code associés, cela nous donne:

import random

probabilites = [10, 25, 65]
somme_probabilites_precedentes = 0
plages_de_nombres = []
for probabilite_en_cours in probabilites:
  plages_de_nombres.append([somme_probabilites_precedentes+1, somme_probabilites_precedentes+probabilite_en_cours]) 
  somme_probabilites_precedentes = somme_probabilites_precedentes + probabilite_en_cours

jet = random.randint(1, 100)
plage_de_nombre_correspondant = None
for plage_de_nombre in plages_de_nombres:
  if jet >= plage_de_nombre[0] and jet <= plage_de_nombre[1]:
    plage_de_nombre_correspondant = plage_de_nombre

Ne prêtez pas attention la ligne « import random », elle est juste nécessaire pour pouvoir utiliser random.randint. A la fin de l’exécution de ces lignes « plage_de_nombre_correspondant » contiendra la page de nombre correspondant au jet du dé. Pour voir le code s’exécuter, cliquez ici.

Code python final

Pour que le logiciel est un intérêt supplémentaire, nous devrions l’améliorer de sorte à ce que nous puissions rapidement et facilement lancer la procédure à plusieurs reprises. Comme ceci ne concerne plus de l’initiation a l’algorithmie mais plutôt de la simple programmation logicielle je ne m’attarderais pas sur comment à été construit le code suivant. Cependant il intéressera les plus curieux

import random

def generer_les_plages_de_nombres(probabilites):
  somme_probabilites_precedentes = 0
  plages_de_nombres = []
  for probabilite_en_cours in probabilites:
    plages_de_nombres.append([somme_probabilites_precedentes+1, somme_probabilites_precedentes+probabilite_en_cours]) 
    somme_probabilites_precedentes = somme_probabilites_precedentes + probabilite_en_cours
  return plages_de_nombres

def trouver_plage_de_nombres_correspondantte_au_jet(jet, plages_de_nombres):
  plage_de_nombre_correspondant = None
  for plage_de_nombre in plages_de_nombres:
    if jet >= plage_de_nombre[0] and jet <= plage_de_nombre[1]:
      return plage_de_nombre

def trouver_cle(plage_de_nombres_trouve, plages_de_nombres):
  if plage_de_nombres_trouve in plages_de_nombres:
    return plages_de_nombres.index(plage_de_nombres_trouve)

def lancer_simulation(probabilites, paquets_de_cartes):
  jet = random.randint(1, 100)
  plages_de_nombres = generer_les_plages_de_nombres(probabilites)
  plage_de_nombre_correspondant_au_jet = trouver_plage_de_nombres_correspondantte_au_jet(jet, plages_de_nombres)
  cle = trouver_cle(plage_de_nombre_correspondant_au_jet, plages_de_nombres)
  print "pour le jet "+str(jet)+" c'est dans le paquet "+paquets_de_cartes[cle]+" que le joueur doit piocher"

paquets_de_cartes = ['Bleu', 'Jaune', 'Rouge']
probabilites = [10, 25, 65]
lancer_simulation(probabilites, paquets_de_cartes)

Pour une démonstration, cliquez ici.

Conclusion

La programmation logicielle consiste a cela: Répondre a un problème et synthétiser sa solution en adaptant de contextes réels des modèles logiques de manière a ce qu’ils soient compréhensible par une machine. Vos ordinateurs, les appareils électroniques et même des système uniquement mécaniques (voir par exemple le métier à tisser Jacquard) sont constitués de quelques ou de millions voir milliards de morceaux de logiques comme celui que nous venons de voir. Complexe, mais pas sorcier !

Avec les nouvelles technologies lié a la génétique ont comprend de mieux en mieux évolution de l’espèce humaine. Les récent progrès nous permettent surtout de pouvoir constater scientifiquement les évolutions des derniers millénaires (exemple avec les Sherpas qui ont évolué pour supporter le manque d’oxygène).

Jusqu’à ce jour on a pas constaté d’évolution autrement du qu’a la sélection naturelle. C’est a dire que l’évolution serait uniquement du aux variations génétiques aléatoire des organismes qui se retrouve plus souvent dans les sujet arrivant le mieux jusqu’à la procréation.

On peut sérieusement se poser cette question a propos de l’évolution de l’espèce humaine: Jusqu’au 20ème siècle, la sélection naturelle était bien présente: Grande vague de maladie, beaucoup de mortalité infantile etc. Pour exemple, en Angleterre a l’époque de la naissance de Darwin un enfant sur deux arrivait jusqu’à l’age de 21 ans. De nos jours (toujours en Angleterre comme référence), 99% atteigne ces 21 ans. On peux donc supposer que plus nous repousseront la mort des humains après l’age de procréer plus la sélection naturelle et donc l’évolution va diminuer.

Cependant deux choses vienne contrer cette conclusion: Premièrement tout le monde ne fait pas forcément des enfants, il y a une sélection naturelle du aux comportements sociaux. Cependant cet argument n’est rien face a la simple logique qui veut que tôt ou tard notre espèce devra subir de nouvelles épidémies (d’autant que tous les continents sont désormais reliés par des transports très rapides et que les virus ne se gênes pas pour surfer sur la vague des pratiques industrielle de l’élevage pour muter). Épidémies qui relanceront drastiquement la sélection naturelle.

Dernier point du reportage et non du moindre: L’eugénisme. Nous somme déjà capable à ce jours d’observer le code génétique des embryons et donc de connaître certaines caractéristique a l’avance: sexe, prédisposition a des maladies, couleur de cheveux etc… On peux donc et cela ce fait déjà aux États-Unis choisir parmi les embryons. Il est donc probable que dans le futur nous soyons de plus en plus capable de pouvoir sélectionner selon un grand nombres de critères les progénitures qui naîtrons. Ce qui ferait de notre espèce la seule ayant un contrôle sur son avenir génétique, contrairement aux autres devant subir les lois de la sélection naturelle.

Pour conclure, un petit rappel: ~99,5% des espèces ont déjà disparu de la terre, ne vous faites pas d’inquiétude la dessus nous disparaîtrons nous aussi tôt ou tard.

Je vous conseil de regarder ce documentaire très bien réalisé et certainement mieux que mon petit résumé !

Lire le tutoriel

/usr/local/nagios/var/rw# ls -l
total 0
prw-rw---- 1 nagios nagios 0 11 sept. 14:32 nagios.cmd

On constate que le fichier ne peut être manipulé que pas l’utilisateur nagios. Or lorsque l’on utilise l’interface web, c’est l’utilisateur www-data qui est utilisé. Il faut donc mettre a jours les droits sur le fichier. Le problème c’est que ce fichier est recréé a chaque démarrage de nagios. On modifie donc le fichier /etc/init.d/nagios de façon a changer les droits sur le fichier lors de sa création:

[...]

case "$1" in

        start)
                echo -n "Starting nagios:"
                $NagiosBin -v $NagiosCfgFile > /dev/null 2>&1;
                if [ $? -eq 0 ]; then
                        su - $NagiosUser -c "touch $NagiosVarDir/nagios.log $NagiosRetentionFile"
                        rm -f $NagiosCommandFile
                        touch $NagiosRunFile
                        chown $NagiosUser:$NagiosGroup $NagiosRunFile
                        $NagiosBin -d $NagiosCfgFile
                        if [ -d $NagiosLockDir ]; then touch $NagiosLockDir/$NagiosLockFile; fi

                        # added by bux
                        chmod 770 $NagiosCommandFile
                        chown nagios:www-data $NagiosCommandFile
                        # end added by bux

                        echo " done."
                        exit 0
                else
                        echo "CONFIG ERROR!  Start aborted.  Check your Nagios configuration."
                        exit 1
                fi
                ;;


[...]

Et voilà !

Ceci dit, en avançant dans mes flux je constate ce qui se passe très souvent (mais dont on ne peut pas toujours se rendre compte): Une information biaisé et relativement transformé au fur et a mesure de sa propagation. D’après les lectures qui suivent l’information viendrais d’un email privée (qui ne le fut d’ailleurs plus) a propos d’un changement dans le modèle de développement de Thunderbird par Mozilla a propos de l’arrêt du développement de nouvelles fonctionnalités au sein du logiciel et non d’un arrêt total. Un article officiel confirmera d’ailleurs tout cela en expliquant que le logiciel est suffisamment fournis en fonctionnalités et qu’ils préfèrent se focaliser sur la sécurité et la stabilité. Ce qui après tout n’est pas idiot puisque la fonction première d’un client de messagerie est de lire et envoyer ses mails.

Donc encore une fois il ne faut jamais s’arrêter a la première information qui nous tombe sous le nez (pourtant on le fait tous de temps en temps hein) car autant sur internet, dans nos discussions, dans les journaux, a la télé (et oui, la télé aussi héhé) c’est le même principe: on vous relais souvent de l’information sans vous servir avec le travail de recherche et d’enquête qu’il, si il y a surtout, eu lieu. Mais vous ne saurez pas non plus si une information semblant plus sure n’est pas issue d’un travail trop subjectif, ou carrément dans un but de vous convaincre sans tout fois être réellement honnête. En somme nous ne pouvons être sur de rien, tant nous somme limité  par nos moyens de compréhension, d’accès aux informations et j’en passe (d’ailleurs qui est réellement sur de ses propres points de vues). Bon, après m’être autant emporté sur le sujet avec Thunderbird comme excuse n’oubliez pas le sujet principal de cet article: la fiabilité d’une information viens de plusieurs critères dont il vaut mieux s’assurer avant de la considérer comme un fait.

D’ailleurs vous ne devriez pas trop faire confiance a ce que je vous raconte et vous faire votre propre point de vue ^^

Info qui peut toujours servir !

En voici un petite sélection rapide parmi celles que j’ai visionné récemment:

• Drew Curtis: Comment j’ai battu un chasseur de brevets
• Frans de Waal : Le comportement moral des animaux
• Frank Warren : Un demi-million de secrets
• Donald Sadoway : le chaînon manquant de l’énergie renouvelable

Vous pouvez retrouver les conférences traduites en français à cette adresse.

Il est très pratique d’isoler ses tests du reste de l’application. Il est donc nécessaire de faire en sorte que la base de donnée utilisé lors des tests soit indépendante de la base utilisé lors du développement.  Cela évite de fausser ses tests si des données ont été modifier pendant le développement ainsi que d’utiliser une base fidèle aux fixtures entre chaque tests.

Cet article est issue de la combinaison des deux articles suivants:

• http://haulynjason.net/weblog/2012/01/fully-isolated-tests-in-symfony2/
• http://alexandre-salome.fr/blog/Symfony2-Isolation-Of-Tests

Dans mon cas, l’article de haulynjason.net seul ne me permettait pas d’exécuter mes tests fonctionnels sur la même base que les tests unitaires. J’ai du utiliser l’astuce de l’article d’alexamdre-salome.fr.

Premièrement nous configurons de quoi éxécuter les tests dans une base sqlite, de façon a ce qu’elle soit isolé de la base de développement.

config_test.yml:

Nous créons la classe ModelTestCase a partir de laquelle seront étendus nos classes de tests (git):

A partir d’ici vos classes de tests unitaires étendus de cette classes utiliserons la base sqlite pour exécuter ses tests. Passons maintenant aux tests fonctionnels: définissons le paramètre test.client.class afin d’écrire notre propre classe Client:

config.yml:

Nous écrivons la classe WebTestCase a partir de laquelle nous étendrons nos classe de test fonctionnels:

Et voilà, nos tests fonctionnels seront étendu de WebTestCase, nos tests unitaires seront eux étendus de ModelTestCase et ils seront totalement isolé de la base de dév puisque ils travailleront avec une base indépendante. Les performances de vos tests seront affectés puisque avec cette méthode chaque test (fichier, pas fonction) effectue une rechargement de la base.