Procédons par étape :

1. Formatter vos carte SD en FAT32 (1 seule partition prenant tout l'espace disponible).
2. Télécharger l'image de la dernière Rapbian disponible ici.
3. Identifier sur quel lecture votre carte SD se trouve en utilisant la commande fdisk :

   sudo fdisk -l

   N.B : chez moi il s'agit de /dev/sdb1

4. Aller dans le répertoire où vos avez téléchargé votre Raspbian (à l'heure où j'écris il s'agit de la 2017-09-07) :
5. Saisissez la commande (en remplaçant mes valeurs par les votres, ne soyez pas stupide hein) :

   # Explications :
   # 'dd' permet de faire une copie bit à bite de l'image vers votre carte SD.
   # 'if' signifie "Input File", c'est la source des données à transférer
   # 'of' signifie "Ouput File", c'est la destination des données lors du transfert
   # conf=fsync est une option de contrôle utilisée par 'dd' lors de la copie
   # status=progress permet d'afficher la progression de la copie
   sudo dd bs=4M if=2017-09-07-raspbian-stretch-lite.img of=/dev/sbd status=progress conv=fsync

6. Une fois l'opération terminée, démontez correctement votre clef USB et branchez-là sur votre Raspberry Pi

Remarques :

• Sur certaines cartes SD, l'option bs=4M doit être descendue à bs=1M autrement l'écriture ne se fera pas.
• Sur certaines version de la commande 'dd', l'option status=process soit n'affiche rien, soit empêche l'écriture ; auquel cas il faut la retirer.

Ce qui donne :

sudo dd bs=1M if=2017-09-07-raspbian-stretch-lite.img of=/dev/sbd conv=fsync

Différence entre WebApp & SPA

Pour bien comprendre la différence, analysons le schéma placé en lien.

La partie supérieure montre bien qu'à chaque requête, toute la page est rechargée. C'est-à-dire que le navigateur va télécharger du HTML + du contenu (en supposant qu'il dispose déjà dans son cache de tous les CSS et JS dont il a besoin).

En-dessous se trouve la SPA, celle-ci va télécharger tout le HTML et le JS lors de la première requête uniquement. Ensuite, seule des données sont échangées entre le client et le serveur, généralement au format JSON (je précise minifié, ceci afin d'obtenir les meilleures performances possibles).

Quand utiliser quoi ?

• Lorsque vos utilisateurs surfent très peu sur votre site et qu'ils ont besoin d'accéder à du contenu rapidement, alors la WebApp est la solution à privilégier - le coût de chargement de la page étant réduit à l'ensemble des informations servant l'utilisateur).
• À l'inverse si vos utilisateurs sont connectés pendant dès heures sur votre site et qu'ils passent sans arrêt de page en page, alors la SPA est à privilégier - tout simplement parce que le coût de téléchargement de la première page (qui contient en réalité toutes les pages du site) est alors rentabilisé par le surf de longue durée.

Quelles technos pour des SPA ?

Les plus connues sont rangées par ordre décroissant d'importance sur le marché :

• Angular
• Vue JS
• React JS (+ redux)
• Ember JS
• Aurelia (qui est de loin ma préférée)

Il suffit d'ajouter le paramètre -Dmaven.repo.local à la ligne de commande :

mvn -Dmaven.repo.local=/path/to/repository

Créer une boite modal pour un petit site.

Rendre son site web accessible. Bon article

Introduction

Comme vous le savez sûrement, il existe une légende sur internet congrue à l'arrivée de Maven 3 : il est possible d'écrire des pom en Yaml. Eh bien sachez que la chose n'est en rien une légende.

En effet, les versions Maven 3.x et supérieures recherchent - avant de lire le pom.xml - un fichier spécifique dans ./mvn/extensions.xml. Ce fichier va charger des extensions à Maven lui permettant de faire plus de choses.

L'idée est donc de demander à Maven de charger l'extension polyglot-yaml qui va ajouter à Maven la capacité d'interpréter du Yaml.

Mise en oeuvre

1. À la racine de votre projet créez le répertoire ./mvn/
2. Créez dans ce répertoire le fichier extensions.xml dont le contenu est le suivant :

   <?xml version="1.0" encoding="UTF-8"?>
   <extensions>
   <extension>
       <groupId>io.takari.polyglot</groupId>
       <artifactId>polyglot-yaml</artifactId>
       <version>0.2.1</version>
   </extension>
   </extensions>

3. Créez un fichier pom.yml à la racine de votre projet
4. A titre d'exemple, voici un modèle de pom parent en Yaml :

modelEncoding: 'UTF-8'
modelVersion: '4.0.0'
groupId: 'com.enterprise.fivestars.fs'
artifactId: 'fs-project'
version: '1.0.0-SNAPSHOT'
packaging: 'pom'
name: '. ${project.artifactId} [${project.version}]'

properties:
  ## Project encoding
  project.encoding: 'UTF-8'
  project.build.sourceEncoding: '${project.encoding}'
  project.reporting.outputEncoding: '${project.encoding}'
  ## Maven compiler
  maven.compiler.source: '1.8'
  maven.compiler.target: '${maven.compiler.source}'
  ## Kotlin compiler
  kotlin.compiler.jvmTarget: '${maven.compiler.source}'
  kotlin.source.directory: '${project.basedir}/src/main/kt'
  kotlin.test.directory: '${project.basedir}/src/test/kt'
  kotlin.version: '1.1.51'
  ## Loggers
  logback.version: '1.1.7'
  slf4j.version: '1.7.22'

modules:
  - fs-domain
  - fs-main
  - fs-persistence

dependencyManagement:
  dependencies:
  ## Project dependencies
  - { groupId: '${project.groupId}'       , artifactId: 'fs-project'             , version: '${project.version}'   }
  - { groupId: '${project.groupId}'       , artifactId: 'fs-domain'              , version: '${project.version}'   }
  - { groupId: '${project.groupId}'       , artifactId: 'fs-persistence'         , version: '${project.version}'   }
  ## Database - Driver & embedded DB
  - { groupId: 'com.h2database'           , artifactId: 'h2'                     , version: '1.4.195'              }
  ## Database - Database migration
  - { groupId: 'org.flywaydb'             , artifactId: 'flyway-core'            , version: '4.2.0'                }
  ## Database - Connection Pool
  - { groupId: 'com.zaxxer'               , artifactId: 'HikariCP'               , version: '2.7.2'                }
  ## Database - Persistence framework
  - { groupId: 'org.javalite'             , artifactId: 'activejdbc'             , version: '1.4.13.j7'            }
  ## Dependencies Injection
  - { groupId: 'org.codejargon.feather'   , artifactId: 'feather'                , version: '1.0'                  }
  ## Kotlin - JVM & Collection compliance
  - { groupId: 'org.jetbrains.kotlin'     , artifactId: 'kotlin-stdlib'          , version: '${kotlin.version}'    }
  - { groupId: 'org.jetbrains.kotlin'     , artifactId: 'kotlin-stdlib-jre8'     , version: '${kotlin.version}'    }
  ## Logger - Logging framework facad
  - { groupId: 'org.slf4j'                , artifactId: 'slf4j-api'              , version: '${slf4j.version}'     }
  ## Logger - Logging framework
  - { groupId: 'ch.qos.logback'           , artifactId: 'logback-classic'        , version: '${logback.version}'   }
  ## Testing dependencies
  - { groupId: 'org.assertj'              , artifactId: 'assertj-core'           , version: '3.8.0'                }
  - { groupId: 'org.jetbrains.kotlin'     , artifactId: 'kotlin-test'            , version: '${kotlin.version}'    }
  - { groupId: 'org.junit.platform'       , artifactId: 'junit-platform-runner'  , version: '1.0.1'                }
  - { groupId: 'org.mockito'              , artifactId: 'mockito-core'           , version: '2.12.0'               }

build:
  pluginManagement:
    plugins:
    ## Compiler - Java (Prevent its execution because of Kotlin)
    - artifactId: 'maven-compiler-plugin'
      groupId: 'org.apache.maven.plugins'
      version: '3.6.2'
      configuration:
        compilerArgs: {arg: '-Werror'}
        encoding: '${project.build.sourceEncoding}'
        fork: true
        debug: false
        optimize: true
        showDeprecation: true
        showWarnings: true
        source: '${maven.compiler.source}'
        target: '${maven.compiler.target}'
      executions:
        - goals:
          id: 'default-compile'
          phase: 'none'
        - goals:
          id: 'default-testCompile'
          phase: 'none'
        - goals: ['compile']
          id: 'java-compile'
          phase: 'compile'
        - goals: ['testCompile']
          id: 'java-test-compile'
          phase: 'compile'
    ## Compiler - Kotlin
    - artifactId: 'kotlin-maven-plugin'
      groupId: 'org.jetbrains.kotlin'
      version: '${kotlin.version}'
      configuration:
        nowarn: false
        jvmTarget: '${kotlin.compiler.jvmTarget}'
      executions:
        - goals: ['compile']
          id: 'compile'
          phase: 'compile'
          configuration:
            sourceDirs: [
              '${kotlin.source.directory}'
            ]
        - goals: ['test-compile']
          id: 'test-compile'
          phase: 'test-compile'
          configuration:
            sourceDirs: [
              '${kotlin.test.directory}'
            ]
    ## ActiveJDBC - Enrich entities bytecode
    - artifactId: 'activejdbc-instrumentation'
      groupId: 'org.javalite'
      version: '1.4.13.j7'
      executions:
        - goals: ['instrument']
          id: 'enrich-entities'
          phase: 'process-classes'
    ## Quality - JaCoCo (Code coverage)
    - artifactId: 'jacoco-maven-plugin'
      groupId: 'org.jacoco'
      version: '0.7.9'
      executions:
        - goals:
          id: 'prepare-agent'
          inherited: true
        - goals:
          id: 'report'
          inherited: true
          phase: 'prepare-package'

Et la même chose avec un pom enfant :

modelEncoding: 'UTF-8'
modelVersion: '4.0.0'

parent:
  groupId: 'com.enterprise.fivestars.fs'
  artifactId: 'fs-project'
  version: '1.0.0-SNAPSHOT'
  relativePath: '../pom.yml'

artifactId: 'fs-persistence'
packaging: 'jar'
name: '${project.artifactId}'

dependencies:
## Kotlin - JVM & Collection compliance
- { groupId: 'org.jetbrains.kotlin'  , artifactId: 'kotlin-stdlib'          , scope: 'compile' }
- { groupId: 'org.jetbrains.kotlin'  , artifactId: 'kotlin-stdlib-jre8'     , scope: 'compile' }
## Database - Database migration
- { groupId: 'org.flywaydb'          , artifactId: 'flyway-core'            , scope: 'compile' }
## Database - Driver & embedded DB
- { groupId: 'com.h2database'        , artifactId: 'h2'                     , scope: 'compile' }
## Database - Connection Pool
- { groupId: 'com.zaxxer'            , artifactId: 'HikariCP'               , scope: 'compile' }
## Logger - Logging framework facade
- { groupId: 'org.slf4j'             , artifactId: 'slf4j-api'              , scope: 'compile' }
## Logger - Logging framework
- { groupId: 'ch.qos.logback'        , artifactId: 'logback-classic'        , scope: 'compile' }
## Testing dependencies
- { groupId: 'org.assertj'           , artifactId: 'assertj-core'           , scope: 'test'    }
- { groupId: 'org.jetbrains.kotlin'  , artifactId: 'kotlin-test'            , scope: 'test'    }
- { groupId: 'org.junit.platform'    , artifactId: 'junit-platform-runner'  , scope: 'test'    }
- { groupId: 'org.mockito'           , artifactId: 'mockito-core'           , scope: 'test'    }

build:
  plugins:
  - { groupId: 'org.jetbrains.kotlin'       , artifactId: 'kotlin-maven-plugin'        }
  - { groupId: 'org.apache.maven.plugins'   , artifactId: 'maven-compiler-plugin'      }
  - { groupId: 'org.jacoco'                 , artifactId: 'jacoco-maven-plugin'        }

Et en prime, vous savez à présent compiler du Kotlin avec Maven.

Un super menu en JS. Le second effet et top-moumoutte !

Un tuto en français montrant comment configurer un couche SSL sur nginx.

Dans tous les cas de figures, modifier le fichier /etc/nginx/nginx.conf.

# Cacher la version de nginx dans les pages d'erreur :
# Décommentez cette section
server_tokens off;

Comment ajouter l'autocompletion dans le shell

1) Installer le paquet :

apt-get install bash-completion

2) Ajouter à votre ~/.bashrc :

 if [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
fi

Et voilà !

Quand comprendras-tu ? Plus tu prends, et moins tu possèdes...
Maître Oogway

Tout est dit !

Explication du problème :
La plupart du temps, les VM sont synchronisées avec l'horloge de l'hyperviseur directement et non un serveur de temps. Ce dernier étant lui-même synchronisé avec un serveur NTP (ndr. le serveur de temps).

Le fait est que la synchronisation des threads en Java s'appuie sur des mécanismes de pool de threads et de mise en pause pendant certaines durées ; durées définies par la JVM elle-même et le garbage collector. Or, l'hyperviseur peut - pour des raisons de performances et en cas de partage des ressources physiques entre plusieurs VM - désynchroniser l'horloge des VM avec le "vrai" temps.

Par exemple, il peut y avoir une pause de l'horloge qui dure 40 secondes et l'hyperviseur choisira alors de synchroniser un grand coup les horloges de toutes les VM en cours d'exécution.

Et alors, quel est le problème avec Java ?
Tout simplement qu'à cet instant, tous les threads qui auraient du n'être en pause que quelques millisecondes vont s'activer un grand coup simultanément ce qui va fortement augmenter la charge du CPU et dégrader énormément les performances (puisqu'il n'y a plus partage des ressources via une attribution séquentielle mais concurrence pour accéder à la même ressource : le CPU).

Bref, c'est du caca. En résumé, toujours synchronisez vos VM avec un serveur NTP.

Lenny, nous parlions des FlexBox et des CSS Grid qui les complètent. Voici une page qui résume parfaitement les FlexBox.

Walk off the earth toujours excellent !

Et la reprise de Shake it Of de Taylor Swift ici

Introduction Les métriques sont la partie la plus visible d'une architecture de supervision. Ce sont des données en général facile à récupérer et à stocker. Par conséquent, il arrive souvent qu'on n'investisse pas assez de temps dans la compréhension des données collectées, du pourquoi nous les collectons et ce que …

Un micro server mail !

Analyser les problèmes de votre site web. Pour une fois que Microsoft fait quelque chose d'intelligent (ok j'exagère). Après, je n'ai pas lu leur licence d'utilisation, donc je ne sais pas ce qu'ils font des données glanées.

Un tuto FlexBox / CSS Grid expliquant dans quels cas l'un où l'autre devient intéressant. On y voit clairement la différence entre un positionnement à une dimension (flexbox) et à deux dimensions (grid).

Fabriquer des charts jolis en JS pure sans dépendance et qui tiennent la charge.