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));
   
  }
}