Première vue globale de la roulotte

Quelques premières captures offrant une vue globale de ce à quoi devrait ressembler la roulotte.

Vue médiane face / côté

Vue face

Vue médiane en élévation

Modélisation des essieux

Les essieux sont en métal plein section carrée de 35 mm, avec un décrochement au bout, certainement pour accueillir une tête de vis plate, de façon à fixer l’écart de roues lorsque la moissonneuse-lieuse passait sur route et que les utilisateurs remettaient en place les roues métalliques.

Essieu

Je profite de cette session pour élargir la roulotte à 2,20 m intérieur comme prévu. Le précédent modèle comptait deux mètres hors tout, ce qui, après la mise en place des cloisons isolées, n’aurait pas été suffisant pour mettre un lit de coin à l’intérieur. Pour les cloisons, je pense faire des sandwiches avec un centimètre de tripli ou de contreplaqué marine de chaque côté et du chanvre pressé en deux plaques de 40 croisées à l’intérieur. Donc, 10 centimètres de murs, et une largeur hors tout de 2,40 environ.

Vue d'ensemble, avec les proportions modifiées

Je viens de me rendre compte que j’ai oublié la margelle. A suivre, donc…

Définition du projet de roulotte

Bon, la décision a été prise il y a quelque temps déjà : la rénovation de la maison étant finie à 99%, je vais m’attaquer à la construction d’une roulotte. Le but : satisfaire un rêve d’enfance de ma femme, et d’une pierre deux coups, celui de ma fille…

Je pars sur une roulotte d’à peu près 8 m² : 2,20 x 4 m en intérieur. On a vu quelques livres sur la question, ainsi que des sites, mais rien avec des plans, ou alors payants. Bref, autant faire moi-même. Par contre, certaines parties seront beaucoup plus faciles à trouver en brocante ou en casse qu’à créer de zéro. Exemple : les roues. Ca tombe bien, nous avons trouvé dans un vieux hangar du père d’une amie, en Ariège, des roues qui étaient destinées à la ferraille. Il s’agit des essieux et roues mobiles d’une ancienne moissonneuse-lieuse. Elles servaient lorsque la machine rejoignait la route. Elles sont en excellent état, et leur ancien propriétaire, en plus de nous les donner, nous les garantit pour 200 ans, puis se ravise pour 100 ans seulement, vu qu’elles seront en Bretagne Je le rassure en lui expliquant qu’elles ne seront pas au contact direct du sol humide, mais sur plaques de bois ou parpaings.

Les roues sont modélisés en 3D pour voir la proportion de l’ensemble.

Roue métallique de moissonneuse-lieuse

Pour le chassis, je pars sur un assemblage quadrillé en bois, apparemment assez classique pour ce genre de construction. Les montants principaux seront assemblés directement sur les bastaings dans les deux sens, pour améliorer la rigidité.

Base du chassis

A priori, les montants seraient en 63×75, et les bastaings à plat en section 63×175. Il faudra que je calcule en gros le poids total à supporter, mais vues les dimensions réduites, 5 sections devraient être largement suffisantes.

Pour le toit, on va certainement faire avec du zinc cambré et rabouté par compression. Mais il serait peut-être intéressant de laisser une circulation d’air juste en dessous du métal, pour mieux isoler pendant l’été. Le but étant plus de faire une sorte de cabane pour les enfants, la roulotte sera utilisée le plus souvent pendant l’été, alors je vais isoler costaud.

La place dans le jardin est déjà trouvée : un peu d’ombre d’un noisetier et d’un prunier, juste à côté de la balançoire pour prendre le goûter et vite retourner au jardin

Pour les cloisons, je pense faire des assemblages en sandwich avec un tripli, de l’isolant et un contreplaqué marine pour l’extérieur. Pour la partie décorative, il va falloir chercher du bardage avec un bois imputrescible. Je ferais bien en Acacia si on en trouve, mais du châtaignier ou du Douglas feront aussi bien l’affaire. Et pour l’intérieur, du lambris, et si possible du beau bois pour le parquet…

Pour l’aménagement, ma femme se charge de tout : le lit de coin est déjà rénové, une petite table en acajou chinée, des coussins et tentures de toutes les couleurs apprêtés. Bref, c’est moi qu’on attend, donc je retourne à mes plans !

Enfin les vacances !

Comment peut-on mieux passer ses vacances qu’en rando en montagne, surtout quand on peut ensuite se reposer dans une maison avec piscine et des hôtes charmants ?

Le mode d’emploi est le suivant… Première journée : monter peinard au refuge. Se faire un petit bain dans un lac de montagne pour activer la circulation et ne pas avoir d’ampoules.

Lac de montagne, en bas du Montcalm

Arriver juste avant l’orage de grêle. Trouver le moyen de se faire tout de même rincer en prenant un café au bord du lac. Patienter dans le refuge. A la fin de l’orage, se dire qu’il est tôt et que ça serait mieux de monter encore pour être plus proche des sommets demain. Se rendre compte que, de toute façon, on n’a pas le choix vu que le refuge est complet.

Après 1200 mètres de dénivellé pour la journée (340 m/h), planter de tente au bord d’un lac, juste avant le deuxième orage. Patienter dans la tente en mangeant des craquottes. A 21h30, l’orage nous accordant un répit, sortir préparer à manger à la lampe frontale.

La cuisine à 2600 mètres d'altitude

S’écrouler de sommeil…

Le lendemain, heureusement, le temps est idéal. On attaque ‘à la citadine’, c’est-à-dire à 7h30 du matin (pour ceux qui ne connaissent pas du tout la montagne, c’est TRES tard). Le campement étant à 2600 mètres, on monte directement au Pic Sutlot à 3073 m. Certains passages sont scabreux, mais finalement, on aura passé toute la journée sans avoir besoin de sortir les crampons.

On est encore en GR !

On grimpe, avec relativement peu de névés, mais pas mal de roche roulante et de terre. Vue la pente, il faut mettre les mains par endroit. Le fait de voir le pic de loin est par contre très motivant. Il n’y a pas un atome de brouillard, ni même un nuage.

Le Pic Sutlot... de tout en bas

Les 200 derniers mètres sont assez sport, et nous raccompagnerons en descente une Espagnole qui a réussi à monter, mais que le retour effrayait. Esprit chevaleresque dont nous serons malheureusement payés en retour par une suspicion moqueuse de la part de nos épouses

Vu que nous sommes en forme et qu’il est tôt, on redescend au col et on attaque le Montcalm à 3077 m. Montée super simple, aucune difficulté. Et on se dit alors “autant en profiter pour aller au Verdaguer”. Bref, remontée à 3125 m, pas beaucoup plus technique… Par contre, on a une superbe vue sur le Sutlot :

Le Pic Sutlot, vu du Verdaguer

Là où on a par contre été un peu (trop) optimiste, c’est que, sachant qu’on devait redescendre au parking (à 1200 m d’altitude) pour la fin de la journée, on n’aurait peut-être pas du faire le Pic d’Estat en plus (3143 m). Mais bon, on était chauds, et on est donc arrivés au plus haut de notre rando.

Sommet du Pic d'Estat

Le temps d’une petite photo, et il faut désormais bourrer pour se faire les 1250 mètres de dénivellé négatif. On le fera à la moyenne record de 430 m/h, mais avec les jambes explosées en bas… Je suis marathonien et j’ai souvent fait des grosses randos à vélo (180 kms/jour), mais je crois pouvoir dire que je n’ai jamais été aussi épuisé qu’après ces trois heures de descente à fond. Sauf, bien sûr, après les 38 kms de VTT du lendemain. Mais comme dirait ma femme, “t’étais pas obligé”…

Reste le plaisir de ces incroyables paysages, et d’avoir réussi la passe de quatre (4 sommets de plus de 3000 mètres dans la même journée) . Merci, Yves, pour ce super parcours, et à l’année prochaine !

Mise à jour des librairies pour FOP en .NET

Suite à une demande dans les commentaires d’un précédent article, voici les librairies compilées en .NET pour faire du XSL/FO par interop avec IKVM. J’en profite pour passer aux nouvelles versions de FOP (0.95) et d’IKVM (0.40.0.1).

Le tout a été buildé sur la base d’une VM 1.6.0_13-b03, et sans clé de nom fort.

Voici le lien. Si vous utilisez ces librairies, merci de m’envoyer un petit message sur votre retour d’expérience, satisfaisant ou pas.

Tant que j’y suis… Cette méthode est manuelle, et ne sélectionne pas les classes utilisées pour la compilation par IKVM. Si vous voulez seulement faire du XSLFO, vous pouvez utiliser également le projet NFOP. D’après ce que j’ai compris, ce n’est pas un portage de FOP en .NET, mais plutôt la même chose que ce que j’ai détaillé dans le post sur XSL/FO en .NET, à savoir une recompilation. Par contre, ils font bien sûr beaucoup mieux les choses, et en particulier, ils doivent filtrer les classes nécessaires lorsqu’ils compilent les JAR de dépendances, ce qui fait que le résultat est bien plus léger. Je vais tester si il n’y a pas autre chose, et je posterai mes remarques dans quelque temps.

Programmation parallèle en .NET

Un petit test de la parallélisation en .NET, avec la CTP de Juin 2008 des Parallel Extensions.

A utiliser, c’est très simple : on utilise une nouvelle librairie System.Threading, qui rajoute des opérateurs parallélisés ainsi que des listes supportant la parallélisation.

Voici un petit bout de code pour tester sur un AMD 64X2 4400+, avec donc deux coeurs :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Threading;

namespace TestParallelisation
{
 class Program
 {
  static void Main(string[] args)
  {
   List<int> Entiers = new List<int>();

   for (int ind = 100000; ind < 120000; ind++)
    Entiers.Add(ind); Stopwatch Chrono = Stopwatch.StartNew();
   List<int> Premiers = new List<int>();

   foreach (int Entier in Entiers)
    if (EstPremier(Entier))
     Premiers.Add(Entier);
   Console.WriteLine("{0} premiers trouvés en {1} ms", Premiers.Count, Chrono.Elapsed.Milliseconds);

   Chrono = Stopwatch.StartNew();
   List<int> PremiersSynchro = new List<int>();
   Parallel.ForEach<int>(Entiers, i => { if (EstPremier(i)) PremiersSynchro.Add(i); });
   Console.WriteLine("{0} premiers trouvés en {1} ms", PremiersSynchro.Count, Chrono.Elapsed.Milliseconds);
  }

  private static bool EstPremier(int Nombre)
  {
   for (int ind = 2; ind < Nombre - 1; ind++)
    if (Nombre % ind == 0)
     return false;
   return true;
  }
 }
}

On voit qu’on cherche la liste des nombres premiers entre 100 000 et 120 000, avec une première version standard, et qui s’exécutera donc sur un seul core, et une seconde permettant la parallélisation. Ici, rien de compliqué puisque chaque nombre est traité séparément, donc c’est très simple de répartir sur autant de processeurs que nécessaire.

Les résultats : 539 ms en mono-core, 388 ms en parallèle sur deux cores. Une amélioration de performance d’environ 30%, en informatique, c’est déjà pas mal… Et imaginez sur un octo-core. Les résultats varient un peu en fonction du temps, mais on a une bonne idée du ratio sur ce type d’algo.

Toutefois, un bug est présent dans ce code : on écrit les résultats dans une liste d’entiers, et le multithread peut faire que les résultats sont écrits en même temps, résultant en des écrasements, que j’ai pu constater sur un test avec un résultat de référence de 1709 entiers premiers, et 1708 seulement sur le deuxième.

Le premier réflexe est de créer plusieurs listes et de les grouper à la fin, mais comment faire quand on n’a pas la main sur le nombre de threads ? Après recherche sur internet, il se trouve que Microsoft a tout prévu. Au lieu d’utiliser des listes génériques, il faut utiliser System.Threading.BlockingCollection<T>, qui est faite spécialement pour ça…

Bref, un premier essai convaincant !

Le chou fractal… suite

Je ne suis visiblement pas le seul à être étonné par cette organisation fractale des branches de chou…

http://www.psy.ritsumei.ac.jp/~akitaoka/machika4e.html

Le chou fractal

En tant qu’ancien élève d’Andreï Kirilov à l’Université de Pennsylvanie (MATH 480 : fractal geometrics), je me suis extasié sur le chou fractal que j’ai trouvé cette semaine dans mon panier de légumes… Bon, le vrai nom est tout simplement un chou Romanesco. Mais je vous laisse regarder les photos pour vous faire votre propre conviction : l’agencement des picots sur le chou suit effectivement une organisation fractale.

Chou Romanesco - Vue globale

La spirale qu’on observe sur l’ensemble ci-dessous peut être retrouvée à une échelle inférieure :

Alignement des cônes au niveau global

En effet, si on zoome sur la portion suivante de l’image

Définition d'un cône en particulier

on retrouve une organisation similaire de spirales

Vue détaillée du cône sélectionné

Et si on regarde bien chacun des picots, on retrouve à nouveau la même organisation sur chacun. C’est le principe d’autosimilarité, ce qui fait le propre de la fractale. La géométrie fractale se retrouve dans de nombreux phénomènes naturels (découpe des côtes, structure interne des poumons, etc.), mais elle est rarement aussi nettement visible qu’ici…

Exercice supplémentaire pour les courageux : calculer la dimension fractale du chou Romanesco !

UI Automation : le framework

J’ai finalement fait beaucoup plus vite que je ne pensais pour créer une première version de ce que je voudrais voir devenir une grammaire XML spécialisée dans le test des interfaces graphiques, et un moteur d’exécution de ces tests basé sur UI Automation Framework.

Miboboio m’a donné la solution pour gérer du texte, j’ai trouvé comment régler le problème des fenêtres principales qui changent (typiquement quand on a une fenêtre de login qui s’efface pour laisser la place à une fenêtre principale), et le reste était relativement simple.

Bon, ce n’est vraiment qu’un prototype pour l’instant, mais j’ai quand même créé un projet sur CodePlex. Vous pouvez aller voir sur http://www.codeplex.com/uiautotestxml pour plus de détails, et tester la release 0.1. J’ai mis deux exemples de scenario XML de test. Un qui pilote la calculatrice :

<?xml version="1.0" encoding="utf-8" ?>
<scenario>
 <application path="calc.exe">
  <launchWaitTimeout>2000</launchWaitTimeout>
 </application>
 <actions>
  <setText target="403" value="123"/>
  <buttonClick target="92" waitForAction="100"/>
  <setText target="403" value="456"/>
  <buttonClick target="112" waitForAction="100"/>
  <checkText target="403" value="579, " errMsg="Mauvais calcul"/>
 </actions>
</scenario>

Un autre qui pilote une application de test que j’ai montée pour l’occasion, afin de tester la prise en compte du changement de fenêtre active :

<?xml version="1.0" encoding="utf-8" ?>
<scenario>
 <application path="UIAutoTest.TestTargetApp.exe">
  <launchWaitTimeout>2000</launchWaitTimeout>
 </application>
 <actions>
  <clearText target="txtPassword"/>
  <setText target="txtPassword" value="coucou"/>
	<linkClick target="linkLabel1" waitForAction="100"/>
  <formSwitch/>
  <checkLabel target="lblLogUser" value="User72" errMsg="Problem with the login"/>
 </actions>
</scenario>

A priori, la grammaire doit parler d’elle-même, et sinon rendez-vous sur le site pour plus de détails. Merci par avance de vos commentaires et remarques sur ce qu’il manque pour que ça puisse servir.

IKVM et FOP

SI vous avez lu mon premier post sur l’utilisation d’Apache FOP en .NET par interop IKVM, vous serez peut-être intéressés de savoir que FOP 0.95 est sorti en version finale, et que les tests d’interop sont concluants.

En tout cas, pas de problème de mise à niveau sur les quelques XSL-FO testé…