Web 3.0

Juste pour rire, peut-être que ce sera la nouvelle désignation marketing pour ce genre de technologie ayant trait au web, je veux parler des nano serveurs.

De quoi s'agit-il ?

En fait l'objectif est d'embarquer dans un objet quelconque un serveur web complet, pour faire de la gestion d'automatisme par exemple. Cela peut aussi servir à créer des objets pour geek.

On peut trouver sur le web de nombreuses expérimentations là dessus. Les techno employés sont souvent à base de micro-controleur PIC car la société Microchip a publié les sources d'une pile IP pour ses processeurs.

Les plus élaborés contiennent une connection ethernet, les plus simple une liaison SLIP sur RS232 comme le webACE

Un autre, simple à cabler est le wwwpic2. Il est basé sur un PIC16F84.

On trouve aussi des variantes dotés d'un port ISA pour connecter une carte ethernet ou des cartes à base d'autres microcontroleurs.

Le système dans tout ça....surement pas de système multi-tâche 32 bits. Les processeurs PIC sont des processeurs 8 bits, le nano serveur historique était basé sur un 12C509, qui est un 8 bits à 4 mhz doté d'une mémoire programme de 1k mot....

Les langages de programmation utilisés sont souvent l'assembleur, parfois le C. Il esiste même une version version qui fonctionne sur une javacard

On trouve aussi des produits commerciaux comme la carte picoweb

Afficher la pile d'appel

Il est très informatif d'avoir en cas de problème la pile d'appel lié à une exception. En java elle est particulièrement détaillée et permet de repérer rapidement la source du bug. Par contre il est tout aussi interressant de l'avoir en cas de fonctionnement normal, pour savoir par exemple quel est l'origine d'un appel à une méthode qui est appelée par un grand nombre d'autres méthodes. Vous allez me dire, qu'il suffit de poser un point d'arrêt et le tour est joué....sauf que cela n'est pas toujours possible.

Voici une technique pour s'en passer. Elle se base sur le fait que la classe "Exception" a pour ancêtre "Throwable" qui n'est pas encore une exception, mais qui a le mérite de fournir toutes les informations nécessaires concernant la pile d'appel.

Voici un exemple simple :

public class Pile {

 private static void appel2(){
  Throwable th=new Throwable();
  th.printStackTrace();
 }
 
 private static void appel1(){
  appel2();
 }
 
 public static void main(String[] args) {
  appel1();
 }
 
}

qui retourne comme résultat :

java.lang.Throwable
 at Pile.appel2(Pile.java:5)
 at Pile.appel1(Pile.java:10)
 at Pile.main(Pile.java:14)

La méthode "printStackTrace()" est un affichage préformaté sur la console des informations de la pile d'appel. On peut bien sur récupérer auprès de l'objet "th" toutes les informations séparément.

CreateProcess en delphi

Le lancement d'un processus à partir d'une application delphi s'appuie sur l'api windows CreateProcess. En dehors de ça rien ne particulier, Delphi sait très bien gérer ce genre d'appel.

procedure Exec(exe : String);
var
  StartInfo  : TStartupInfo;
  ProcInfo   : TProcessInformation;
  CreateOK   : Boolean;
begin
  FillChar(StartInfo,SizeOf(TStartupInfo),#0);
  FillChar(ProcInfo,SizeOf(TProcessInformation),#0);
  StartInfo.cb := SizeOf(TStartupInfo);

  CreateOK := CreateProcess(PChar(exe),nil, nil, nil,False,
              CREATE_NEW_PROCESS_GROUP+NORMAL_PRIORITY_CLASS,
              nil, nil, StartInfo, ProcInfo);
end;

Create process en c#

Pour changer je vais faire une petite série "hello world" concernant uniquement le lancement de processus. Le premier de la série sera sous windows avec c#. Rien de bien magique, le framework dotnet fourni une classe "Process" qui permet de faire facilement ce genre d'opération.

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void exec(string exe)
        {
            System.Diagnostics.Process proc = new System.Diagnostics.Process();
            proc.EnableRaisingEvents = false;
            proc.StartInfo.FileName = exe;
            proc.Start();
        }

        static void Main(string[] args)
        {
            exec("calc");
        }
    }
}

Un singleton en Delphi

Le source suivant présente comment réaliser un objet singleton en Delphi. Lorsque l'on appel le constructeur d'un objet, le compilateur fait un appel à NewInstance pour récupérer un pointeur sur l'objet instancié. Dans le cas présent au premier appel on fait effectivement cet appel. Dans les cas suivant on retourne toujours la même instance.

unit uSingleton;

interface

type

  TSingleton=class
  public
    class function NewInstance: TObject; override;
  end;

implementation

var
  fSingleton:TSingleton;

{ TSingleton }

class function TSingleton.NewInstance: TObject;
begin
  if assigned(fSingleton) then
    result:=fSingleton
  else
  begin
    result:=inherited NewInstance;
    fSingleton:=TSingleton(result);
  end;
end;

end.

Phonétisation en java

Phonétisation en java

Les techniques de phonétisation sont nombreuses et posent de nombreux problèmes liés
aux différentes langues humaines. Les applications sont, quand à elles bien connues.
On peut citer la recherche documentaire, la synthèse vocale ou les applications d'analyse
de langage naturel.

Il existe, entre autre, trois algorithmes courant pour la phonétisation : le soundex,
le métaphone et le double métaphone. Le soundex est plutôt spécialisé pour l'anglais et
est issue de brevet déposés en 1918 et 1922.

Le métaphone a été conçue pour répondre aux limitations du soundex. Le double métaphone
est un perfectionnement du métaphone. Il est capable de travailler avec les langues slaves,
germaniques, celtiques, grec, français, Italien, espagnol et chinois entre autres.

Il existe une implémentation des ces algorithmes en java dans la librairie Apache commons.
Elle fait aussi partie du sdk Google Androïd.

Voici un petit exemple de programme java utilisant cette librairie. On se rend bien compte
que le résultat est encore approximatif. En effet il trouve que "bière" et "beer" se prononce
à peu près pareil, mais pas "fin" et "faim".

import org.apache.commons.codec.language.DoubleMetaphone;

public class Codec1 {

  public static void main(String[] args) {
      DoubleMetaphone dm=new DoubleMetaphone();
      System.out.println(dm.doubleMetaphone("bière"));     
      System.out.println(dm.doubleMetaphone("beer"));     
   
      System.out.println(dm.doubleMetaphone("faim",false));     
      System.out.println(dm.doubleMetaphone("fin",false));
   
  }
}

Hello World Ant

c'est pas le premier avril, mais j'ai pas pu résister à présenter ce script fort complexe, c'est pour ant et cela affiche "Hello World"....

<?xml version="1.0" encoding="UTF-8"?>
<project name="Hello World" default="hello" basedir=".">

    <target name="hello">
        <echo message="Hello World !" />
    </target>

</project>

Faites vos lampes triodes vous-même

Je suis tombé sur ce site par hazard et c'est le travail d'un très bon bricoleur. Un radio am qui se fabrique ses propres tubes.

Il présente une petite vidéo de 17minutes concernant sa fabrication.

F2FO

Vraiment impressionnant !

Hello world OpenGL

Voici un petit programme pour linux qui montre comment dessiner la théière de l'Utah. Il est remarquable de constater que de nombreuses API 3D ou applications de dessin 3D ont une primitive capable de dessiner cet objet de référence.

Pour linux il faut au préalable avoir installé la librairie glut.

Le source est très simple :

#include       

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
// on dessine une théière
glutWireTeapot(0.5);
}

int main(int argc, char** argv)
{
// initialisation
glutInit(&argc,argv);
// Initialisation de l'affichage et de la fenêtre
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
// définition du titre
glutCreateWindow("théière");
// la procédure d'affichage sera appelée en callback
glutDisplayFunc(display);
// on attend la fin
glutMainLoop();
}

pour la compilation il faut lancer la ligne suivante :

gcc -o teapot teapot.c -lglut -lGLU -lGL -lXmu -lXi -lXext -lX11 -lm

BumpTop

Il s'agit d'un nouveau style de bureau graphique. C'est en 3D et c'est joli. Par contre j'aimerais bien essayer pour voir si c'est vraiment pratique.

Pour plus d'info bumptop

Le protocole IP et la couche physique

Le protocole IP en tant que couche réseau ne définie pas de couche physique. En fait il est conçue pour pouvoir être monté sur toutes sorte de couches physiques : réseaux ethernet, modem, ATM, etc....

Il est alors tout à fait possible d'implémenter IP sur une couche physique composé de pigeons voyageurs, comme l'expose le RFC 1149.

Une implémentation de ce genre de réseau existe : http://www.blug.linux.no/rfc1149/ Les sources sont fournis.

wiimote

La console Nitendo Wii introduit une nouvelle forme d'interface homme/machine. Ce qui est très intérressant avec cette console est que sa manette, la wiimote, est dotée d'une interface Bluetooth, ce qui a permis à de nombreux développeurs d'expérimenter autour de cette technologie.

On peut par exemple visiter ce site, WiinRemote, qui explique comment connecter sa wiimote à un pc windows et développer des applications avec Delphi.

Une application originale est de transformer un habituel tableau blanc en tablette électronique.

Je ne sais pas si cela vous est arrivé au cours d'une réunion d'avoir fait un joli schéma sur un tableau blanc, mais cela est souvent dommage d'avoir à reprendre à la main le résultat d'une réflexion. Avec le projet wiiwhiteboard, on peut espérer pouvoir conserver ce genre de document, voir via un menu intégré, l'archiver, le lier à un agenda ou l'envoyer par mail.

Avoir aussi :

http://www.wiili.org/index.php/How_To:_BlueSoleil

http://www.cs.cmu.edu/~johnny/projects/wii/

Les exemples de code fournis sont en C# ou en delphi.

Le "hello world" de wiiwhiteboard :