Cet article est destiné à un public JavaScript avertit.
J'y explique comment créer depuis un seul repository, des packages indépendants avec leur propres traductions, style, js, tests et rendus isolés.
Le process est valable pour n'importe quelle techno.

Si vous êtes un développeur web "2.0" alors vous connaissez forcément npm, cet outil pratique qui permet de "tirer" puis d'utiliser des dépendances.

A la base npm est un outil dédié à NodeJS (et donc au back) mais avec les nouveaux outils front, de plus en plus complet et complexe, npm devient indispensable pour assister nos "build" front.

Dans cette marrée de différentes technos (Vue, React, Angular pour ne citer qu'eux) un problème reste présent:

• comment puis-je faire des modules que je pourrais réutiliser sur tous mes projets sans tenir compte de la "stack" du projet final

Et plus ça va, plus on a des modules et plus on fait du "copié-collé" d'un projet à l'autre. Pas top question maintenance.

Donc on se dit qu'on va faire un repos qui contiendra tout ça (pas bête), on va peut-être faire un submodule au lieu d'une npm (car on veut que ça reste privé), mais la procédure npm n'est pas si complexe.

Puis le temps passe, on a des composants de toutes sortes, des petits, des complets, des métiers, des techniques et la taille de notre build dépasse allègrement le méga-octet (je suis sympa, en vrai si vous faites de l'es6 côté front et que vous utilisez babel et React, votre build fait très vite 1Mo sans même avoir codé quoi que ce soit !).

Dans notre super salade nous allons mettre les ingrédients suivants: Lerna, Rollup, Yarn (et npm sisi), Babel, Storybook, du CSS via PostCSS et CSSNext et du code React (car c'est ce que j'utilise, mais le principe fonctionnera avec n'importe quelle techno).

Petit tour de table

• Lerna: pour faire simple c'est un outil qui permet de lancer des commandes en parallèle dans plusieurs sous-dossier, l'outil indispensable pour gérer une bibliothèque de composants indépendants
• Rollup: concurrent de Webpack plus simple et plus orienté dépendences
• Yarn: concurrent de npm, on va s'en servir pour initialiser et utiliser le "workspace", les commandes npm fonctionneront toujours, mais derrière cela appelera yarn
• Babel: transpilateur ES6+ vers ES5 (en français ça donne, faire que du code JS de dernière génération s'exécute correctement sur tous les navigateurs)
• Storybook: un outil qui permet d'instancier des composants d'UI dans un environnement vierge (un peu comme des calques photoshop)
• React (y'a besoin de le présenter ?)
• i18next est un framework d'internationalisation, on l'utilisera dans les derniers chapitres de l'article "aller plus loin" afin d'intégrer des json à notre fichier
• PostCSS / CSS Next, une variante de SASS/LESS en gros :) que l'on utilisera aussi à la fin, histoire de mettre en place du style indépendant dans nos composants.

Je vais faire au plus simple au début, notre "composant" démo ne sera pas extra-ordinaire en termes de fonctionnalités, mais ça fonctionnera et vous permettra de comprendre l'environnement. Si vous n'avez jamais fait de React, pas de soucis. Suivez l'article et une fois que vous aurez compris comment ça fonctionne, il devrait vous être aisé de migrer vers votre stack favorite.

Initialisation du projet

Positionnez-vous dans le dossier où vous voulez créer votre projet lerna.

Installez lerna en global via npm: npm i -g lerna
Ensuite, initialisez un repo multi-packages "lerna": npx lerna init

À partir de là vous devriez voir un dossier "packages" vide, un fichier package.json et un fichier lerna.json.

Votre package.json ne devrait contenir que "lerna" comme devDependencies, on va donc ajouter toute la clique correspondant a notre stack:

  "devDependencies": {
    "babel-cli": "^6.26",
    "babel-core": "^6.26",
    "babel-preset-env": "^1.7.0",
    "babel-preset-react": "latest",
    "babel-preset-stage-0": "latest",
    "lerna": "^3.4.0",
    "prop-types": "latest",
    "react": "latest",
    "rollup": "^0.63.5",
    "rollup-plugin-auto-external": "^2.0.0",
    "rollup-plugin-babel": "^3",
    "rollup-plugin-commonjs": "^9.1.8",
    "rollup-plugin-node-resolve": "^3.4.0"
  }

Babel et ses presets pour la transpilation ES6+ vers ES5, react et rollup avec ses plugins nécessaires pour matcher le reste de notre stack.

Là on a le minimum requis.

Maintenant, on descend dans packages/ et on va créer notre premier package "alpha".
cd packages/ && mkdir alpha && cd $_

Il faut maintenant créer un fichier package.json et y mettre le contenu suivant:

{
  "name": "my-demo-package-alpha",
  "version": "0.0.0",
  "description": "Alpha is the first",
  "author": "Someone who was here before you",
  "license": "MIT",
  "repository": "",
  "main": "dist/index.js",
  "module": "dist/index.es.js",
  "scripts": {
    "build": "rollup -c",
    "prepare": "yarn run build"
  },
  "dependencies": {
    "react": "*",
    "prop-types": "*"
  },
  "files": [
    "dist"
  ]
}

Ajoutez aussi le fichier qui permettra de lancer la build, le fichier rollup.config.js avec le contenu suivant:

import resolve from 'rollup-plugin-node-resolve';
import babel from 'rollup-plugin-babel';
import commonjs from 'rollup-plugin-commonjs';
import autoExternal from 'rollup-plugin-auto-external';

import pkg from './package.json';

export default {
  input: 'src/index.js',
  output: [
    {
      file: pkg.main,
      format: 'cjs'
    },
    {
      file: pkg.module,
      format: 'es'
    }
  ],
  external: [
  ],
  plugins: [
    // say to rollup how to resolve node dependencies
    resolve(),
    // allow to include all kind of amd package in an ES6 way
    commonjs({
      include: 'node_modules/**',
      namedExports: {
        'node_modules/react/index.js': ['Component', 'PureComponent', 'Fragment', 'Children', 'createElement', 'cloneElement']
      }
    }),
    // babel
    babel({exclude: "node_modules/**"}),
    // automatically detect what should be excluded from the build
    autoExternal()
  ]
}

Enfin, ajoutez un dossier "src" et mettez ceci dedans un fichier index.js:

/**
 * @class AlphaComponent
 */

import React, { Component } from 'react';
import PropTypes from 'prop-types';

export default class AlphaComponent extends Component {
  static propTypes = {
    text: PropTypes.string
  }

  constructor(props) {
    super(props);

    this.myRef = React.createRef();
  }

  render() {
    const {
      text
    } = this.props;

    return (
      <div ref="test">
        Alpha Component: {text}
      </div>
    )
  }
}

Remontez au dossier racine du projet et ajoutez un fichier .babelrc pour les options babel (on pourrait mettre ce fichier dans chacun des packages, mais c'est plus simple d'avoir le même pour tous les packages):

{
  "presets": [
    ["env", {
      "modules": false
    }],
    "react",
    "stage-0"
  ],
  "plugins": []
}

Attention, Storybook utilisera aussi ce babelrc, donc si vous deviez ajouter des plugins ou autre et que le storybook (ou les tests) ne fonctionne plus, le mieux sera d'injecter un babelrc dans la config rollup au vol (voir les derniers chapitres "aller plus loin").

Yarn est un concurrent de NPM. Selon moi il n'apporte pas grand chose, n'est pas plus rapide et pas plus fiable.
Cependant, Yarn apporte un truc vraiment sympa, le workspace.
Grâce à cela vous allez pouvoir centraliser toutes les dépendances communes à chacun de vos packages.
En plus de sauvegarder de la place sur le disque dur (ce qui en soit n'est plus un problème aujourd'hui), vous allez grandement gagner du temps lorsqu'il faudra les récupérer, mettre à jour. Et autre cas relativement fréquent, lorsque vous aurez des conflits de versions.

Idéalement vous aimeriez que chaque package ait exactement les mêmes versions de dépendances (sinon bonjour la galère). Avoir un point d'entrée va permettre de simplifier ça.

Le workspace vous permettra aussi de réaliser plus facilement les cross-dependencies (il me semble que ça marche sans, mais bon autant faire le plus propre qu'on peut 😉 ).

Si vous n'avez pas Yarn, installez-le
Ensuite configurez le workspace pour qu'il pointe sur le dossier packages.

En cas de doute, voilà ce qu'il faut ajouter dans le fichier lerna.json (au root):

  "npmClient": "yarn",
  "useWorkspaces": true,

puis dans package.json (toujours depuis le root):

  "workspaces": [
    "packages/*"
  ]

Maintenant ajoutez ces commandes dans votre package.json:

"scripts": {
    "bootstrap": "lerna bootstrap --use-workspaces",
    "build": "lerna exec --parallel -- yarn run build",
    "linkLerna": "lerna link --force-local"
},

Nous allons utiliser ces commandes une par une, tout d'abord, lancez bootstrap avec npm run bootstrap (ou yarn bootstrap), cela va fetcher toutes les dépendances liées au workspace.
Puis yarn linkLerna, cela permet de faire des symlink entre vos packages en cas de cross-dépendances (il n'y a pas besoin de cette commande si vous n'avez pas de cross-dépendances, mais elle ne coûte rien donc prenez le réflexe de la faire après un bootstrap !).

Ces 2 commandes doivent toujours être appelées lorsque vous ajoutez des packages ou modifiez une config (que ce soit un ajout/suppression dans un package.json, peut importe lequel).

Logiquement vous devriez pouvoir lancer yarn build sans erreur.

Cool, a ce stade vous êtes fin prêt pour publier vos packages.

Si l'ajout de Storybook ne vous intéresse pas, sautez directement au chapitre suivant: "npm publish".
Sachez qu'on a fait le tour des basiques concernant Lerna!

Storybook permet d'instancier des composants dans un espace vide, un peu comme si vous aviez un laboratoire et que vous pouviez afficher un composant dans le vide sans personne d'autres.
C'est plutôt pratique pour générer des test live (en ajoutant des commandes diverses ou en faisant plusieurs scénario), de même qu'écrire de la doc !

On peut spécifier de la config custom à Storybook, ça demande de creuser un peu, mais je n'ai pas vu de limite à ce que Storybook propose (et au pire, c'est un projet open-source 😉 ).

Commencez par récupérer Storybook, lorsque j'ai écrit cet article j'étais en LTS 3.4.11, la v4 étant en alpha, d'ici quelques mois ces informations ne seront peut-être plus exacte.

Referez donc vous aux liens que je vais vous passer ci-et-là.

Pour pouvoir lancer notre storybook, il faut d'abord ajouter dans notre package.json principal, les devDependencies dont on va avoir besoin:

"glob-loader": "^0.3.0",
"react-dom": "^16.5.2",
"@storybook/addon-actions": "^3",
"@storybook/addon-info": "^3",
"@storybook/addon-options": "^3",
"@storybook/addons": "^3",
"@storybook/react": "^3",
"storybook-addon-jsx": "latest"

Ajoutez aussi la commande "start" dans vos scripts:
"start": "start-storybook -h 0.0.0.0 -p 9001 -c .storybook"

Voilà le guide de démarrage lié a react.

Vous pouvez suivre le guide de storybook, ou ce que j'ai écrit selon votre préférence.

Sachez que la config que je vous présente est plus complète que le minimum requis, de cette manière vous verrez plus d'options et de possibilités ("dans la vraie vie" le truc de base exposé en démo n'est jamais suffisant).

Créez donc un dossier ".storybook" à la racine du projet.
Ensuite, ajoutez les fichiers et contenus suivant dans ce dossier:

stories.pattern (regex pour récupérer les fichiers "story"):
../stories/**/*.js

config.js (configuration de base de l'appli "wrapper" React):

import React from 'react';
import { configure, addDecorator } from '@storybook/react';
import './storybook.css';

addDecorator((story) => 
    <div style={{padding:"10px"}}>
        {story()}
    </div>
);

function loadStories () {
    require('glob-loader!./stories.pattern');
}
configure(loadStories, module);

storybook.css (pour pouvoir modifier le style par défaut du Storybook, c'est toujours sympa):

body {
  background-color: rgba(0, 0, 0, 0.05);
  background-image: repeating-linear-gradient(0deg, transparent, transparent 7px, rgba(0, 0, 0, 0.2) 1px, transparent 8px), repeating-linear-gradient(90deg, transparent, transparent 7px, rgba(0, 0, 0, 0.2) 1px, transparent 8px);
  background-size: 8px 8px;
  display: flex;
  flex-direction: column;
  justify-content: space-around;
}

html {
  box-sizing: border-box;
  font-family: Helvetica, "sans-serif";
  font-size: 14px;
}

webpack.config.js (pour surcharger la configuration webpack par défaut, si besoin):

const genDefaultConfig = require('@storybook/react/dist/server/config/defaults/webpack.config.js');
const path = require('path');

module.exports = (baseConfig, env, defaultConfig) => {
  const config = defaultConfig;
  
  // For example, add typescript loader:
  // config.module.rules.push({
  // });

  return config;
};

Maintenant, il faut ajouter une "story", voyez ça comme un test unitaire un peu.
Ajoutez donc un dossier "stories" puis créez un fichier par composant (du nom de chaque composant si vous voulez), on va donc ajouter alpha.js

Voilà le contenu à mettre dans votre fichier, cela devrait être sensiblement pareil d'un fichier à l'autre. Attention à bien mettre des noms unique, vous pouvez créer l'arborescence que vous voulez dans le dossier stories:

// stories/alpha.js
import React from 'react'
import {storiesOf} from '@storybook/react'
import {withInfo} from '@storybook/addon-info';

import Alpha from "../packages/alpha/dist";

storiesOf('Alpha', module)
  .add('default', withInfo(``)(() =>
    <Alpha text="Coucou je suis le composant alpha" />
  ));

N'oubliez pas de faire un yarn bootstrap puis yarn linkLerna afin d'avoir toutes les dépendances. Un npm i fonctionne aussi mais il requiert quand même le bootstrap après.

Et maintenant showtime, on lance storybook avec npm start et on consulte le résultat sur 0.0.0.0:9001.

Je vous laisse le soin de consulter les commentaires pour comprendre chaque partie.
Libre à vous de rajouter des boutons, un state, ou quoi que ce soit dans chaque fichier, qui vous permet de jouer avec votre composant.

Vous pouvez aussi faire une documentation, en complétant par exemple chaque "withInfo", rajouter des tests unitaires, ajouter des snapchots avec Jest.

En tout cas, vous avez vos composants qui fonctionnent, il ne reste plus qu'à... publier !

Histoire d'être raccord, voici la branche qui correspond à tout ce que l'on vient de faire.

npm publish

D'abord, on va ajouter la commande "publish" dans nos scripts du package.json principal:
"publish": "lerna publish"

Libre à vous de publier sur le repo public npm ou sur un repo privé.

Si vous publiez des packages privés qui ne dépendent pas du service npm, il vous faut utiliser cette commande à la place:
"publish": "lerna publish --no-verify-access"

Vous pouvez aussi consulter la documentation de lerna publish

Aussi, avant d'aller plus loin retenez bien ceci:

Le but de Lerna est de centraliser la maintenance, tests et publications de vos dépendances.
Par conséquent, vous ne DEVEZ JAMAIS publier un package seul, "à la main". Sinon lerna ne sera plus capable de publier, il vous faudra sauter des versions ou supprimer les packages publiés, bref. Ne faites pas ça.

On est bon ? On retourne au dossier racine du projet.
Vérifiez que vous avez bien configuré chacun de vos packages, si c'est un repo privé il faut ajouter la configuration qui va bien, s'il est publique il faut y mettre les bonnes informations.

Instanciez votre repo git si ce n'est déjà fait, faite votre commit/push puis...

Lancez npm run publish (ou yarn publish) pour publier!

Cette commande lance un build avant de publier, libre à vous de modifier cette commande pour y intégrer les tests.

npm vous demande de quelle "upgrade" il s'agit, vous pouvez suivre la convention par défaut ou le faire "custom". Moi je fais mon possible pour respecter le standard:

• +0.0.1 pour un fix
• +0.1.0 pour une feature
• +1.0.0 pour un changement majeur (potentiellement "breaking changes")

Aller plus loin 1 - une config pour les gérer toutes

On peut encore améliorer tout ça.

Un problème reste présent dans notre projet actuel, lorsque l'on aura plusieurs packages et que l'on fera "une évolution" ou "un petit changement" dans la config "rollup" de nos packages:

Il faudra faire le changement pour chaque package, 1 par 1. Rien de plus pénible.

Donc, on va faire un fichier type "factory" au répertoire racine, puis chacun de nos packages appellera ce fichier-là, y précisera "ses spécificités" et lance la fonction.

Comme ça, on a plus qu'un fichier à maintenir.

Voilà la théorie:

1. On fait un fichier "global.rollup.config.js" à la racine du répertoire parent.
   Ce fichier est censé exporter une fonction qui prend en paramètre un objet dans lequel on pourra écraser n'importe quel paramètre.
2. Dans le fichier rollup.config.js de chacun de nos packages on enlève tout et on appelle ce fichier dans le parent.
   Il ne reste qu'à appeler la fonction retournée par le fichier en lui passant en paramètre nos options customisée pour ce composant-là.

Je vous invite à consulter la branche plus_loin_1_factory pour pouvoir consulter cette amélioration.

Aller plus loin 2 - embarquer du json tu pourras (traductions)

Dans ce chapitre additionnel on va ajouter le chargement de JSON à notre package "alpha" (le json ne sera pas chargé via un appel AJAX mais sera inliné dans la build).

Afin de faire une démo "utile", on va faire comme si l'on voulait ajouter un fichier de langue qui sera chargée automatiquement par i18next.

Cela sous-entend que vous utilisez i18next dans votre projet principal, si ce n'est pas le cas vous trouverez un moyen d'adapter ce principe à votre stack :)

On ajoute dans notre package.json principal ces devDependencies:

    "i18next": "^11.9.0",
    "rollup-plugin-json": "^3.1.0",

Ou en commande npm i --save-dev i18next rollup-plugin-json

Une fois ces nouvelles dépendances installées, dans le fichier global.rollup.config.js il faut ajouter le json loader.

import json from 'rollup-plugin-json';


// a ajouter juste après "resolve()" (ligne 31 normalement)
      // allow to load inlined json
      json( Object.assign( optional.json || {}, {
        include: 'src/**',
        indent: ' '
      } ) ),

Un petit yarn bootstrap suivi d'un yarn linkLerna et un yarn build nous confirment que notre build rollup fonctionne toujours.

Maintenant on va ajouter notre json dans notre package.
Je vous invite à consulter la branche github associée

Dans le fichier package.json du package alpha, ajoutez dans les dépendances: "i18next": "*".

Dans le dossier alpha on ajoute un sous dossier src/locales qui contiendra chacun de nos fichiers de langues, on va mettre fr.json et en.json pour cet exemple.
Vous pouvez directement reprendre les fichiers depuis le github.

Les fichiers sont importés comme une dépendance normale, ensuite dans le constructeur du composant on vérifie si i18next connait déjà ce namespace. Sinon, on y injecte nos langues.

Attention, cette technique ne fonctionne que si votre projet utilise i18next dans la même version, vu que le package demande n'importe quelle version de i18next via "*", vous n'aurez normalement pas de conflits de versions. Sinon, passez vos dependencies en peerDependencies règle toujours le problème, mais le projet parent devient alors responsable de la présence des dépendances.

Dans le code du composant on fait ces modifs:

// ajoutez ces imports
import FR_LOCALES from "./locales/fr.json";
import EN_LOCALES from "./locales/en.json";

// dans le constructeur
    // charge le bundle fr s'il n'existe pas dans i18n
    if ( !i18n.hasResourceBundle( "fr", "namespace" ) ) {
      i18n.addResourceBundle( "fr", "namespace", FR_LOCALES );
    }
    // charge le bundle en s'il n'existe pas dans i18n
    if ( !i18n.hasResourceBundle( "en", "namespace" ) ) {
      i18n.addResourceBundle( "en", "namespace", EN_LOCALES );
    }

// dans le render afin de vérifier que cela fonctionne
Localization: {i18n.t("namespace:key_of","i18n_error")}

Il va nous falloir faire une petite modification à l'initialisation de storybook pour initialiser i18next (sinon cela ne marchera pas).
Dans le fichier .storybook/config.js ajoutez le code suivant juste après les imports:

import i18n from "i18next";

i18n.init({
    lng: 'en',
    fallbackLng: ['en'],
    fallbackOnNull: true,
    fallbackOnEmpty : true,
    returnNull: false,
    returnEmptyString: false,
    debug: true,
    resources: {
    }
  }, () => {
});

Une fois ce code ajouté, lancez yarn build et enfin yarn start.
En navigant à l'adresse du storybook vous devriez voir votre composant avec la phrase traduite.
Maintenant pour tester vous pouvez changer le lng: 'en', à lng: 'fr', dans la config, attendre que le code soit rechargé à la volée et actualiser la page (ou passer d'un module à l'autre pour forcer le re-rendering), vous devriez l'avoir en français !!

Aller plus loin 3 - avec du css c'est mieux

Comment ? Vous n'êtes pas satisfait de vos composant en noir et blanc ?
Alala. Pas de soucis, j'ai une solution (à défaut d'avoir là solution).

Si vous voulez gagner du temps, voilà la branche qui contient tout ce qu'il faut.

Les étapes sont assez rapide, on va utiliser PostCSS (pourquoi? Parce que c'est ce qu'on utilise à Viareport et que j'avais pas envie de faire une version de chaque 😆) mais vous devriez pouvoir trouver chaussure à votre pied si cela ne vous convient pas.

Sachez que comme le CSS sera transpilé, ce choix n'impactera pas votre projet final de toute façon !
Une bonne chose en somme.

Dans le fichier global.rollup.config.js faites les modifications suivantes:

// on ajoute ces imports spécifique à postcss
import postcss from 'rollup-plugin-postcss';
import cssNext from 'postcss-cssnext';
import cssReporter from 'postcss-reporter';
import cssImport from "postcss-import";

// dans plugins, juste avant "resolve()," (ligne 34 normalement)
    postcss({
        // modules: true, // if true, create a css namespace => will add the name of the css file as prefix to all classname (ux-header became style_ux-header)
        plugins: [
          cssImport( { skipDuplicates: true } ),
          cssNext(),
          cssReporter()
        ]
      }),

Il faut ajouter les nouveaux outils dans le package.json principal:
npm i --save-dev rollup-plugin-postcss postcss postcss-cssnext postcss-reporter postcss-import

Comme à l'habitude il faut lancer yarn bootstrap && yarn linkLerna

Un petit test avec yarn build pour confirmer que tout fonctionne comme avant.

Et maintenant, il nous suffit d'ajouter un fichier css à notre composant alpha (je vous laisse le soin de découvrir ce que CSSNext offre):

// dans le fichier alpha/src/index.js
import './style.css'

// pensez à modifier le render pour avoir une classe
<div className="alpha" ref="test">

// exemple dans le fichier style.css, mais n'importe quoi marcherait
.alpha {
  padding: 10px;
  background: white;
  border: 1px solid black;
}

Vous lancez à nouveau yarn build && yarn start puis allez vérifier sur Storybook que tout est conforme.

Alors, c'était dur ?
J'espère que non !

PS: a la vitesse a laquelle évolu le JS, il est probable que certaines config ne fonctionnent plus, auquel cas il faut vérifier chaque dépendance une par une pour voir et comprendre comment elle fonctionne et comment l'upgrader.
Mais si vous utilisez mon repo tout devrait bien se passer 😂

Si vous avez aimé cet article n'hésitez pas à me le faire savoir, j'écrirai peut-être un autre article dans la lignée de celui-ci, concentré sur les tests.

Suggestion musicale pour la lecture de cet article

Le 3 & 4 Août dernier se produisait la "nuit des étoiles", probablement le meilleur week-end de l'année pour combiner tout ce qu'on aime, ballade 4x4, rando, bivouac et admiration du ciel étoilé.

Le tout dans les Pyrénées pas loin des 2500m d'altitude, a la fraiche donc (dans les 3-4° la nuit l'air de rien !).

On est parti en début de matiné histoire d'avoir toute l'après midi pour profiter, mais voilà. Tout ne s'est pas passé comme prévu (ça fait partie de l'aventure, aussi courte soit-elle).

5km avant Barège le Jeep câle et de la fumée sort de sous le capot. Panique.

Le moteur crache de l'eau au niveau d'un tuyau, obligé d'attendre que ça refroidisse. Vous remarquerez l'endroit idéal pour tomber en panne.

Après une rapide recherche sur internet je découvre que le Jeep est équipé d'un relais anti-surchauffe. Je n'ai pas trop cherché où il était mais déjà je suis "rassuré". Le moteur devrait aller bien.

Re-remplissage avec de l'eau, on roulera sans le bouchon du radiateur pour éviter de le mettre sous pression.

Le bouzin démarre, on y va.

Après 1 arrêt intérmédiaire (1 bonne heure au total) on arrive enfin dans Barrèges, câlé dans une petite ruelle, on commence à voir ce qu'on peut faire.

Le constat tombe, le radiateur est fendu sur le côté (pas la partie cuivre, sorte de plastique) trop de pression semble t'il.
On attend l'ouverture d'une petite supérette pour y acheter de la super-glue, chanceux il y en a.

On applique la glu sur la fissure, on attend un peu, on re-rempli et on y va. Encore une fois on a décidé de ne pas remettre le bouchon du radiateur afin de le libérer de toute pression et éviter que la réparation super-glue ne tienne pas.

Moment stress, on a 1km à faire avant de rejoindre la piste.

On arrive à la piste ça sent bon le liquide de refroidissement, juste à temps on s'arrête, y'a de l'eau qui sort de partout ^^

Cette fois on se dit "tiens en fait c'est peut-être le bouchon du radiateur qui marche pas comme il devrait". C'est une sorte de valve qui réagit à la pression et laisse partir la pression dans le "vase d'expansion".
Du coup on enlève la rondelle caoutchouc de ce bouchon pour permettre une "évacuation directe" de la pression.

On va voir comment ça marche.
1km plus loin, on rejoint enfin les potos. Petit check.

Tout va bien, plus de perte d'eau donc a priori notre théorie est bonne.
L'endroit est sympa, on est pas pressé, c'est cool.

On a laissé le petit Che se reposer un peu, on y retourne, que le petit Sunny à chaud ^-^ (et nous aussi).


Grosse troupe ahah, le 4L ne galère pas au moins (pas encore).

1 pause le long de la piste, on check que ça va on fait quelques photos et on continue.

Encore une pause 1km plus loin pour vérifier et mettre de l'eau, il fait très chaud et la piste est raide, avec 7 personnes dedans plus tout le matos...

Toujours plus raide, avec la remorque ça n'aide pas, le Jeep commence à chauffer et cette fois c'est la crasse "historique" qui fume tout autour du moteur.

On décide de s'arrêter là, il nous aura déjà amené bien loin, on commence donc la rando.

Sunny n'a qu'une envie, la ballade vite !

Et c'est parti pour la rando

Il s'éloigne doucement.



On grimpe, nous ne sommes pas les seuls malgré l'heure tardive il y a beaucoup de monde.

Nous voilà arrivé au lac de la Glère (2000m), le refuge est juste au-dessus de nos têtes. On se repose un peu ici le temps que tout le monde arrive.

Petit détour par le refuge

Qui s'éloigne rapidement dans la brume

De même que le lac de la Glère

Tandis que l'on commence à apercevoir le lac suivant

On grimpe sans pause, car la nuit approche (donc moins de photos ^^) pour finalement s'arrêter avant le lac Det Mail

Perdu

dans la brume

Un peu moins de 2h de marche assez intensive pour environ 6km, au départ nous voulions aller beaucoup plus loin vers le lac du Pourtet, mais les problèmes mécaniques ont joué contre nous. Le Lac Det Mail beaucoup moins loin mais relativement haut était une bonne option de repli, n'oublions pas notre objectif de base: observer les étoiles et le ciel.

Mais pour l'heure, repos avec une baignade très fraiche (et très agréable).
On va essayer de trouver un coin sympa, car le lac Det Mail est éparpillé.

Sunny a peur de l'eau donc je le porte pour traverser (alala pire qu'on petit enfant ^^).

Et la baignade !

La brume s'intensifie, on en profite pour faire un feu et s'amuser avec du light painting.

Le ciel fini par se découvrir, on peut observer Jupiter, rapidement Vénus qui se retrouve à nouveau derrière la brume.
La voie Lactée est bien visible, ainsi que la station ISS qui passe au-dessus de nous, nombreuses sont les étoiles filantes.
Malheureusement nous n'avons pas réussi à faire de photo correcte du ciel.

Histoire de ne pas vous laisser sur votre faim voilà une photo prise dans le même coin ;) (j'ai volontairement choisie une qui se rapproche de ce que l'on voit en vrai).

Via Meteo_Pyrenees

Et une autre très sympa, plus tôt dans l'année, de l'autre côté de la montagne par rapport à nous !

Via Maxime Tessier

Le retour

Le refuge de la Glère.

Notre bivouac vue de plus haut

Un peu moins haut, moi je dors encore ^^

Au loin l'observatoire du Pic du Midi.





On redescend maintenant, après avoir laissé une trace éphémère de notre passage.

Sunny apprécie aussi le paysage (ou bien est-ce le bruit du troupeau ?)

Nous revoilà, presque au Jeep.

Mais si, regardez mieux

Là !

Bye bye la montagne

Avant de réellement rentrer, on a aidé quelqu'un qui avait un soucis d'embrayage. On a réussi à lui réparer avec un maillon de ma chaîne de portefeuille (pratique).

Un long retour stressant, en espérant que le radiateur ne cède pas à nouveau.


Nous aurons réussi à rentrer sans encombre ! Cette réparation "super-glue" aura tenue bien mieux que je ne le pensais.

Maintenant le Jeep va rester au garage le temps que je lui commande un radiateur digne de ce nom.
J'ai un peu de mécanique à faire (rien de très compliqué pour le coup).

Les problèmes peuvent parfois sembler insurmontable et on a tendance à baisser les bras trop vite, heureusement j'avais mon ami Justin avec moi pour m'aider à trouver des idées et solutions. Et ça a payé, on a fait notre randonnée au lieu de rester coincer à attendre une dépanneuse.

J'espère que vous aurez apprécié cette petite aventure dans les Pyrénées et les photos prises par mes amis Justin et Sylvain.

Dites-moi si vous voulez d'autres articles de ce genre ^-^

Douche et WC
Les cloisons sont finis, dans ce nouvel article je vais vous parler de la salle de bain et du WC.

Un peu de plomberie et de carrelage en somme.

Tout d'abord, le WC.
On a installé un WC "suspendu" (c'est-à-dire sans empattement au sol) ce n'est plus si cher que ça (on a pris dans les premiers prix).
Le montage se fait via un cadre métallique que l'on fixe au mur et au sol.
Dans notre cas, avec les murs en vieux parpaings on a dû utiliser du scellement chimique pour faire tenir les vis dans le mur.
Ensuite l'évacuation Comme on le voit sur la photo elle n'est pas cachée derrière, la raison à cela est que notre évacuation est en amiante donc on n'y a pas touché ! (tant qu'on y touche pas, ça ne craint pas. Surtout qu'elle passe dans les fondations de la maison et absolument pas dans l'enceinte de la maison, ouf).
On s'est donc directement connecté dessus avec un tube PVC de diamètre un peu plus petit et beaucoup de colle.

Et la photo finie (avec le chauffe-eau, quelques semaines plus tard donc)

On passe côté Salle de bain (abrévié sdb à partir de maintenant) et douche.
La douche est entièrement séparée par une cloison + porte coulissante, on va donc s'occuper de carreler la douche en entier avant de s'occuper du reste.
Mais avant le carrelage il y a de la plomberie cachée sous le placo (c'est donc un petit retour dans le temps comparé à l'article précédent 😲 ).

Déjà voilà la nourrice, c'est un "bifurcateur" qui permet de générer plusieurs sorties depuis une arrivée d'eau, ici eau froide (uniquement froide pour l'instant puisque le chauffe eau n'est pas posée à ce stade). Je vous conseille fortement d'en prendre une avec des robinets, cela vous permet d'en acheter une "plus grande que prévue" ou simplement de pouvoir travailler chaque système un à un (ce qu'on a fait ici).

Ensuite, il faut le tuyaux d'alimentation de la douche, de loin ça donne ça
Et la fixation de robinetterie murale vue de près
On l'a "collé" avec du mortier pour l'arrière (dans le trou) et de l'enduit colle (ou map) sur la partie proche de la surface.

Une fois le placo percé au bon endroit et collé au mur, la douche ressemble à ça

On fait les joints de placo que l'on ponce
Puis une première couche de peinture au plafond

Place au carrelage.

Certaines personne sont "ok" pour poser le carrelage directement sur le placo vert en partant du principe que la colle à carrelage + le placo hydrofuge (couleur vert) seront suffisant (le placo vert est plus résistant à l'eau que le placo blanc, mais il n'est pas 100% "étanche" pour autant).
Après pas mal de recherche sur internet sur les différentes façons de faire et produits, j'ai opté pour un enduit d'étanchéité de parois "pré-carrelage", de cette manière je me sens plus rassuré pour la suite.

Allé au boulot là 😝

Tout ça avance tranquille

Au niveau du sol on a utilisé l'équivalent d'un receveur à carreler pour surélever le plancher (il en existe de différentes épaisseurs), ensuite on a fait en sorte de faire une petite pente pour que l'eau revienne dans la douche en cas de débordement (c'est pas parfait, on aurait dû insister un peu plus mais bon c'est déjà bien !)

Pose quasi finie

Et une fois tout néttoyé

Résultat avec la colonne de douche posée

On aura encore de la finition (bordure du carrelage en haut à poncer et repeindre) mais déjà, la douche est fonctionnelle et ça c'est quand même cool.

Côté sdb, pose du sol

Puis montage du meuble "test"

Et version "finale" (en attendant de faire le carrelage des murs dans la sdb, ce qui sera fait quelques mois plus tard).

Pendant ce temps, le chauffe-eau est stocké dans la chambre à côté, on a que de l'eau froide (en août ça va)

Au moins ça nous permet d'avoir une "vraie" sdb, car avant on utilisait ça 😌

Les cloisons et le placo, une grande histoire d'amour qui ne fait que débuter !

Comme il y a plusieurs pièces et même des parties de la maison qui n'existe pas encore à ce moment-là, il y aura des parties "placo" dans beaucoup d'autres articles.

Je vais un peu casser la chronologie dans les 2-3 articles qui suivent, car l'on a fait plusieurs choses en même temps / en alternance et je préfère essayer de focus au maximum un sujet à la fois.

Après un gros chargement placo (sans photo 😓 ) on arrive très rapidement à ce résultat:
Début de la future salle de bain donc !

Puis on y monte la porte:

Après une après midi on a posé toute la structure, les portes et quelques plaques:

Et on a perdu pas mal de temps sur la porte coulissante de la douche (on a fait une douche à l'italienne séparée par une porte coulissante. On préfère ça permet de prendre sa douche tranquille et quelqu'un d'autre se sert de la salle de bain en même temps).

Petite vue du reste de la salle de bain:

Oh un singe ! Ah non 😂

Quelques précisions/explications:

La structure des cloisons c'est sûrement le truc le plus facile. On fixe le rail au sol (vis pour nous puisque plancher bois, cheville à frapper sinon sur une dalle béton) ensuite on sertit les rails (verticaux) sur le rail du sol, puis on finit en mettant un rail en haut (le même que celui au sol) qui est sertit à son tour avec ceux verticaux, l'ensemble devient plutôt rigide.

Pour le plafond tout dépend de votre maison comment elle est faite, la taille des pièces etc...

Par exemple pour la douche je voulais un plafond à 2.5 et pas 3m donc on a fait reposer la plaque du plafond directement sur les bords des plaques murales. Après quoi on a ajouté des rails de plafond que l'on a fixé sur les rails de la cloison (histoire de verrouiller, mais il faut savoir que juste en posant la plaque sur les autres ça tenait très bien, il faut dire que ce n'est pas très large).

Après, dans ma maison on avait des poutres qui étaient là (depuis perpète) pas trop pourries, au début on voulait les virer pour faire un demi-étage avec une vraie hauteur, puis on s'est dit que c'était trop de boulot pour pas grand-chose donc on a gardé les choses tel quel, et on a pu se servir de ces poutres pour y fixer toutes nos cloisons.

Vue de dessus du plafond de la salle de bains:
Et vue de dessous:

Fun fact, fixer les cloisons aux poutres aura rigidifié les poutres (ça devrait être l'inverse j'suis d'accord lol).

L'avantage de garder les poutres aussi c'est qu'on peut y fixer nos suspentes qui permettent de faire le faux plafond:

3m l'air de rien ça fait haut sur des poutres 😅

Et maintenant on lève les plaques sans lève-plaque 😲
La technique: utiliser 4 élingues "légère", une a 20cm de chaque coin environ, cette technique se fait à 2 facilement, mais à 3 c'est encore mieux (2 qui tiennent chacun 2 élingues et l'autre qui les fait monter à tour de rôle).

Une fois plaqué au plafond ça tient "tout seul" reste plus qu'à visser et faire la suivante. Fastoche.

Hop des petits dessins sur les murs 😹 (on aime bien mettre des ci git)

Isolation de tout ça en 30 minutes chronos !

Et le résultat "quasi fini" (avec le stockage pour le carrelage de la salle de bain ^^)

On fini avec du "collage" de placo, technique "crado" mais très pratique/rapide (et plus utilisée que ce qu'on pourrait penser, des fois les trucs crade c'est pas si grave)

La colle en question c'est de "l'enduit colle" tout prêt. Juste a mettre de l'eau.
Plusieurs personnes avec qui je parlais me disent "le map" ce doit être une marque ou quoi donc ne soyez pas surpris si vous entendez ce mot (pour ma part ça me fait juste penser au mot anglais "carte" lol).

Le principe est simple, on fait de la colle et ensuite on éparpille des petits patés partout sur la plaque, ensuite on la colle au mur.

Les élingues sont là pour garder les plaques bien collées (de niveau si possible sachant que les murs de la maison sont tout sauf droit 😁 ).

Par rapport au choix de mettre du placo sur les murs "porteur", il y avait une sorte d'enduit, sous lequel on trouvait autre chose, sous lequel probablement de la peinture puis de la tapisserie. Tout ça posé sur des parpaings de très mauvaise qualité qui s'effritent.
Vu le temps passé pour gratter quelques cm d'enduit puis le travail nécessaire pour reboucher (sachant qu'à la fin le mur ne serait pas droit) on a préféré mettre du placo et rattraper la droiture du mur (ça reste pas parfait, loin de là ^^).

Nous n'utiliserons pas cette méthode partout dans la maison, chaque endroit à sa petite histoire, des pour et des contres. Sachez juste que cette méthode marche bien !

Et pour terminer cet article voilà une petite photo du début des "joints" de placo, l'ami de tous (et pourtant pas si difficile, mais il faudra patienter pour ça 😉 )

Petit teasing pour la semaine prochaine, on parlera sanitaire ! Douche et WC.

Chaînage fini, charpente ok, on pose maintenant les tuiles.
Rien d'extraordinaire si ce n'est qu'il faut bien les disposer pour faciliter la pose et s'assurer de leur alignement.

Ce sont des tuiles "Romanes" ça s'emboîte donc de gauche à droite et de bas en haut. Inutile de fixer chaque tuile ou chaque rangée à la charpente, fixer les tuiles de rives est suffisant (et encore, je n'avais pas mis les tuiles de rives avant un bon moment et rien n'a bougé malgré les tempêtes !).

C'est l'heure d'aller chercher les Velux en bonne compagnie
On a posé les Velux une fois les tuiles posées. Malheureusement j'ai oublié de documenter cette partie, je n'aurais donc pas grand-chose à vous montrer si ce n'est le résultat (et ouai, on ne pense pas toujours à prendre des photos de tout quand on fait sa maison 😣).

Petite précision, à ce moment-là je devais attendre la fin du bardage de la maison pour pouvoir poser les tuiles de rives et de faîtage (celles tout en haut). Le toit va donc rester comme ça un long moment (vraiment longtemps en fait).
Pas de soucis en soit, enfin tant qu'on a pas une très grosse tempête (heureusement Toulouse a plutôt été épargné comparé à d'autres, donc "ouf". Si c'était à refaire j'aurai au moins fixé la première rangée par précaution).

Vue des Velux de dessous

Ils donnent directement sur la cuisine (les "poutres" seront enlevées par la suite)

De retour sur le plancher, on va très vite sur le premier et dernier tiers puisqu'on sait exactement quoi faire Il faut toujours rire 😉

Nous voilà donc sur le cadre central, le dernier. Qui comporte tous les passages de câbles et tuyauterie (le plus long du coup)
Enfin avant ça, il aura fallu faire les saignées, vive les disques diamants et le burineur 😍

On a donc tout refait (les 3 cadres) avec un espacement de 50 par chevrons (mais comme je disais précédemment, à refaire je mettrais 30).

Ici l'arrivée d'eau pour la cuisine et des câblages qui arrivent au pied du compteur

Là l'arrivée d'eau globale et le "départ" pour celle de la cuisine

Pour tout ce qui concerne la plomberie, j'ai choisi de partir sur du PVC flexible, ça se tord à la main, pas de soudures et moins cher que le cuivre, sauf que niveau prix les embouts eux coûtent cher (on doit arriver au même prix, mais ça se pose plus rapidement quand même, surtout quand on est pas un pro).
Pour les embouts, il en existe 2 types, les "à sertir" et les "à visser". Ne partez pas sur ceux à sertir car il faut une pince spécifique qui coûte plutôt cher et vous ne pourrez pas redémonter en cas d'échec (ou de changement d'avis, ce qui arrive souvent).

Par contre attention, avec les embouts à visser il faut rajouter du joint sur les filetages. Prenez du "ruban Téflon" et pas la pâte (c'est galère et moins pratique je trouve), ensuite comptez 8-10 tours sur le filetage, ruban bien à plat, dans le sens du vissage.

L'autre côté du cadre, l'arrivée cuisine sort au coin et passera dans un coffrage bois "esthétique" (on aurait pu faire que l'arrivée continue sous le cadre, mais l'évacuation ayant besoin d'une pente nous n'avions de toute façon pas le choix ! Autant tout mettre au même endroit)

Répartition des câbles de l'autre côté, petite boîte de dérive pour démultiplier en gros une boite de dérive c'est "juste" une boîte en plastique creuse dans laquelle on fait arriver X câbles que l'on connecte ensemble avec un "sucre" (ou domino, y'a plusieurs noms 😁 ).

Entre-temps on accueille le nouveau venu, faut dire que ça creuse tout ça

Et on termine le cadre, adieu petit graffiti (ça fera des souvenirs ou une surprise si un jour c'est démonté 😂)

Les planchers sont finis (enfin), câbles prêt ainsi que plomberie.
Il manque la photo finale, mais je vous laisse imaginer 😝
Prochain épisode on commencera donc les cloisons, ça va enfin ressembler à quelque chose !

Spoiler

Dans l'article précédent je vous parlais du toit, voilà donc la deuxième partie.

On s'est donc préparé pour faire le chaînage du toit.

Première étape, récupérer le matos pour ce faire, béton et parpaings:

Accompagné d'une bétonnière et d'un premier godet de mélange:

Afin de libérer l'espace du toit au maximum on a viré le reste de tuile en bas, on a donc fabriqué un palant:

Un petit aperçu du tas de gravats et de la remorque chargée avant qu'on commence:

Pour le chaînage on a fait une partie avec des parpaings de chaînage et le reste avec des planches de coffrage (les parpaings nous permettaient de faire un guide comme ça):

On avance pas mal

Puis la cata, l'orage pointe son nez et ruine ce que l'on avait commencé à faire dedans:

Et encore, on a minimisé l'eau dedans avec un système D (pas au point)

Quand je vous disait précédemment que c'était "pas de bol" et mal calculé je ne mentais pas.
Le plancher était foutu, bien que le bois avait plutôt bien résisté après séchage (c'est de l'osb "pièce humide" 2cm d'épaisseur) on a pu réutiliser 90% du plancher, par contre la laine de verre en dessous poubelle a 80% (heureusement que ça ne coûte pas super cher).

L'orage passe, on continue donc le chainage:

Sur la rangée arrière on a rajouté une ligne de parpaing, car d'origine sur la maison, la dernière ligne était une sorte de "chaînage en galets". Un truc tout pourri qui s'enlevait juste en poussant avec la main.

Si c'était à refaire, j'aurai ajouté 3 rangées à l'arrière et 2 sur le reste afin de surélever le toit par rapport à l'origine, ça faisait 4 fois plus de béton c'est certain mais j'aurai pu faire un étage ou une bonne mezzanine ! (j'en parlerais plus tard mais il faut savoir que les impôts, eux, ne raisonnent pas en "loi carrez" donc quitte à refaire, refaites bien ou ne faites pas. C'est dommage de payer un impôt pour 30cm de hauteur sous plafond 😂 ).

Aujourd'hui il est impensable de ré-hausser la maison, ce serait bien trop de boulot alors que tout est fait.

Vue de la rangée arrière:

Petite pause "wouffesque"
Madame aussi veut le style !

Le chainage est fini, on en profites pour enlever tout le faux plafond et autres trucs qui étaient là (anciennes cheminées notamment) car après ce sera galère !

Encore un sacré boxon qui va agrandir un peu le tas de gravats derrière 😌

Et voilà, après un peu moins de 2 semaines de boulot, les charpentiers reviennent et en une journée c'est plié
Un jour de plus pour les finitions et on peut faire les marioles sur le toit !

Temps total de l'opération toit:

• 3 jours de démontages de toit/tuiles
• 12 jours de chaînage
• 2 jours de charpentes

Pas trop mal au final !

Prochaine opération, on repose les tuiles et on refait le plancher.

L'intérieur est détruit (et "propre"), de même pour les combles. On peut donc maintenant s'attaquer à:

• commencer le plancher bois dans la maison (et autres)
• enlever les tuiles (afin de refaire la charpente)

Au cas où cela ne serait pas évident pour certains, c'est une grosse bêtise que de commencer les travaux dedans alors qu'on va démonter le toit. Mais... la météo était vraiment favorable et nous avions au moins 1 semaine de beau temps, le travail sur le toit ne "devait" prendre que quelques jours.

Tout était calculé (j'aime bien ça, mais c'est pas très compatible avec les chantiers surtout extérieurs).

Spoiler (version courte): connerie (et au final tant mieux, vous comprendrez pourquoi).

Bon, cela dit afin d'éviter les noeuds (y'en a déjà assez) je vais tenter de rester chronologique au maximum.

Et nous voilà donc en train de fabriquer la première section de plancher. La maison faisant env 4m de large sur env 12m de long, on a décidé de faire 3 quadrillages de 4x4 (environ).

Première bêtise qu'on a faite ici, l'espacement entre les chevrons (on y connaissait rien donc on a "testé"). Ici on a mis 70cm (par là). En vrai, n'allez jamais au delà de 50cm. Et aujourd'hui à refaire je mettrai même 30cm.

Isolation (c'est pour cette raison que l'on fait un plancher, on oublie l'idée d'isoler le vide sanitaire de 20cm de haut, bofbof).

Et une fois la section de plancher finie:

En parallèle un pote s'occupe de commencer la saignée pour passer l'eau jusqu'au futur emplacement de la cuisine.

Et un autre pote s'occupe de réhausser le palier de porte à la hauteur du futur plancher "fini" du taff question découpage du cadre en haut et réajustement des gonds mais ça passe. Un petit coffrage de béton et le tour est joué (ça tient encore donc c'est bon ! Je crois...)

A l'opposé de la maison, mise en place de la 3ème section

Au passage on "contemple" la manière dont cette partie du mur a été traité (sûrement une ancienne porte, il y a bien longtemps).

Et puis n'oublions pas le plus important, enlever les tuiles du toit !

Pour rappel on démonte tout le toit car la charpente est pourrie, morte archi morte et l'isolation des combles nase aussi, bref on perd pas grand chose.

On refait donc tout à neuf.

Le plan ici c'était "on enlève les tuiles le week-end, les charpentiers feront la charpente lundi/mardi, on remet les tuiles direct après et en plus on a 2 jours de marge avant l'orage".

Pas de plan B non, jeune padawan les erreurs tu commettras. Bref, au boulot !

Ah, ça bosse dur !

On y était encore le dimanche soir (on a étalé ça sur 2 jours, dur l'air de rien !)

Une des petites trouvailles jolie mais malheureusement "mortelle" (même si l'on bouge le nid 😢)

Et on stocke "le max" de tuiles sur le toît du garage qui lui n'a rien on a stocké un peu moins de la moitié ici 😨

Tout se passe bien jusque là.
On est Lundi les charpentiers arrivent et moi je vais bosser, puis on m'appelle. Problème... ok j'arrive (plus simple).

Et là il m'explique que la maison n'a pas "de chaînage". Chaînage késako, j'sais pas.
Heureusement mon pote qui m'aide le plus, lui sait ce que c'est. Il en a même déjà fait un avec son père pour une clôture (c'est pas pareil mais bon, la théorie reste la même et la pratique... pas très loin).

C'est donc le plop twist, l'orage arrive et on sait que le chaînage ne sera pas faisable en si peu de temps. Vous comprenez d'avance donc pourquoi c'était une bêtise de faire l'intérieur avant d'avoir fini le toit.

Enfin si tout s'était bien passé ça aurait été le plan parfait.
Si...

(poubelle, oui-oui).

Au vue du travail qu'il reste au sujet du toit, je ferai donc un deuxième article qui concluera la partie "toiture" ! 😊

Clés en mains, nous voilà armés de massues, disqueuses, burineurs bref tout l'arsenal pour tout péter.

Vérifiez avant où arrive l'électricité (disjoncteur, tableau) ainsi que l'eau et potentiellement le gaz.

Concernant l'arsenal d'ailleurs qui vous sera vite indispensable, profitez des affaires d'occasions ! Entre les sites d'annonces et les brocantes vous trouverez votre bonheur (mais il faut s'y prendre avant c'est mieux car au dernier moment on a rarement les meilleurs deal).

Si vous voulez du neuf adaptez vos achats en fonction de la fréquence d'usage, si vous vous en servirez autant après et si on vous le remplace en cas de panne (en général on le renvoi dans une usine et il faut attendre 1-2 mois sans l'outil).
Des fois il vaut mieux mettre un peu plus, ou alors beaucoup moins mais en 2 exemplaires ^^ (j'écrirais peut-être un article pour parler outillage).

PS: durant cette étape je n'ai pas pris beaucoup de photos, mais bon la destruction c'est pas le plus compliqué.

Mettre des coups de massue c'est pas sorcier hein. Si comme moi vous avez décidé de tout péter et tout refaire, y'a pas besoin d'hésiter BOUM (quand c'est de la brique comme là, c'est plus dur 😂 c'est mieux).

Il faudra au préalable s'assurer de couper le disjoncteur et/ou de déconnecter tous les fils qui y arrivent, de même pour l'arrivée d'eau.

Il va sans dire que si vous craignez les petites bébêtes de la nature cela vous complexifiera la tâche très souvent !

On enlevait tranquillement le carrelage et en arrivant sur le dernier tiers de la maison, le revêtement nous semble étrange (colle a carrelage mais dessous on dirait que ça sonne creux, comme du bois).
Après avoir gratter légèrement on voit que c'est bel et bien du bois ! Du coup on a ouvert pour vérifier l'état en dessous.

Tout va bien, les poutres sont saines, pas besoin de tout refaire (ouf).

Cela dit, ça nous pose quand même un sacré pépin technique.
Dans l'idée on pétait tout pour ensuite couler une grosse dalle béton uniforme avec de l'isolant dessous.
Là... bon on aurait pu faire du "béton léger" ou quoi mais j'étais pas très chaud.
On laisse ça pour plus tard de toute façon, on a déjà une tonne de choses à faire avant !

On alterne un peu entre destruction en bas et nettoyage des combles (le matin de préférence car il fait une chaleur à mourir dans ces combis, plongé au milieu de la laine de verre et d'un milliard de merdes (oups, pardon 😂 ).

Voyez par vous-même (ah le mot n'était pas exagéré hein ! On a retrouvé des trucs... dingue ! Bref).

PS: la charpente était entièrement "à refaire" je le savais avant d'avoir acheté et c'était dans les devis (un des rares trucs que je n'aurai pas fait).

On entasse, on essaye de faire un "tri" l'air de rien, je me suis dit que c'était plus pratique pour plus tard quand faudra tout virer.

En même pas une semaine on avait tout pété et tout viré (quand il faut mettre des coups de massue y'a du monde, mais quand faut ramasser les gravats et les vider, y'a plus personne !)

Le système d'arrivé d'eau/évacuation est bien vieux et vraiment bizarre (pleins de tuyaux d'évacs, certains semblent condamnés, des gros, des petits).
Afin de minimiser les travaux et pas s'embarquer dans des trucs "trop gros" j'ai préféré tout garder tel quel et "on verra plus tard". Choix prudent vu que tout fonctionnait !

Entre temps je me suis décidé de faire un plancher entièrement en bois.
Au début je voulais faire un plancher chauffant, mais ça s'est avéré beaucoup plus cher que prévu, long à faire, puis le béton par-dessus le bois j'étais pas chaud et j'aime pas le gaz. Bref... Beaucoup de raisons du coup => bois avec isolation en dessous.

Et voilà l'intérieur de la maison "tout détruit" qui se transforme en entrepôt du coup:

Une autre vue où l'on voit les anciens câbles électrique que l'on a "enlevé".

Et pour l'occasion on s'était marré à faire un petit "concours" de destruction. Une bonne égalité avec deux techniques bien différentes 😂 l'occasion de se marrer un peu aussi.

Dans l'étape suivante, on continue le démontage/destruction et on commence le plancher et d'autres petites choses.

Petit teaser ! 😆

Vous vous demandez comment fonctionne mon serveur ?
Vous cherchez des réponses pour faire le vôtre ?
Vous êtes juste curieux ?

Dans cet article je vais vous dévoiler comment j'ai conçu "l'architecture" de mes serveurs pour Hexamaster. Un jeu que je voulais "au départ" concentré sur le multijoueur.

Avant d'entrer dans "ma techno" je vais un peu parler de l'état de l'art sur le marché du jeu vidéo.

PS: Cet article contiendra beaucoup de termes techniques de différents milieux, je ferais mon possible pour essayer de traduire ça !

Dans le monde du jeu vidéo

Qui dit multijoueur dis plusieurs personnes en même temps.
De ce fait on a plusieurs façons de voir et prévoir les choses:

• on fait le truc le plus simple/léger/pas cher possible et puis quand ça va plus on essaye d'améliorer ça
• on prévoit un ensemble robuste, voir on prévoit "le buzz"

Pour avoir une comparaison simple, pour le jeu PUBG ils ont choisi la méthode 1, le succès du jeu les as dépassés et depuis le début leurs serveurs croulent sous la quantité de joueurs (aujourd'hui ça va mieux, mais ils perdent des joueurs aussi donc est-ce que les serveurs sont aujourd'hui suffisant pour le monde qu'il y avait l'an dernier ? On ne le saura sans doute jamais).

Et prenons donc l'opposé: Fortnite (qui ont probablement profité de la hype de PUBG pour se "douter" du monde qu'ils auraient) qui lui a eu bien moins de problèmes.

Ok donc quand on "m'entends" parler il n'y a "que des problèmes avec les serveurs". Oui c'est vrai.
Quand un jeu rencontre un gros succès, les serveurs sont rarement capables d'amortir le choc, des fois un petit peu, mais souvent pas assez.

Et pour causes plusieurs raisons je pense :

• manque d'expérience des programmeurs serveurs
• méthodes de réalisation des serveurs trop "basique" (1 serveur pour X joueurs)
• pas de scaling dynamique (architecture beaucoup plus complexe à mettre en place pour un jeu temps-réel)
• pas de monitoring suffisant donc zéro anticipation

Pour faire plus simple, je dirais que l'industrie du jeu vidéo n'est pas assez "à la page" question technos serveurs.
On a amélioré sans cesse nos méthodes de productions de rendering, mais question "comment faire un serveur" ça n'a pas bougé (presque pas) alors que les technos elles, sont là ! (queueing, dockerisation, micro services).

Je ne dis pas que tout est simple au contraire même, les serveurs c'est probablement le truc le plus "hypothétique" qui soit.

Et pour causes, beaucoup de problèmes peuvent apparaîtres:

• serveur qui crash
• base de données qui crash
• connexion de l'utilisateur instable
• connexion de l'utilisateur qui plante
• utilisateur qui tente une action plein de fois
• 10 utilisateurs qui tentent une action en groupe plein de fois
• trop de personnes qui demandent à se connecter d'un coup
• etc..

Bref, faire un serveur indestructible semble (est, soyons honnêtes) impossible.
Mais une chose est certaine à mes yeux, c'est que les efforts mis en place par les équipes pour faire des serveurs robustes sont bien trop faibles.

En tout cas, en ce qui concerne les jeux PC "mainstream". (car aussi étonnant que cela puisse paraître, pleins de jeux indépendant ou de jeux mobiles se portent très bien et n'accusent pas autant de lacune sur les serveurs).

Lexique

Un lexique s'impose pour être certain de comprendre la suite.

• quand on dit "serveur" ou "serveur de jeu" on parle du serveur qui exécute le serveur du jeu, avec les algorithmes, la logique du jeu etc...
• serveur de queuing (ou message broker): un serveur qui récupère des messages et les redistribues ou génère des files d'attentes en attendant que d'autres serveurs les récupères
• serveur de base de donnée: permet de stocker des données plus ou moins complexes, de manière durable et sécurisée
• serveur clé valeur: un serveur de base de données très simples qui ne peut stocker qu'une faible valeur, généralement destiné à faire transiter une information très rapidement
• clustering: le fait de pouvoir instancier plusieurs fois le même serveur (on en fait des clones) qui travaillent tous de paires
• scaling: le fait d'augmenter le nombre de serveur
• micro-service: le fait de faire plusieurs serveurs de jeu qui traiteront chacun un aspect différent (l'opposé à cette méthode est le monolithe, on fait un serveur qui fait tout)

Les serveurs de Hexamaster

Maintenant que vous avez un peu une vision d'ensemble je vais vous détailler comment j'ai fait mes serveurs.

Alors, déjà j'ai dit "mes", je ne fais donc pas un serveur monolithe non-clusterisé non-scalable (comment ça j'ai abusé sur cette phrase ? 😂)

Sachant que ma communauté "déjà existante" est pas très grande, j'aurai tout à fait pu faire "un serveur pourri", cela serait resté cohérent et "fiable".

Mais après l'expérience "Pokewebgo" (et le serveur qui crash 4h après sont lancement), j'ai voulu taper le plus haut possible dans ce que je pouvais faire niveau architecture et technique.

Bien entendu, rien ne me garantit que mon travail aura été "utile" si on a aucun/peu de joueur (ce qui est le cas jusqu'à présent, mais le jeu n'est pas fini donc...pas d'pression).

Je me suis donc penché sur plusieurs idées, pour créer une puissante architecture serveur scalable à souhait et en temps réel (voir automatique en suivant l'affluence de joueur).
Et j'en suis donc venu à une idée que j'avais eue auparavant, faire une architecture micro-service, scalable, avec un serveur central de base de données et un cluster de serveurs clés/valeurs + broker.

Ce qui donne au minimum:

• 6 serveurs NodeJS (serveur de jeu en micro-service)
• 1 serveur MongoDB (base de données)
• 1 serveur Redis (serveur clé/valeur + message broker)

J'ai précisé au minimum puisque tout est scalable.

Voilà un petit schéma des serveurs pour rendre tout ce tralala plus comestible:

Ce qu'il faut comprendre, c'est que chaque serveur est libre de discuter avec Mongo (la base de données) ou Redis quand ça lui chante !
Le truc c'est de réussir à "contraindre" chaque service à un type de donnée afin d'éviter les éventuels conflits (ce qui se solderait par une perte d'objets par exemple, pour le joueur).

Voilà maintenant un exemple de quel bouton fonctionne avec quel serveur dans le jeu (ce n'est pas tout à fait ça mais c'est pour "illustrer"). De cette manière, chaque interaction concernant l'inventaire, appellera le service "inventory". Le Matchmaking quand on veut jouer en ligne contre quelqu'un, le solo lorsqu'on joue seul, etc...

Vous remarquerez que sur mon dernier schéma on ne voit ni le serveur "authentification" ni "Versus" et c'est normal, l'authentification n'est appelé que lors de la connexion/déconnexion (en gros) et le versus est appelé par Matchmaking qui vous fait transiter une fois la partie prête !

De son côté, Redis s'occupe de sauvegarder les informations des parties en cours et des personnes connectés. Redis assure aussi l'échange de messages entres plusieurs instances de serveurs soit le schéma suivant:
Traduction: le serveur A dit à Redis "jouer la carte sur la case 1", Redis transmet le message à tout le monde, tout le monde exécute "jouer la carte sur la case 1".

Cela se traduit par les avantages suivants:

• si le serveur d'authentification plante, tous les joueurs déjà connectés pourront continuer de jouer sans aucun problème
• si le serveur "matchmaking" plante, uniquement les joueurs voulant lancer une partie en ligne seront impactés
• si le serveur shop plante, les achats seront impossibles
• etc...

Sans oublier que:

• chaque serveur peut se répliquer à l'infini, donc seul les joueurs d'une instance d'un serveur seront impactés en cas de crash

Et là ça change tout.
On reprend notre précédent schéma et on y ajoute le joueur Toto qui joue sur le serveur A, contre Tata sur le serveur C.

Le serveur B plante pour une raison inconnue, Toto et Tata ne sont pas impactés car ils n'ont pas à se soucier des autres serveurs.

Le serveur A ou C plante, Toto et Tata sont impactés
Mais si Toto jouait sur le serveur B, il n'y aurait pas eu de problèmes.

Côté code, ce qu'il faut retenir c'est que j'ai 6 serveurs différents.
D'un côté c'est bien car j'ai moins de choses par projet et c'est plus facile à déboguer (si l'inventaire plante je vais pas chercher dans le matchmaking !)
D'un autre côté je suis obligé d'avoir des doublons de code (problème que j'ai résolu en faisant une dépendance commune à tous mes serveurs) et de lancer une myriade de serveurs pour tout tester !

Cf une photo avec tous les serveurs de lancés

J'oubliais presque de parler de l'hébergement.
Il va s'en dire que des serveurs "micro-services" c'est plus compliqué à héberger quand les besoins du jeu sont petits.
On ne ressent la puissance de cette architecture que lorsque des centaines, des milliers même ! De joueurs se connectent en même temps pour "la première fois".

Dans mon cas de figure j'utilise "scalingo", l'avantage c'est que c'est "tout fait" facile à utiliser et puissant.
Maintenant il est clair que pour lancer son prototype a 6 serveurs ce ne sera pas cadeau (le total des serveurs me coûte env 90€/m lorsque tout est lancé, heureusement on peut très facilement les éteindre et ainsi réduire sa facture).

Peut-être un "kimsufi" sera largement suffisant pour mener vos tests, mais le moment venu ne lésignez pas et choisissez bien !

Pour conclure cet article, comprenez que si vous arrivez à faire des serveurs "micro-services" cela pourra avoir un gros impact positif sur votre jeu.
Vous n'impacterez pas tous vos joueurs pour le moindre petit problème et en plus il sera plus facile de traquer et patcher l'origine d'un problème.

J'aurai pu rentrer dans la technique pure, dans le code, mais je pense que je me serais éloigné du sujet et que cet article aurait été moins accessible et qu'il n'aurait pas vraiment traité le sujet critique "l'architecture".

Si vous savez coder il vous sera assez facile de trouver de la documentation avec les termes que j'ai utilisés ici, de trouver des exemples et de mettre ça en pratique !

J'espère que cet article vous a plu et que vous avez appris des choses.
Peut-être un article plus technique la prochaine fois ?

En Mars 2018 j'ai eu une mésaventure avec mon Jeep Cherokee (un "vieux" de 1999).

La boîte de transfert a éclaté sur l'autoroute (la boîte de transfert c'est le truc juste après la boîte de vitesse qui permet entre autre, d'envoyer la puissance à l'avant et à l'arrière du véhicule quand c'est un 4x4).

Face au prix des boîtes de transfert j'ai acheté un Jeep "pour pièce" (bien moins cher au final surtout que j'avais besoin de plusieurs choses).

Mais voilà une fois que j'avais récupéré les quelques pièces pour remettre le mien en état, il me restait quand même une voiture quasi complète.

Donc je me suis dit que plutôt que de jeter la carcasse j'allais m'amuser avec 😄.

Quelle mouche m'a piqué vont se dire certain. Un Jeep c'est fait pour aller dans la forêt pas pour faire de la fumée (cela viendra aussi). Réponse courte: parce que.

Et je suis certain que le résultat final en surprendra plus d'un 😉.

Voilà la "bête" d'origine.

Les spécs technique du bouzin :

• c'est un Jeep Cherokee XJ de 1991
• moteur 4L 6 cylindres (atmosphérique donc pas de turbo)
• il a environ 150.000 au compteur
• le moteur fait 190cv d'origine avec un très gros couple
• la zone rouge est à 5600 environ (mais une fois qu'on a passé les 4600 ce n'est plus très intéressant)
• il fait 1500Kg d'origine

Le but premier est de faire une version "fonctionnelle et le moins cher possible", afin de valider le concept et le potentiel.

On commence donc par les trains roulants en descendant le Jeep au maximum et en trouvant les meilleurs réglages (empattement, cambre, angle max).

Quelques photos de repérage.
Pont avant Pont arrière Pont avant démonté, yay Pont arrière aussi ^-^

On a ensuite pris une journée pour commencer la partie "technique".
Comprendre, découper, modifier, re-souder tout ça.

D'abord, le pont arrière

Quelques explications. Sur le Cherokee "XJ" à l'arrière c'est des suspensions à lames, l'axe (le pont) est accroché en dessous des lames.
En mettant le pont au-dessus des lames on baise donc la garde au sol de l'épaisseur du pont.

Schéma explicatif:

On commence donc par cette première modification afin de voir jusqu'où ça descend.

Voilà 2 photos une fois que l'on avait fini de découper le support de suspension et le support de pont. C'était long, mais cette étape demande d'être précis !
le pont avec les éléments enlevé, tout propre (enfin presque).
Et là le support de suspension découpé

Il manque la photo du support "plat" mais c'est dans la même idée.
Donc ensuite, on a retourné le pont et on a re-soudé les supports (upside down quoi).
Voilà ce que ça donne une fois remonté sur Smokey.

Cette "simple" modif nous à fait descendre le Jeep de 20cm env, mais on peut aller plus bas encore !

V1 de l'arrière c'est fait, on tentera de descendre encore plus en ajoutant des "cales" en acier.

Maintenant, le pont avant

On a commencé par couper les extrémités du pont, juste avant les supports de roues.
De cette manière on élargit ce qui nous permet d'augmenter l'angle des roues et on peut aussi régler la cambre (ce n'est pas réglable par défaut sur un Cherokee).

Et on prend un autre tube d'acier de même épaisseur mais diamètre plus petit pour l'extension. ça passe bien, du coup on nettoie impec l'extension et on la met dans le support de roue avec des points de soudures pour que ça tienne

Et maintenant on plug les deux, boum.

On vient de gagner 10cm de chaque côté à l'avant, yeah.

Une curieuse !

Bon maintenant on coupe les amortisseurs pour faire descendre tout ça (ouaip comme des bourrins).

Et voilà ce que ça donne une fois "descendu"

On a aussi enlevé tout ce qui pouvait être enlevé afin de maximiser ce qu'on appel le "angle lock" (soit l'angle maximum de rotation des roues, c'est mieux pour drift).
Voilà la photo du rendu (je mettrais des photos du taff fait quand on re-démontera car j'ai oublié d'en prendre -_- ).
Au début on avait 38°, maintenant on a 62° !! (mais sans les étrier de freins, on va trouver un truc 😅)

Là on voit bien le taff !

C'est tout pour cette première "grosse" étape.
Relativement intéressante pour nous, mais pas encore impressionnante.
On a du taff encore !

Prochainement donc (pas forcément dans cet ordre là):

• re-démontage des ponts et finalisation des renforts et soudures (temporaires là)
• supression du différentiel avant
• descendre encore plus !
• démontage de la boîte à vitesse et fix (car elle a une fuite)
• conception d'un arbre de transmission pour bypasser la boite de transfert
• barre stabilisatrice av/arr
• création d'une "trackbar" à l'arrière pour renforcer la tenue du pont
• frein à main hydraulique
• test !
• préparation moteur (une fois les tests validés)

Tout commence en mai 2017, à défaut d'avoir un gros budget mais désirant une maison avec jardin je me suis lancé dans la rénovation d'une vieille baraque.

Je savais un peu bricoler 2-3 choses (bois et mécanique en fait) et je suis plutôt débrouillard, créatif, curieux, motivé et je n'ai pas peur de l'échec ! (les 2 derniers points étant indispensable 😉).

Après 1 an je me suis décidé à tout raconter (je n'ai pas encore fini), cela va être fastidieux mais je vais tenter de faire le plus de chapitre possible afin de rentrer dans le détail et si possible dans l'ordre (cependant je mettrais des warnings sur mes échecs afin que vous ne vous lanciez pas les yeux fermés en prenant comme source un échec ^^).

Aussi, ne vous lancez pas dans un projet comme cela si vous êtes vraiment seul. Avant de signer j'ai demandé a mon frère et a des amis de me "jurer" qu'ils m'aideraient (au moins un peu) sans quoi je n'aurai jamais eu le cran d'y aller tout seul (surtout que certaines choses sont infaisables seul).

Cela ne veut pas dire que vous aurez tout le temps quelqu'un avec vous bien sûr et donc plusieurs fois vous vous retrouverez seul sur des étapes plutôt balèzes mais c'est surmontable.

L'image d'en tête est la maison dans son état initial.

Là voilà de dos:

Lors de la visite, il faut faire en sorte de prendre en compte le max de choses, bien analyser la maison et ce qui est déjà présent.

Le prix est à négocier bien entendu, mais cela dépendra du secteur où vous habitez. Par chez nous sur Toulouse ce genre de bien est vendu en une semaine, voir deux max. Donc il faut aller très vite et ça rend la décision plus difficile.

Regardez sur internet combien coûte chaque chose avant de faire des visites, comme une salle de bain (aka sdb) ou une cuisine, du carrelage, une chaudière etc...

De cette manière au moment de la visite vous saurez vite capable de mettre des chiffres par-ci par là vous évitant de faire une propositions trop foireuse.

(yaaaaay les clééés)

Après vous être décidé vous devez chiffrer combien vous allez dépenser en plus "réel" (en fonction de vos revenus et du temps que vous souhaitez y consacrer vous pourrez vous permettre d'être plus ou moins précis ou de diluer dans le temps. Moi je me suis concentré sur le chiffrage de "l'essentiel pour vivre" au début, le reste je le ferai quand je peux tranquille).

Pour chiffrer il faut aussi savoir ce que l'on va faire, il faut donc définir des plans !

De cette manière vous verrez vite ce que vous allez modifier ou ajouter.

Et j'en ai fait un paquet à ce moment-là !

Ce que l'on savait, c'est que l'on voulait agrandir.

Après divers devis on s'est rendu compte que l'on ne pourrait pas faire beaucoup de manière "classique" (~20m²).

Puis, j'ai eu "l'idée" (je l'ai pas inventée soit, mais ça m'est venu à l'esprit) de le faire avec des containers maritimes, ce qui nous a permis de passer a 90m² de plus en faisant des dépenses "sur la durée" (c'est plus cher au total, mais on peut faire petit à petit et le faire nous-mêmes, double bonus).

Si la partie "budget" (et crédits) vous intéresse ne vous en faites pas, j'ai prévu un article dédié, il y a tellement de choses à dire à ce sujet que ce serait bête de faire des raccourcis.

Revenons sur les plans. On savait que l'on allait utiliser des containers maritimes donc on connaissait les dimensions, cela facilite les choses, car il faut les emboîter de manière intelligente tout en respectant le PLU.

J'en ai tellement fait que j'ai même fait une "maquette" en Lego.

Faut dire, à force de faire des plans on ne se rend pas vraiment compte de si c'est bien ou pas, donc j'ai essayé de voir ce que cela donnait avec des petits bonhommes lol.

Ensuite, j'ai fait des plans 3D, j'ai galéré avec divers logiciels pour finalement trouver Sweet Home 3D qui est gratuit, open source et super bien ! (j'ai contaminé pas mal de gens qui étaient novices comme moi à ce niveau :D ).

Après donc beaaaaucoup de versions, j'arrive à ce résultat.

Vous noterez que je n'ai pas spécifié les fenêtres sur mon plan (cela ne m'étai pas vraiment utile).

Une grande cuisine (tout à gauche), une salle de bain correcte au centre (pour des raisons techniques, je ne me sentais pas de déplacer toutes les évacuations et j'avais raison !) un WC dédié, 3 chambres et un grand garage, le garage existant sera converti en habitation (on verra bien quoi ^^).

Comme on a fait un crédit à taux zéro il nous fallait un devis global, j'ai donc fait appel à un charpentier (une connaissance indirecte, c'est préférable je trouve, car on ne sait pas sur qui on va tomber sinon...) en lui expliquant ce que l'on voulait.

Entre temps on s'était décidé pour les containers (le devis de base nous a montré à quel point les choses sont "cher") donc je lui ai expliqué mais j'ai gardé le devis pour simplifier le dossier auprès de la banque (croyez-moi c'est mieux, mais on en reparlera dans l'article dédié).

Afin de valider certains trucs technique au niveau des container je me renseigne quand même auprès de mon charpentier sur la réalisation d'une isolation toiture plate, je savais que j'allais utiliser de l'epdm (un truc pas trop connu est super par rapport au goudron) mais il me manquait les connaissances du genre "acrotère" et taille d'isolant idéal.

PS : notez la petite coquille, j'ai mis 20mm. En vrai c'est 20cm mais on parle en mm dans la construction donc j'aurais dû mettre 200mm !

Le plan est good, on valide avec une architecte qui s'occupe du permis de construire et nous on peut attaquer les travaux une fois les clés en main !

Concernant l'architecte. Déposer un permis de construire c'est vraiment quelque chose de lourd comparé à une déclaration préalable, j'ai préféré le faire faire surtout qu'elle a pris le temps de voir avec l'architecte de la ville afin de tout valider à l'oral avant de faire le dossier.

Ce serait dommage de perdre 3 mois car on s'est planté sur une bêtise et c'est toujours bien de recevoir l'avis d'un(e) pro sur notre projet.

La suite ? On y parlera de destruction, le truc que tout le monde préfère ! (bizarrement 😜)

Voilà un petit teaser!

Mais, mais ?? Qu'est-ce donc que cet endroit ?

Après un bon moment à en parler (plus ou moins) à hésiter (beaucoup) ça y est, je me lance 😆

Sur ce "blog" (payes ton mot internet 2.0 lol) je parlerai d'un peu de tout (cf la page "à propos").

Je vais faire en sorte d'être régulier, l'idéal serait au minimum 1 article par semaine histoire de commencer avec un objectif réalisable.

On parle de quoi ici ? De pleins de choses.

• 🏠 tout d'abord de la maison que je rénove depuis 1 an
• 🎮 du développement informatique (surtout de jeux)
• 🚙 de voitures (souvent mécanique 🔧)
• d'autres trucs divers genre cosplay 🎭 ou diy 🔨

Varié vous avez dit ? A peine.

Ce qui est sûr c'est que ce sera souvent stupide et donc, vital !
Si tu ne veux rien rater alors abonnes toi !

D'ici là, t'as qu'à tester ce jeu super débile ou quelques-uns de mes jeux sur mon site inateno.com ;)