Le SDK Androïd

Google vient de sortir son système pour l'informatique nomade. Androïd est un OS intéressant, architecturé autour d'un noyau linux 2.6.23, avec une couche java pour le développement haut-niveau.

Le SDK fourni par Google est vraiment très simple à installer. Il est composé d'un plugin pour eclipse et d'une machine virtuelle basée sur qemu. Le tout étant vraiment simple à installer. La prise en main ne pose aucun problème.

Pour plus d'information : open handset alliance

Résistance d'un mot de passe avec Google

Lorsque l'on souhaite s'inscrire à Gmail, le serveur évalue un indice entre 1 et 4 pour savoir si ce mot de passe est fiable ou pas. On peut récupérer cette fonctionnalité, pour d'autre application nécessitant une identification. (tant que google laissera cette fonctionnalité disponible). Il suffit de faire un appel au webService de type REST https://www.google.com/accounts/RatePassword?Passwd=. En retour on a un bête fichier texte contenant un chiffre (de 1 à 4). C'est simple et pratique à utiliser.

Principe de gestion des disjoncteurs dans un réseau de transport d'énergie électrique

Un disjoncteur sur le réseau haute et très haute tension ne fonctionne pas exactement comme un disjoncteur domestique. Lorsque notre disjoncteur saute, après un coup de foudre par exemple, on doit le réarmer manuellement. Par contre il est difficilement imaginable de voir une armée d’agent EDF se promener dans la nature au moment des orages d’été pour réenclencher les disjoncteurs haute-tension. Avant de vous expliquez le principe de la gestion du réenclenchement des disjoncteurs, je vais d’abord vous présentez les deux causes principales de défaut sur les lignes : l’orage et les objets extérieurs à la ligne (branche d’arbre par exemple). Dans le premier cas, bien souvent, l’énergie envoyé dans la ligne va finir par se dissiper. Dans l’autre cas on compte sur l’apparition d’un arc électrique pour supprimer (griller) le problème.
Sachant que le défaut est transitoire, une solution est de mettre un temporisateur qui va automatiquement fermer le disjoncteur après un court instant (3 à 5 secondes). Si au moment de la remise en tension on détecte à nouveau un défaut, on ouvre définitivement le circuit. Une variante consiste à retenter le coup plusieurs fois avec une mise hors tension définitive de la ligne au bout de x essais.

Javascript et java

La norme JSR223 définie comment appeler un interpréteur de script à partir de java. On peut utiliser toute sorte de langages, comme Python, Ruby ou java.

Voici un exemple trivial qui montre comment peut exécuter du code javascript dans une application java

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class Main {
public static void main(String[] args) {
 ScriptEngineManager mgr = new ScriptEngineManager();
 ScriptEngine jsEngine = mgr.getEngineByName("JavaScript");
 try {
  jsEngine.eval("print('Hello, world!')");
 } catch (ScriptException ex) {
  ex.printStackTrace();
 }
}
}

Café

Qui n'a jamais entendu, avec un ordinateur on peut tout faire sauf le café. Cette célèbre boutade a engendré un grand nombre de bricolages et logiciels divers dont le seul objectif est de la faire mentir.

Les dispositifs, servent en général uniquement à allumer ou éteindre une cafetière. Il est remarquable de constater que même la très sérieuse IETF a rédigé le RFC2324 pour la gestion de cafetière en réseau....texte proposé le 1er avril 1998

Le protocole HTCPCP (Hyper Text Coffee Pot Control Protocol) est assez simple : il se base sur HTTP. Il introduit de nouvelles méthodes comme, par exemple, BREW (brassage). La gestion des additifs est aussi prévu grâce au champ "Accept-Additions" dans l'entête HTTP. On peut ajouter du lait, du rhum, du sirop,.....

Les erreurs sont aussi gérées, comme l'erreur 406 qui vous sera retourné si l'additif demandé n'est pas disponible. L'erreur 418 se produit si vous essayez de faire du café avec une théière.

La théière de l'utah

Pourquoi le prix Prix Pixel-INA du festival imagina représente une théière ? En fait les pionniers de la 3D cherchaient une forme simple à modéliser. En 1975, une théière était un objet suffisament simple pour pouvoir être utilisé avec les premiers algorithmes 3D.

Avec le temps ce fichier de description d'une théière est devenu le hello world de la 3D.Comme les débuts de l'image de synthèse étaient surtout consacrés à la recherche sur les algorithmes, les premiers créateurs ne recherchaient pas beaucoup de fond, seul la forme, c'est à dire la technique comptait. Ils se donnaient le fichier de descriptions de la théière entre-eux, ce qui fait que cet objet est devenu une emblème. On la voyait souvent dans les premières démos. Il faudra attendre l'épopée de John Lasseter et de pixar pour voir cette tendance s'inverser.

Calculatrice expérimentale

Avant les microprocesseurs, les ordinateurs étaient souvent construit à l'aide de circuits intégrés à faible niveau d'intégration, contenant que quelques portes logiques élémentaires. Il est amusant de constater qu'il reste encore dans les stocks des boutiques d'électronique des composants de cette époque. En particulier, un circuit intégré en technologie TTL LS, le 74Ls181, qui est un circuit logique et aritmétique 4 bits. Il est facile (et totalement inutile) de fabriquer une petite calculatrice à l'aide de ce circuit. Il ne faut pas rever, on n'obtient qu'une machine très rudimentaire, capable d'allumer quelques leds et de faire des opérations en binaire. Mais bon, c'est rapide et amusant à faire.

Un driver caractère pour linux

Pour faire suite à l'article précédent, je vais vous présenter un deuxième driver "hello world", qui lui est "un vrai" pilote de périphérique.

Le source

#include linux/fs.h
#include linux/sched.h
#include linux/errno.h
#include linux/init.h
#include linux/module.h
#include linux/kernel.h
#include asm/current.h
#include asm/segment.h
#include asm/uaccess.h

/* le message à retourner */
char message[80]="bonjour monde";

/* ma fonction open. */
int mon_open(struct inode *inode,struct file *filep)
{
return 0;
}

/* ma fonction close. */
int mon_release(struct inode *inode,struct file *filep)
{
return 0;
}

/* ma fonction lecture. */
ssize_t mon_read(struct file *filep,char *buff,size_t count,loff_t *offp )
{
/* fonction pour copier le tampon depuis l'espace du noyau vers l'espace utilisateur*/
if ( copy_to_user(buff,message,strlen(message)) != 0 )
printk( "Kernel -> Erreur copie vers espace utilisateur\n" );
return strlen(message);

}

/* ma fonction lecture */
ssize_t mon_write(struct file *filep,const char *buff,size_t count,loff_t *offp )
{
/* On ne fait rien en écriture */
return 0;
}

/* Cette structure permet de définir les 4 fonctions de base que doit remplir   */
/* un pilote caractère. Ces 4 fonctions sont celles décrites par les prototypes */
/* que l'on vient de décrire.                                                   */
/* Ces fonctions sont l'ouverture du périphérique, sa fermeture, l'écriture et  */
/* la lecture.                                                                  */
struct file_operations mon_fops={
open: mon_open,
read: mon_read,
write: mon_write,
release:mon_release,
};

MODULE_AUTHOR("olivier thebault");
MODULE_DESCRIPTION("Hello world");
MODULE_LICENSE("GPL");

static int hello_init(void) {
/* enregistre le driver auprès du système.    */
/* On précise son numéro majeur, son nom      */
/* et la structure file_operations qui        */
/* contient les références aux fonction de    */
/* base du driver.                            */ 
/* Ce driver ne fait que retourner le message */
/* "message".                                 */
if(register_chrdev(234,"Bonjour Monde",&mon_fops)){
printk("<1>déclaration impossible");
}
return 0;
}


static void hello_exit(void) {
/* On désenregistre le driver */
unregister_chrdev(234,"Bonjour Monde");
}

module_init(hello_init);
module_exit(hello_exit);

L'installation

Une fois la commande insmod appelée, il faut déclarer le chemin /dev du périphérique avec
la commande mknod /dev/bonjour c 234 0.

Test

La commande cat /dev/bonjour devrait vous permettre de voir le message Bonjour Monde.

Comment écrire un module pour linux ?

Après avoir fait des essais autour d'un driver windows, j'étais quelque peu échaudé par ce genre d'activité.

C'est pourquoi, je me suis contenté de faire un petit driver expérimental sous linux. Rien de
fabuleux, juste pour m'habituer à la démarche. Pour linux, un driver peut se présenter sous le forme
d'un module, ou directement être compilé dans le noyau.

Préparation
Pour commencer il faut bien avoir installer le compilateur gcc et make. Ensuite il faut s'assurer que les headers du kernel soient présents. (j'ai fait mes premiers pas sur un noyau 2.6.18)
Ensuite à partir de là, il s'agit de créer des liens symboliques sur les entêtes du noyau, de la manière suivante :

ln -s /lib/modules/2.6.18-5-686/build/ /usr/src/linux
ln -s /usr/src/linux-headers-2.6.18-5-686 /lib/modules/2.6.18-5-686/build/

Maintenant, la compilation du module devrait marcher...

Mon premier module à un but unique : s'inscrire dans la liste des modules chargés.

Le code source (helloworld1.c)

#include linux/init.h
#include linux/module.h
#include linux/kernel.h

/* Les sources contiennent une série de macros permettant de faire */
/* des déclarations diverses au sujets des modules, comme ici la   */
/* licence.*/
MODULE_LICENSE("GPL");

static int hello_init(void) {
printk("<1>Bonjour monde\n");
return 0;
}

static void hello_exit(void) {
printk("<1>Au revoir\n");
}

module_init(hello_init);
module_exit(hello_exit);

Le seule chose que ce driver fait, c'est d'écrire un message en log système lorsqu'on
charge et lorsque on le décharge. Il est un peu prématuré de parler de driver pour ce
petit module car il n'est pas capable de faire grand chose. Il ne possède pas de
numéro majeur/mineur non plus.

La compilation

• Le Makefile

 obj-m := helloworld1.o

• Un petit script pour lancer la compilation

make -C /usr/src/linux-headers-2.6.18-5-686 M=`pwd` modules

Bien entendu, ce script est à adapter en fonction de la version du noyau.

L'installation

par la commande insmod ./helloworld.ko

ensuite pour vérifier : lsmod

Module Size Used by
helloworld1 1408 0
ppdev 8676 0
lp 11012 0
button 6672 0
.....

puis on le désinstalle : rmmod helloworld1.ko

lsmod

Module Size Used by
ppdev 8676 0
lp 11012 0
button 6672 0
ac 5188 0
......

dans le log système on trouve :

Sep 18 20:56:58 localhost kernel: Bonjour monde
Sep 18 20:58:11 localhost kernel: Au revoir

En fait, tout cela est très simple, en tout cas plus simple que sur un système windows.

Linux et les E/S en pascal

Les programmes DOS que je souhaite porter sous linux sont écrit avec turbo-pascal. Donc voici la version pascal de l'article précédent :

program portout;

Uses ports;

   function ioperm(from: Cardinal; num: Cardinal; turn_on: Integer): Integer; cdecl; external 'libc';

const
   BASEPORT=$378; //lpt1

begin
   // on demande l'accès des adresses BASEPORT à BASEPORT+3
   if (ioperm(BASEPORT, 3, 1))<>0 then
       Halt(1);

   // Initialisation de tous les signaux de données (D0-D7) à l'état bas (0)
       port[BASEPORT] := 0;

   // on libère l'accès des adresses BASEPORT à BASEPORT+3
   if (ioperm(BASEPORT, 3, 0))<>0 then
       Halt(1);

end.

Le compilateur utilisé est freepascal. Donc un simple fpc portout.pas suffit à le compiler.

programmation des ports E/S sous linux

En cherchant à porter d'anciens programmes dos vers linux, j'ai été confronté à la problématique de l'accès aux ports d'entrées/sorties du processeur. A l'époque du dos c'était simple, puisque il n'existait aucune protection à ce niveau, mais avec des systèmes en mode protégé cela est moins évident. Il existe plusieurs possibilités avec linux. L'une d'entre elle passe par des api système qui sont ioperm, outb et inb.
ioperm a pour rôle de demander l'autorisation au système d'accéder aux entrées sorties. Lorsque les opérations d'E/S sont terminés on demande à ioperm de libérer les autorisations.
Si le système accorde l'accès au peut appeler des api comme outb ou inb. Voici un exemple minimaliste en c pour illustrer cette technique :

/*
* programme très simple permettant d'accéder au port parallèle
*/

#include 
#include 
#include 

#define BASEPORT 0x378 /* lp1 */

int main()
{

/* on demande l'accès des adresses BASEPORT à BASEPORT+3*/ 
   if (ioperm(BASEPORT, 3, 1)) {
       perror("ioperm");
       exit(1);
       }

/* Initialisation de tous les signaux de données (D0-D7) à l'état bas (0) */

   outb(0, BASEPORT);

/* on libère l'accès des adresses BASEPORT à BASEPORT+3*/
   if (ioperm(BASEPORT, 3, 0)) {
       perror("ioperm");
       exit(1);
       }
     
   exit(0);
}

Installation de l'environnement MPLAB sous linux

Cet environnement est conçu par Microchip pour le développement d'application pour les micro-contrôleurs de la famille PIC. Ces circuits permettent d'embarquer et d'enfouir de petits systèmes informatiques.
L' IDE MPLAB est prévu à l'origine pour windows. Compte tenu qu'il s'agit d'une application windows classique, qui ne semble pas utiliser d'api très complexe, je me suis dit qu'elle devait assez bien fonctionner sous linux grâce à wine. L'installation de MPLAB s'est en effet déroulé sans problème, le setup installshield fonctionnant normalement. Par contre la mise en route de MPLAB s'est accompagné d'erreurs COM sur ce qui semble être une gestion de la localisation. Une fois les boites de dialogues passé, la première mise en route semble fonctionner tout à fait normalement.

Par contre mes tests se sont bornés à quelques opérations simple. Ne possédant pas de platine de développement, je n'ai pas pu valider la connection à ce genre de matériel.

créer un connecteur CAS

L'objectif ici est de permettre le développement d'application et d'extention autour de CAS, à l'aide
d'eclipse europa. CAS est un serveur d'authentification SSO développé à l'origine par l'université de Yale.

La première étape consiste à importer CAS dans eclipse. Pour cela, on va utiliser l'import du fichier war d'eclipse
pour créer un nouveau projet. Eclipse propose en cours d'import de laisser les fichiers jar du projet dans le
répertoire lib ou de les convertir en projet. Il faut les laisser en tant que lib.

Puisque il s'agit d'un fichier war, eclipse va l'importer en tant que projet web dynamique.

à partir de là, pour créer un nouveau connecteur il faut coder une classe java implémentant l'interface AuthenticationHandler. Cette implémentation est simple,
puisqu'il s'agit en gros de valider un couple login/mot de passe.

un exemple de code des deux méthodes peut être le suivant

public boolean authenticate(Credentials credentials)
  throws AuthenticationException {

 UsernamePasswordCredentials upCredentials = (UsernamePasswordCredentials) credentials;
 String username = upCredentials.getUsername();
 String password = upCredentials.getPassword();
 ......validation du login/mot de passe
}

public boolean supports(Credentials credentials) {
 return credentials instanceof UsernamePasswordCredentials;
}

L'opération suivante consiste à déclarer le connecteur dans CAS. Ceci se fait dans le fichier deployerConfigContext.xml qui se trouve dans WEBINF. La lecture de ce fichier permet de facilement déclarer notre connecteur.

Mapping automatique d’objet vers une source de donnée

Cette technique s’adapte bien à des données de type code/libellé. L’objectif est d’écrire ce genre de chose :

Var

ObjetSource :TobjectSource ;
….
Showmessage(ObjetSource.T253) ; // affiche la valeur associé à T253
….
Showmessage(ObjetSource.T255) ; // affiche la valeur associé à T255

Bien sûr, si j’ajoute une valeur T569 à ma source, je veux avoir automatiquement la propriété T569 sur mon objet, sans changer son source.

Cela veut dire que l'on a plus besoin de modifier l'objet de type TobjectSource . Cela veut dire aussi qu'une instance de cette classe n'a pas de propriété est qu'elle est capable de les créer à la volée au moment de l'exécution. Si cette classe n'a pas de propriété, on a donc pas besoin de les déclarer. (Monsieur de Lapalisse, 1/4 avant sa mort était encore en vie.)

Je m'explique : Sur un objet classique Delphi lorsque l'on souhaite rajouter une propriété on déclare dans le source de la classe un champ de type property : read...write...; et ensuite on compile. Le compilateur de delphi écrit en dur dans la structure du programme les listes des propriétés des classes (voir TypInfo.pas). On pourrait, à l'exécution, rajouter une propriété toto sur une classe quelconque (en tout cas celles qui ont été compilées grace aux directives $M+, $M-) en bidouillant (copie + ajout d'un enregistrement dans le RTTI) en assembleur la zone des données qui définissent une classe...(une aspirine??).

Ici le but du jeux est de faire ceci facilement (sans assembleur). Ceci est possible à l'aide de l'interface IDispatch.

Cela revient à écrire ce genre de chose:

 z:= ObjetSource.T253;

au moment ou l'on cherche à évaluer ObjetSource.T253, il y a un bout de code de l'objet qui récupère la chaine 'T253’ et qui cherche la valeur correspondante dans la base et ensuite au moment de l'affectation renvoie la valeur qu'il a trouvé. Il va de soi que la propriété T253 n'a jamais été déclaré dans le source.( je radote, je sais)

Je vous laisse découvrir le code pour voir comment tout cela fonctionne. Il s'agit juste d'une ébauche pour valider le principe. La partie accès base de donnée n'est pas implémentée.

unit Unit3;

interface

uses ComObj, sysutils, classes;

type

 TobjectSource  = class(TInterfacedPersistent, IDispatch)

 private

   FValueName: string;

 protected

   function GetTypeInfoCount(out Count: Integer): HResult; stdcall;

   function GetTypeInfo(Index, LocaleID: Integer; out TypeInfo): HResult; stdcall;

   function GetIDsOfNames(const IID: TGUID; Names: Pointer; NameCount, LocaleID: Integer; DispIDs: Pointer): HResult; stdcall;

   function Invoke(DispID: Integer; const IID: TGUID; LocaleID: Integer; Flags: Word; var Params; VarResult, ExcepInfo, ArgErr: Pointer): HResult; stdcall;

   function GetValueString(ValueName: string): string;

   procedure SetValueString(ValueName, Value: string);

 end;

  implementation uses dialogs, ActiveX, variants;

   function TobjectSource .GetTypeInfo(Index, LocaleID: Integer; out TypeInfo): HResult;
  begin 
   Result := 0;
  end; 

  function TobjectSource .GetTypeInfoCount(out Count: Integer): HResult; begin 
 Result := 0;
   end; 

  function TobjectSource .Invoke(DispID: Integer; const IID: TGUID; LocaleID: Integer; Flags: Word; var Params; VarResult, ExcepInfo, ArgErr: Pointer): HResult;
 var 

 zPutValue: OleVariant;

 zResult: OleVariant;
   begin 

 // on veut lire le paramètre

 if (Flags and DISPATCH_PROPERTYGET) = DISPATCH_PROPERTYGET then

 begin

   zResult := POleVariant(VarResult)^;

   // on peut faire un varType pour savoir si on a un string ou un integer à récupéré (ou autre chose)

   POleVariant(VarResult)^ := GetValueString(FValueName);

 end;

 // on veut écrire le paramètre

 if (Flags and DISPATCH_PROPERTYPUT) = DISPATCH_PROPERTYPUT then

 begin

   zPutValue := POleVariant(Params)^;

   // on peut faire un varType pour savoir si on a un string ou un integer à écrire (ou autre chose)

   SetValueString(FValueName, zPutValue);

 end;

 result := S_OK;

end; 

function TobjectSource .GetIDsOfNames(const IID: TGUID; Names: Pointer; NameCount, LocaleID: Integer; DispIDs: Pointer): HResult; var 

 P: POleStrList;

begin 

 P := POleStrList(Names);

 FValueName := P^[0];

 result := S_OK;

end; 

function TobjectSource .GetValueString(ValueName: string): string; begin 

 // retourne la valeur correspondant au nom passé en paramètre

 Result:='On va dire que ceci est la chaine que lon a récupéré en base';

end; 

procedure TobjectSource .SetValueString(ValueName, Value: string);
begin 

 // affecte la valeur....

 showmessage('On va écrire en base:'+ValueName + '=' + Value);

end; 

Le projet d'urbanisation du S.I.

Ce livre présente l'urbanisation de manière claire à travers un exemple traité de manière exhaustive. Cet ouvrage a de réelles vertues pédagogiques. Il permet de rendre moins obscur et plus pratique l'urbanisation de système d'information.

• Auteur: Christophe Longépé
• Broché: 288 pages
• Editeur : Dunod (18 septembre 2001)
• Collection : Informatique et Entreprise
• Langue : Français
• ISBN-10: 2100056948
• ISBN-13: 978-2100056941

Constructor, destructor, procedure : Quels différences ?

C’était pour dire….euh…rien du tout (?)

En fait le constructeur de TObject ne fait rien....ou presque...

constructor TObject.Create;
begin
end;

le destructeur non plus...

destructor TObject.Destroy;
begin
end;

Rôle de NewInstance et FreeInstance

En fait le mots-clé constructor va obliger le compilateur à rajouter un appel à la méthode NewInstance au moment du begin. C'est ce qui différencie le constructeur d'une bête procédure.
Sur le même principe, le mot clé destructor va provoquer un appel à FreeInstance.

Comment fonctionne NewInstance ?

Là encore il s'agit de quelques chose de très simple : il va d'abord récupérer la taille en octets
de l'instance d'une classe grâce à la méthode InstanceSize, puis va appeler un GetMem pour allouer l'espace mémoire auprès du système. Ensuite un appel à InitInstance va initialiser les octets alloué à des valeurs par défaut.
La valeur retournée par InstanceSize est définie au moment de la compilation.
Dans le cas de TObject, la taille en mémoire d'une instance est 4 octets. Elle permet de stocker un pointeur vers la classe associée à l'instance.

Comment fonctionne FreeInstance ?

Il s'agit d'un bête appel à FreeMem.

Hello World OS

Le but de cet article est de présenter comment coder un petit hello world au boot d'un PC.

Rappels sur le démarrage d'un PC

• Le premier programme qui démarre est le bios
• Il effectue des contrôles sur le PC
• Il initialise les périphériques
• Il charge le secteur de boot et il l'éxécute

Le secteur de boot

Rappel : un programme en assembleur se présente sous la forme d'une suite d'octets

Un secteur de boot contient :

• Des informations donnant les caractéristiques du disque
• Les octets du programme de secteurs de boot
• 2 octets magiques indiquant que le disque est bootable
• Le seul secteur chargé automatiquement par le bios
• Il stocke moins de 512 octets pour le programme

Le source

[BITS 16]

[ORG 0x0]

; initialisation des segments en 0x07C0
 mov ax,0x07C0
 mov ds,ax
 mov es,ax
 mov ax,0x8000
 mov ss,ax
 mov sp, 0xf000

;--- les données ---
msgDebut db "Hello world OS is running ! ",13,10,0

; Affiche une chaine de caracteres se terminant par 0x0
; Entree:   DS:SI -> pointe sur la chaine a afficher
afficher:
 push ax
 push bx
.debut:
 lodsb  ; ds:si -> al
 cmp al,0 ; fin chaine ?
 jz .fin
 mov ah,0x0E ; appel au service 0x0e, int 0x10 du bios
 mov bx,0x07 ; bx -> attribut, al -> caractere ascii
 int 0x10
        jmp .debut
.fin:
 pop bx
 pop ax
 ret

;--- NOP jusqu'a 510 ---
times 510-($-$$) db 144
; nombre magique : indique au pc que le secteur est bootable
dw 0xAA55

Structure de tomcat

Il s'agit de quelques éléments de structure du serveur tomcat

Server
C'est l'ensemble du serveur catalina. Il peut contenir un ou plusieurs services.

Service
Un service est un groupe de connecteurs partageant un unique container, par un exemple
un connecteur http et un connecteur https partageant les mêmes servlets.

Container
Un container est un objet implémentant l'interface Container.Il est capable de traiter une requêtes en provenance d'un client et de fournir un réponse. Avant d'effectuer le traitement de la requete, il peut la faire transiter par un objet Pipeline qui est composé d'un ou plusieurs objets Valves.
Le Container, grâce à la méthode invoke, passe la requete à la première valve du pipeline. Cette méthode part du principe que la requete est de type Http. Son paramètre "request" implémente l'interface "HttpServletReques"

Pipeline
Gère une liste de valve. Si cette liste est vide une valve spéciale est appelée. Elle
est stockée dans le champ 'basic'. La liste des valves est stockée sous la forme d'une liste chainée.

Valve
Permet de faire des appels aux servlets. Gère aussi l'enchainement des valves.

Quelques correspondances entre interfaces et classes:
StandardServer -> Server
StandardPipeline -> Pipeline
ContainerBase -> Container
GenericServlet -> Servlet

Comprendre les programmes opensource

Le but de cet article n'est pas d'expliquer le mode de fonctionnement des licences des projets open-source, mais plutôt de donner quelques astuces pour comprendre comment fonctionne ces logiciels. Bien que les sources soient ouverts, il n'est pas toujours évident pour une personne qui débarque dans un projet d'en comprendre la structure. On peut trouver, bien sûr, quelques documents de structure, mais cela ne suffit pas toujours.

On peut penser que la première source de documentation, ce sont les développeurs eux-mêmes. A mon avis il n'est pas judicieux de les bombarder de questions, pour au moins deux raisons : d'abord ils n'ont peut-être pas que ça à faire, et ensuite il est sans doute plus instructif de se casser les dents sur le code pour bien le comprendre, quitte à le laisser tomber momentanément lorsque l'on est vraiment bloqué.

L'autre source d'information ce sont les ouvrages édités autour des applications.Leur seul défaut est que bien souvent on n'entre pas dans le vif du sujet à quelques rares exceptions prêt. Souvent les ouvrages traitant de tomcat ou eclipse aborde le développement, mais effleure la structure même de ces produits.

Autre source d'information, bien sur ce sont les sources. Et c'est bien l'avantage même de ces produit. Le meilleur moyen des les aborder est sans doute de répérer une fonctionnalitée, ou une caractéristique et de la rechercher dans le code.
Dans le cas de firebird, par exemple, je suis parti à la recherche des mots clés SQL et des procédures stockée.
Pour le noyau linux ma première exploration vient d'un source de "Hello World" écrit en assembleur. Ce source m'a permis de voir comment sont implémentés les appels systèmes et par ce biais aller plus loin dans les sources du noyau. Dans le même style, sachant que le noyau démarre le processus "init", j'ai cherché à savoir ce qu'il fait à ce moment là.
Pour tomcat, je suis partie de l'implémentation de HttpServlet. Comme il s'agit d'un programme très structuré, il m'a été facile de voir les principales structures de ce serveur.

La dernière source d'information est bien sur internet. On peut trouver toutes sortent d'informations sur les programmes open-source que l'on souhaite étudier. Cependant, si l'on ne veut pas se noyer dans les informations et dans le bruit issue des moteurs de recherche, il est important d'avoir une démarche de recherche structurée.

Toutes ces approches sont complémentaires. Avec un peu d'organisation on peut assez rapidement venir à bout de projets complexes. Je ne dis pas que l'on peut comprendre l'exhaustivité du code de projets importants, mais que l'on peut comprendre comment il s'organise.

Urbanisation

Le concept d'urbanisme est récent mais se répand rapidement. Derrière cette formulation qui peut paraitre pompeuse, il se cache une vrai nécessitée. II repose sur le constat qu'il est illusoire de vouloir reconstruire entièrement un système d'information en faisant table rase de l'existant, pour des raisons de coût et de risque (désorganisation, pertes de données...). Les principes soutenus par ce concept est que l'on peut gérer un système d'information comme on gère l'urbanisme d'une ville. Cela revient à cartographier le sytème, identifier les voies de circulation et le faire évoluer en suivant un projet d'entreprise qui dépasse le cadre du simple projet informatique. Cela implique d'avoir une réflection méthodologique en ce qui concerne la marche à suivre pour faire évoluer le système, morceaux par morceaux, sans pertuber l'existant, mais en apportant de nouvelles fonctionnalitées essentielles à l'entreprise.
Il s'agit aussi d'avoir une vision à long terme du système d'information, ce qui implique d'avoir une connaissance claire de la stratégie de l'entreprise.

Interfaces textes

Au risque de passer pour un vieux crouton, je me demande si parfois l'antique interface texte n'avait pas du bon. Je sais bien que les interfaces graphiques, qu'elles soient web ou non, sont très conviviales et faciles d'accès, mais je ne suis pas sur qu'elle soient très adaptées pour la saisie au kilomètre.
Je m'explique : je ne sais pas si vous l'avez remarqué, mais à chaque fois que l'on souhaite développer une interface de saisie sous windows ou sur le web, se pose invariablement la question des raccourcis clavier et de la lisibilité. C'est encore plus vrai dans un contexte industriel, où la présence d'une souris devient genante et où les terminaux peuvent avoir des contraintes de taille d'écran ou des claviers spéciaux. J'ai souvent entendu les utilisateurs regretter leur ancienne interface, qu'ils trouvaient bien plus rapide à utiliser.Dans certains cas ne vaut-il pas mieux utiliser un serveur telnet plutot qu'un serveur apache ?

Idéalement, la bonne solution est la bonne interface pour les bonnes fonctions. Le marketing et tout ce qui relève de la communication avec les interfaces graphique et la production à la chaine, manipulant des informations textuelles une interface texte. Un petit bémol, s'il s'agit d'une production "complexe", impliquant des schémas ou des graphiques, cela n'est pas possible, mais s'il s'agit de liste de codes à barres ou d'adresse d'expédition, cela peut se discuter.

Ceci devrait être possible à partir d'un serveur style dotnet ou j2ee. Surtout que ces systèmes intégre des notions de type MVC, ce qui permet d'avoir les mêmes notions métiers entre tous les terminaux. Bien sur la plupart de ces serveurs sont orientés HTTP, mais il est possible d'avoir une sorte de Telnet/HTTP. (oui, oui, l'inverse du WebToHost)

Comment Delphi compare les valeurs de pointeur ?

On peut très bien faire des convertions forcées entre des pointeurs et des entiers dans Delphi. Cela ne pose pas de problème particulier. Le type Tobject qui est un pointeur sur une instance de classe, peut lui aussi être converti en entier, comme le montre l’exemple suivant. Que se passe t-il alors au niveau code machine en ce qui concerne les comparaisons entre deux pointeurs ?

procedure TForm1.Button1Click(Sender: TObject);
var
 lst:TStringList;
 a:integer;
begin
  lst:=TStringList.create;
  lst.AddObject('test',TObject(10));
  lst.AddObject('test2',TObject(18));
  lst.AddObject('test2',TObject(180));
  a:=lst.IndexOfObject(TObject(18));
  showmessage(IntTostr(a));
  lst.Free;
end;

En regardant les sources de IndexOfObject on a :

function TStrings.IndexOfObject(AObject: TObject): Integer; begin  
 for Result := 0 to GetCount - 1 do
if GetObject(Result) = AObject then Exit;
Result := -1;
  
end;

A partir de ça le compilateur génère le code suivant : (en vu CPU pas à pas dans le code de la méthode IndexOfObject). :

Le compilateur de delphi converti la comparaison entre pointeurs en comparaison entre entiers ( cmp eax,ebp-$08 ). Il compare ici la valeur contenue dans le registre eax ($A, 10 en décimal) qui est la première valeur du tableau Tobject, à la valeur qui se trouve à l’adresse EBP-$08 c’est à dire $12 qui donne 18 en décimal. En fait Delphi ne sait pas faire de différence entre pointeur et entier, tout simplement parce que cette distinction n’existe pas au niveau CPU. C’est pour lui la même chose, tout est entier sur 32 bits. L’apparente différence entre un entier et un pointeur n’est qu’un pur artifice du langage de Delphi.

Quelques liens à propos de l'AS/400

Une société qui propose du temps machine sur internet

Netshare400.com

---

Documentations techniques fournis par IBM

AS-400 Online Library - Books in French

AS-400 Online Library - English Language Library Contents

---

Initiation à la programmation cobol sur AS/400

Programmation en
COBOL sur AS-400

Apple I Replica Creation

Pour ceux qui ne le saurais pas, la société Apple est née dans un garage en 1976. Le premier micro commercialisé par cette société était une carte mère pour amateur avec un 6502, un contrôleur clavier et un contrôleur vidéo intégré.

30 ans plus tard, l'Apple I est devenu un pièce de collection d'une valeur inestimable. Certaines personnes, par amusement ont fait un kit pour construire un clone de l'apple I. Tom Owad décrit dans cet ouvrage le Replica I. Il s'agit d'un livre pour débutant, où tout est décrit pour faire ses soudures, repérer les composants. Le basic de l'apple est aussi abordé. La dernière partie du livre est consacré à un hack d'un mac SE. Ce livre est un vrai régal. On a droit aussi l'aspect historique et à quelques photos d'apple I montés.

Apple I Replica Creation de Steve Wozniak (Préface), Tom Owad (Auteur)
Broché: 416 pages
Editeur : Syngress Publishing; Édition : Pap/Cdr (17 février 2005)
Langue : Anglais
ISBN-10: 193183640X
ISBN-13: 978-1931836401

Quelques liens à propos de SAP R/3

tous ce qui concerne les fichiers IDOC, les connecteurs DCOM, RFC, etc...

SAP Interfacing Technology

Truc et astuce à propos du langage ABAP

ABAP Hints and Tips - Upload and Download ABAP Source Code

Toujours à propos d'ABAP

SAP Repository

Extrait de la doc SAP concernant les interfaces COM SAP

SAP-Bibliothek - SAP Automation RFC and BAPI Interfaces (BC-FES-AIT)

Le peuple des manchots

Une fois n'est pas coutume, une innovation de microsoft nous rappelle à tous que nous sommes des manchots.

Microsoft Surface est vraiment quelque chose d'intérressant et de novateur. On se rappelle enfin que nous avons deux mains de dix doigts chacunes. La souris avait fait de nous des manchots avec une main à deux doigts. Microsoft Surface nous libère de ce handicap. J'ai vraiment l'impression de revivre l'époque des Apple Lisa et Macintosh, lorsque l'on passait de l'interface texte à l'interface graphique.

Avec les NUI (Natural User Interface) ont passe un nouveau cap dans la simplification de l'utilisation de l'ordinateur.

La présentation remarquée de Microsoft Surface ne veut pas dire qu'ils sont seuls à être novateur sur ce sujet. De nombreuses expérimentations existent autour de ce sujet. A titre d'exemple on peut voir le produit de Perceptive Pixel.

Windows NT et le mode noyau

Il n'est pas forcément évident d'avoir des informations concernant les api natives de windows NT. La répartition des appels d'interruptions n'est pas forcément très connue non plus.

Windows NT et 2000 n'utilisent pas la technique des "call gate", mais se base sur de simples interruptions logicielles, comme linux, pour faire des appels à ses api internes et passer en mode noyau. C'est la DLL ntdll.dll qui se charge de cette opération. Cette DLL est composée des principales api du noyau, d'ailleur on retrouve la plupart des fonctions disponibles dans l'api win32, à ceci près qu'il ne s'agit pas des api win32. En fait win32 se comporte un peu comme un wrapper sur les api natives.

Pour passer en mode noyau l'api native met le numéro de la fonction à appeler dans le registre eax, les arguments dans le registre edx et l'appel se fait via int $2E.

On dirait presque linux ;o)

Gallica

Par pure curiosité, j'ai voulu voir quel genre de document électronique on peut récupérer via Gallica.
J'ai commencé par un document très connu : Le comte de Monte-Cristo d'Alexandre Dumas. Recherche sans aucun problème, ce qui m'a permit de télécharger une édition complète scannée au format PDF.

Je constate aussi que l'on peut récupérer des périodiques. Je commence alors par quelque chose de moins facilement trouvable : Annalen Der Physik. Et là, surprise, la notice décrit une liste de fascicules depuis 1799.
Cela devient très intéressant. Peut-on consulter certains articles connus, comme ceux parus en 1905, sous la plume d'un obscur employé du bureau des brevets à Bern ?

Trois fichiers de cette année là sont disponibles. Je les télécharge. Le premier est composé de 1000 pages. Je regarde rapidement l'index, cela ne semble pas être ça. Le festival d'articles fondateurs de cet illustre inconnu commence vers le mois de mai me semble t-il. Le premier fichier s'arrête au mois de mars. Fichier suivant. Son nom est dans l'index. Les premiers articles de cette année fabuleuse n'était qu'une mise en bouche. Le dernier article de la série, celui de septembre se trouve dans le troisième fichier PDF, à la page 647 (639 du document d'origine). Le truc amusant c'est que sa célèbre formule n'est pas présentée sous sa forme la plus connue. A la fin de l'article il en arrive à la conclusion que la masse d'un corps vaut L/V² (L pour son énergie propre et V pour la vitesse de la lumière). Ce fonctionnaire s'appelait Albert Einstein.

Cherchons plus vieux encore, un auteur arabe du IX ième siècle : al Khwarizmi. Je ne me faisait pas trop d'illusions à son sujet, je n'ai pas trouvé trace de son célèbre traité de mathématiques "Hisab al-jabr w'l muqabala" sur Gallica. J'ai pensé alors à rechercher à partir de Google Recherche de livre. On obtient plus de réponses, des textes biographiques sur l'auteur mais aucun ouvrage complet. Sur wikipedia, on trouve un article à son sujet et quelques pages scannées de ses écrits.

Appel des interruptions logicielles en Delphi

Bien que l'accessibilitée de ces interruptions soient limitées, je vais vous présenter deux d'entre elles.

La première concerne la gestion des débordements. Si vous écrivez

asm
  int $4
end;

vous produirez une exception EIntOverflow, débordement d'entier. Je vous le consède bien volontier, ceci n'a pas grand interêt. La deuxième interruption que l'on peut appeler et celle qui gère les points d'arrêts.

asm
int $3
end;

int $3 est l'interruption logicielle prévue par Intel pour gérer les points d'arrêt. A ce moment là, le processeur passe en mode noyau et donne la main au système windows, qui fera remonter l'info au debugger de Delphi. Le programme va s'arrêter en mode pas à pas dans Delphi sur l'instruction pascal qui suit cet appel à int $3.

Cet appel fait penser à la fonction de l'api windows : DebugBreak. Par contre DebugBreak provoque l'affichage de la vue CPU dans Delphi. On ne se retrouve pas en arrêt sur une ligne pascal.

Contrôle d'une carte à relais en PHP

Le kit Velleman K8056 permet de construire une carte comprenant 8 relais commandés par un port série RS232. Voici comment contrôler cette carte en PHP sur une machine linux.

Il existe une version linux du programme de contrôle de la carte k8056. Vous pouvez le trouver ici : http://k8056.free.fr

Un fois le programme compilé, il s'agit de le lancer via PHP. Cette page minimaliste vous montre comment faire :

';
    echo '';
    $last = system($interface,$retval);
    echo "derniere ligne : ". $last;
    echo "valeur retournée:" . $retval;
    echo '';
    echo '';
?>

Cette page part du principe que le programme de lancement se trouve dans /usr/local/bin/k8056_20051007/
A vous d'adapter le chemin en fonction de votre contexte. Dans le cas présent le port et la commande à envoyer sont en dur. Rien n'empêche de récupérer des paramètres par un formulaire.

Il vous faudra aussi faire attention aux droits d'accès au programme k8056.

Voilà

L'ERP Neogia

Présentation d'un ERP facile à utiliser

Installation
L'installation est très simple, il suffit de décompacter l'archive. Il faut au préalable avoir installé un JDK 1.5. Le package de lancement inclu le moteur catalina.


Mise en route
Il suffit de lancer http://localhost:8080/catalog. Le login est "admin" et le mot de passe "ofbiz".

Cet ERP possède un module de gestion de stock et achats, gestion des commandes, gestion marketing, un module de comptable, gestion de la fabrication,...

Pentaho

Une plate-forme incluant des outils de reporting, d’analyse (OLAP), de tableau de bord, de data mining et d’ETL. Disponible sous forme de suite ou de services Web. Ce produit s'appui sur le serveur J2EE Jboss et sur Jboss Portal.

Installation

L'installation de la version de démo ne pose pas de problème particulier sur windows. Il suffit de décompresser l'archive pentaho_demo-1.2.0.534-GA.zip. Il faut bien entendu au préalable avoir installé sur la machine un jdk.

Démarrage

Il suffit de lancer start-pentaho.bat. Puis de lancer un navigateur sur localhost:8080


Outil de conception

L'installation de cet outil se base sur le même principe que le serveur. Il suffit de décompresser l'archive (pentaho-design-studio_1.2.0.341-GA.zip). Par contre il s'agit d'un programme client lourd basé sur eclipse. Le programme de lancement est PentahoDesignStudio.exe.

Licence

Ce produit est distribué sous licence MPL

PHP sur serveur JAVA

Il existe un serveur J2EE qui est capable de voir les applications PHP comme des servlets. Voici comment il s'utilise.

Resin-Caucho est un serveur certifié J2EE, proposé sous une double licence GPL et commerciale. Sous ces deux licences vous pourrez trouver la servlet Quercus qui est capable de faire tourner des programmes PHP5. L'installation d'une application php sur ce serveur est très simple. Il suffit de copier dans la répertoire webapps de copier l'application. il faudra lui rajouter un répertoire WEB_INF contenant un fichier de paramétrage resin-web.inf.

Ce qui est interressant aussi, c'est qu'il existe une version autonome de Quercus, l'interpreteur/compilateur PHP, embarqué dans Resin. Je précise interpreteur/compilateur, parce que, en mode compilateur quercus convertie le code PHP en code JAVA, comme Jasper peut le faire avec du code JSP.

La licence de ce produit est la GPL.

Ceci en fait un produit praticulièrement interressant.

Comment fonctionne les dfm ?

Les dfm sont les fichiers descriptifs des fiches, datamodule et frame. Le but de cet article est de décrire comment fonctionne la construction des fiches dans un programme Delphi.

La sérialisation des composants dans Delphi passe par la classe TStream. Cette classe est abstraite et ne propose pas d'implémentation des méthodes d'accès au support de stockage. De cette manière on a dans la VCL une implémentation de cette classe pour des fichiers disques (TFileStream), pour la RAM (TMemoryStream), pour un blob binaire dans une base de données (TBlobStream), sur un réseau (TSocketStream) ou dans les ressources d'un fichier au format PE, type .exe ou dll (TResourceStream). C'est cette dernière classe qui va nous intérresser ici.

En fait les points communs entre TDatamodule, TForm et TFrame est que tout d'abord ce sont des composants et donc qu'ils peuvent être agrégés et sérialisés. De plus les constructeurs de ces trois classes sont conçus pour aller chercher un fichier dfm et le déssérialiser.

Dans l'éditeur de Delphi, ces classes se dérivent toujours. A chaque fois que l'on souhaite créer une nouvelle fiche, Delphi va construire une nouvelle classe de fiche dérivée de TForm. De plus le source de cette classe possède une directive particulière qui lui permet de convertir le fichier dfm associé en ressource du fichier compilé ({$R *.dfm}). Dans les sources des constructeurs de ces classes on peut constater que l'on fait appel à un traitement particulier si l'on n'est pas dans l'IDE et si la classe courante n'est pas la classe de base.

Ce traitement particulier se trouve dans la procédure InitInheritedComponent. Cette procédure va faire appel à la fonction InternalReadComponentRes(const ResName: string; HInst: THandle; var Instance: TComponent) qui va reconstruire la fiche à partir de la ressource ResName, dans le module HInst et sur le composant Instance. Le nom de la ressource est celui de la classe finale.

Voilà.

Comment appeler une méthode par son nom ?

L'objectif est de pouvoir appeler une méthode sur un objet, descendant de TObject, dont la classe est inconnu. Cette méthode sera simple et sans paramètre. La difficulté ici est que l'on ne peut pas passer par le transtypage.

Donc il va falloir ruser pour pouvoir faire l'appel à une méthode de cette classe.

Conditions préalables :

1 - La classe doit être compilé avec la directive $M+ (par exemple TPersistent).

2 - La méthode que l'on souhaite appeler doit être publiée.

Pour récupérer la méthode save d'un objet inconnu il faut passer par la fonction de classe MethodAddress introduite dans TObject. Tant qu'une classe descendante de TObject n'est pas compilée avec la directive $M+, les instances n'auront pas de RTTI, on donc pas de possibilité de retrouver l'adresse d'une méthode.

Pour plus de détails à ce sujet vous pouvez voir le code de MethodAddress dans System.pas.

Le code de cet appel est le suivant :

 var
  zmSave: procedure of object; // la méthode save
  zpSave: pointer; // pointeur vers le code de la méthode save
 begin
  // si il existe un éditeur courant et que le panneau de cet éditeur existe et que le panneau a une méthode
  // save publié alors....
  if assigned(CurrentEditor) and assigned(CurrentEditor.ctrl) and (CurrentEditor.ctrl.MethodAddress('Save') <> nil) then
  begin
    // on récupère le pointeur sur le code de la méthode save
    zpSave := CurrentEditor.ctrl.MethodAddress('Save');
    // puis on initialise la variable zmSave avec le code et les données associés
    TMethod(zmSave).data := CurrentEditor.ctrl;
    TMethod(zmSave).code := zpSave;
    // et on fait l'appel
    zmSave;
  

Le transport d'électricité

La France étant un pays de faible densité de population, les lieux de production sont souvent éloignés des consommateurs. Les réseaux de transport et de distribution ont pour but de faire circuler le courant électrique des centrales aux clients. La desserte de ces derniers a rendu nécessaire la construction de plus d'un million de kilomètres de lignes.

Les lignes haute et très haute tension qui constituent le réseau de transport, acheminent d'importantes quantités d'électricité. Organisées en réseaux interconnectés, elles permettent les échanges entre régions ou pays. En cas de besoin, elles peuvent faire transiter l'électricité d'un bout à l'autre du territoire. Elles alimentent aussi de grandes entreprises industrielles.
Les lignes moyennes et basse tension forment le réseau de distribution. Elles répondent aux besoins locaux. Alimentées depuis les lignes à haute et très haute tension, elles diffusent l'électricité vers les autres clients (particuliers, P.M.E.-P.M.I.).
Les centres de production et de répartition du courant électrique vers les lieux de consommation sont régis par un système complexe. Au coeur de ce système, les 'dispatchings' constituent les centres d'aiguillage de l'électricité. Le rôle de ces centres est d’ajuster en permanence la production à la demande. Les 'dispatchings' sont aidés par de puissants calculateurs qui traitent les informations et signalent le franchissement de seuils dangereux pour la qualité ou la sécurité d'alimentation en électricité. Il permet également d'éviter tout gaspillage.
Physiquement ce réseau est constitué de lignes, de postes de répartition et de transformation, de générateurs et de points de piquage
Les tensions de fonctionnement, en France, vont de 63000 à 400000 volts.


Le poste de répartition

Un poste de répartition a pour but de distribuer l’énergie électrique sur le territoire. En général un poste de répartition 63 kV contient des transformateurs pour abaisser la tension de 63 kV vers 20 kV pour fournir le service distribution qui achemine alors l’énergie vers des PME-PMI ou des transformateurs 20KV-380V .
Le poste est le point de connexion de toutes les lignes électriques hautes tensions. Un poste est constitué d’un ou deux jeux de 3 barres qui répartissent l’énergie sur plusieurs lignes triphasées (d’une façon imagé c’est une multiprise ). Chaque ligne est connectée aux barres par l’intermédiaire d’un disjoncteur et de 2 sectionneurs de ligne montés en série.
Ces barres peuvent être divisées en plusieurs sections ( jusqu'à 3 ) connectées entre elle par des sectionneurs de sectionnement. Lorsque le poste a 2 jeux de barres on a présence d’un ou deux disjoncteurs de couplage pour connecter les 2 jeux entre eux. Sauf exceptions tous les disjoncteurs et sectionneurs sont télécommandables. Les opérateurs contrôle ainsi l’ouverture et la fermeture des disjoncteurs de plusieurs postes sur une zone géographique bien délimité. Ils commandent les disjoncteurs et les sectionneurs en fonction de la consommation électrique, des travaux sur le réseau etc....
Les disjoncteurs des postes ont aussi pour fonction de protéger le réseau contre les surintensités. ( à cause de la foudre ou à des branches d’arbre) Ces défauts électriques sont dans la plupart des cas furtif, c’est pourquoi il est inutile et problématique ( coupure électrique ) de laisser un disjoncteur ouvert après un problème. Un automate va donc essayer de réenclencher le disjoncteur au bout de quelques secondes. L’évolution conduit à réduire le temps de coupure en installant des automates de réenclenchement rapide.

Les points de piquage

Il s’agit simplement du branchement de l’extrémité d’une ligne au milieu d’une autre.

Les générateurs

Il s’agit simplement des centrales de production d’électricité.

Truc pour dotclear

Que faire si vos tags aboutissent à une page inconnu dans apache (erreur 404) ?

La solution est très simple une fois que l'on a trouvé, mais ce n'est pas évident à première vue. En fait il suffit d'aller dans
Tableau de Bord / paramétres du blog et ensuite de demander Méthode de lecture de l'URL=QUERY_STRING

Voilà.

Structuration d’un produit assurance IARD

Ce document est un exemple de modélisation de données pour l’enregistrement de contrats d’assurances. Il ne s’agit pas d’une règle absolue.

Grandes lignes de l’assurance et de la structuration d’un contrat

Le principe de l’assurance consiste pour la compagnie d’assurance à prendre à son compte un risque de perte financière résultant d’un évènement à caractère accidentel et/ou imprévisible subit par l’assuré. L’assuré en échange de ce service devra payer une prime à l’assureur. Les sinistres peuvent être de natures variés sur le plan financier (montants très variables) et par rapport à leur fréquence (évènement rares ou fréquents).
Ainsi le contrat d’assurance décrit un accord entre l’assureur et l’assuré concernant le type de risque couvert et les montants en jeux.

L’évolution du secteur fait qu’un contrat peut-être dit multirisques.. Les niveaux de garantie souscrit pour ces risques sont eux aussi variables en fonction du type de protection souhaité par l’assuré. Ainsi, par exemple, pour une assurance automobile on peut avoir simplement la responsabilité civile (tiers) ou un ensemble de garantie (RC+juridique+bris de glace, etc….). Ce type de contrat peut porter sur un ou plusieurs « objets » assurés (exemple : l’automobile seule, ou l’automobile+le conducteur).
L’ensemble des garanties qui composent un produit d’assurance décrit le découpage de ce produit en différentes garanties. Ces garanties sont elles-mêmes regroupées en options suivant des règles de marketing et/ou juridique. Ce sont ces options qui vont être commercialisées. Chacune des garanties d’une option est tarifé, la prime d’une option est la somme des montants de primes de chaque garanties qui la compose, augmentées des taxes diverses applicables en fonction de la garantie. En outre des taxes peuvent avoir un rôle a jouer dans la réassurance, lorsqu'un risque est considéré comme trop gros pour être supporté par une seule compagnie (Catastrophe naturelle et attentat)
(Remarque : le présent document ne traite pas de la tarification, mais uniquement du découpage des contrats). Chaque option commerciale est rattachée ensuite à un (ou plusieurs) objets qui sont définis comme étant nécessaire à la vente d’un contrat. Par exemple on ne peut pas vendre de contrat d’assurance automobile, s’il n’existe ni automobile, ni conducteur. Ces deux « objets » doivent être décrit dans le contrat et doivent exister. Ceci afin de se mettre en conformité avec le droit, car pour qu’un contrat d’assurance puisse exister, il est nécessaire que les objets assurés existent et de plus les risques assurés doivent aussi exister. (exemple : il n’est légalement pas possible d’assurer un poisson contre le risque de noyade)

Les caractéristiques des objets assurés permettent de déterminer les montants de primes. Ainsi un conducteur pourra avoir comme caractéristique l’age de son permis (jeune conducteur) et son bonus/malus. Ces caractéristiques influencent les montants de prime de la responsabilité civile automobile.

Exemple de découpage

Produit assurance automobile
Objet assuré : véhicules
Options commerciale : Au tiers
* Défense-recours
* Responsabité civile

Options commerciale : Bris de glace de base
* Pare-Brise avant

Options commerciale : Bris de glace « plus »
* Pare-Brise avant
* Vitre latérales et arrières
* Optiques

Objet assuré : conducteur
Options commerciale Accident corporels
* Arret de travail, indemnités journalières
* Frais médicaux.
Options commerciale : Décès
* Frais d’obsèques
* Préjudices économiques des ayants droits


Les divisions du produit d’assurance correspond à la notion de condition générale. Le choix des options commerciales dans un produit va définir les conditions particulières d’un assurés. Certaines options commerciales peuvent être obligatoires (au tiers) et d’autres peuvent être incompatibles (on ne peut pas vendre pour un même contrat une option Bris de glace de base et Bris de glace « plus »).

Principes d’informatisation de ces concepts

* Les informations de références – Les conditions générales
Les informations concernant les conditions générales doivent être enregistrés dans un domaine de la base particulier. On devra y retrouver le découpage complet d’un produit d’assurance, ainsi que la tarification associé à chaque garantie.

* L’enregistrement des contrats
Au moment de l’enregistrement d’un contrat on devra au préalable saisir les données du souscripteur du contrat. Ensuite on enregistrera le type de contrat (automobile, habitation etc…) avec les informations propres au contrat (par exemple date de souscription, mode de paiement, ….). Puis on saisira les informations concernant les objets assurés. Chaque type d’objet ayant des propriétés qui lui sont propres (une automobile aura une immatriculation, une date de mise en circulation, une marque, etc…. un conducteur aura un numéro de permis, une date de permis, un bonus/malus, etc….)
Les règles de compatibilités d’options commerciales doivent être gérée par le logiciel de gestion. Ce logiciels devra pouvoir enregistrer ensuite la ou les options commerciales associés au couple contrat/objet. Puis il reste à faire le total des primes des garanties et à rapporter le montant au niveau du contrat.

Persistance simple d’objet VCL en base SQL avec blob

Présentation d'une technique minimaliste de persistance d'objet en base SQL avec Delphi.

Pour cette technique on utilise la méthode d’un objet de classe TStream

function ReadComponent(Instance: TComponent): TComponent;
qui retourne un composant correspondant à l’instance décrite dans le flux TStream et la méthode

procedure WriteComponent(Instance: TComponent);
qui écrit un composant dans le flux.

Il existe dans Delphi une classe TblobStream qui permet l’enregistrement du flux dans un champ de type blob d’une base. Il suffit alors d’utiliser une instance de ce genre de flux pour enregistrer des objets en base.
La structure d’un enregistrement peut avoir la forme suivante :
Un identifiant (ID) (chaine de caractères ou entier en fonction des besoins) et un champ blob.