58

Programme z 050

  • Upload
    yomay

  • View
    221

  • Download
    0

Embed Size (px)

Citation preview

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 1/58

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 2/58

Actus 

Programmez N°50 • FÉVRIER 2003

Présentée comme une évolution naturel-le de Windows 2000, la nouvelle mou-

ture du serveur de Microsoft se veut un

environnement intégré et productif, digne de

confiance et ouvert. Le nouveau produit s’at-

taque en fait aux principaux défauts de Win-

dows 2000 et renforce la sécurité et la facilité

d’administration. Il étend les possibilités et

les scénarios d’utilisation, simplifie l’adminis-

tration et l’exploitation et comprend une nou-

velle approche de la sécurité. Pour y parvenir,

Microsoft a fait évoluer d’importantes briques

technologiques de son système, dont Active

Directory et IIS 6.0.

Intégration et ProductivitéLa productivité de la plate-forme concerne, de

prime abord, les administrateurs et les archi-

tectes. Ainsi 95 % des commandes sontaccessibles en ligne ou par scripts.

Les autres évolutions concernent l’annuaire

intégré. Désormais, les contrôleurs de domai-

ne d’Active directory maintiennent en cache

les groupes d’appartenance (forêts) des utili-

sateurs. Ces caches sont périodiquement

rafraîchis. Il est aussi possible de créer un

répliquat de l’annuaire sur un media amo-

vible. La gestion des attributs multi-valués

est différente et n’est plus limitée à 5000

membres par groupe. Il est aussi possible de

changer un membre d’un groupe sans refaire

une réplication complète comme auparavant.

Ces réplications, elles-mêmes, présentent

moins de contraintes liées au nombre de

sites.

Pour résoudre le souci de flexibilité qui ame-

SYSTÈME

Windows Server 2003 sur la rampe de lancementMicrosoft a confirmé les dates du prochain

lancement de la version 2003 de ses serveurs

.NET. La disponibilité commerciale a été arrêtée

pour avril prochain. Le produit est actuellement

en phase de tests, au stade de version pré

commerciale. Les principales améliorations et

innovations concernent Active Directory, l’annuaire

intégré dans le système d’exploitation, la gestion du

stockage et la sécurité du système d’exploitation, avec

de fortes évolutions du serveur Web IIS 6.0.

2

nait les architectes à créer le moins dedomaines et de forêts possibles dans les ver-

sions antérieures, un niveau de validation

Kerberos a été installé entre les forêts et une

version de Metadirectory Services 3.0 est

fournie.

Ces différentes fonctions permettent de

prendre moins de décisions irréversibles,

comme auparavant. Il est maintenant pos-

sible de renommer un domaine racine et de

renommer les domaines. Cela demande

cependant une interruption de services et des

contrôleurs de domaines. Il est aussi possible

de changer les schémas d’Active Directory. Par 

des partitions applicatives, Windows Server 

2003 autorise la réplication dans des fron-

tières différentes et de limiter ainsi la réplica-

tion de certains objets. Ainsi les fichiers, ou

données utiles à un groupe d’utilisateurs, ne

seront répliqués que dans les domaines utiles

à ce groupe spécifique et non dans tous les

domaines, comme auparavant. On voit ainsi

rapidement l’avantage pour les administra-

teurs, de cette fonction. L’annuaire supporte

les entrées dynamiques supprimées.

Fonction connue mais renforcée avec Group

Policy Management Console, les stratégies de

groupe centralisent les opérations de configu-

ration des postes et des serveurs. Certaines

SSII, comme Integris, l’utilisaient déjà pour 

leur offre de services de contrôle des configu-

rations par Serveur. Les possibilités sont

étendues dans cette version et simplifient lar-

gement l’administration de la plate-forme.

Ces fonctions s’accompagnent d’une impor-

tante amélioration des performances du ser-

veur (2,4 fois plus qu’avec Windows.NET),

jusqu’à 400 % d’amélioration sur unerecherche dans une sous arborescence dans

un annuaire LDAP.

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 3/58Programmez N°50 • FÉVRIER 2003

La PKI supporte les certifi-

cations croisées, édite des

modèles de certificats,

prend en charge le

séquestre et le recouvre-

ment des clés. L’authentifi-

cation entre les forêts de

l’annuaire sont sécurisées

par l’intégration de SSL. Les

utilisateurs contrôlés par 

les stratégies de groupe

sont enrôlés automatique-

ment.

Le serveur supporte aussi

les serveurs Radius. Pour 

les utilisateurs mobiles, une ré authentifica-

tion rapide s’effectue. Les utilisateurs non

authentifiés n’ont désormais qu’un accès res-treint. Enfin, les postes ne répondant pas à

certains critères de sécurité (présence d’un

firewall, d’un anti-virus) peuvent être mis en "

quarantaine ", par isolation des clients

RAS/VPN.

La disponibilité n’a pas été oubliée avec la

possibilité de clustering et de load balancing.

Cela devrait apporter normalement une stabi-

lité accrue de la plate-forme, même si Micro-

soft indique un taux de reboots non planifiés

de 24 %, ce qui semble tout de même beau-

coup !

System Event Tracker (SET) permet de suivre

les incidents et s’accompagne de Windows

Error reporting, un système de fiches d’inci-

dents permettant la construction d’une base

de connaissances. SET gère automatiquement

l’indisponibilité, si le problème et sa résolu-

tion sont connus.

Comparée à la première version de NT 4.0, la

montée en charge a été multipliée par 80,

capable donc de supporter des applications

critiques.

Windows Server 2003 se veut un système

ouvert sur l’extérieur par le support des stan-

dards des Web Services. Sur ce point, ladémonstration de Microsoft est moins

convaincante. Le logiciel intègre Windows

Une gestion de stockage revue et corrigéeLe stockage de la solution a été aussi amélio-

ré, avec plusieurs racines DFS (Distributed

File System) par serveur (seulement à partir 

de Enterprise Edition). Le serveur intègre dif-

férents points de montage pour le support de

clustering. Le support SAN a été amélioré

avec des propriétés de boot sur San et le sup-

port d’iSCSI. Le système prend en charge

aussi les priorités d’entrée/sortie pour rame-

ner en cache les fichiers avant un incident

d’alimentation.

Le système intègre de plus, Volume Shadow

Copy, un outil de snapshot, qui récupère la

version n-1 des fichiers modifiés et autorise

la sauvegarde de fichiers ouverts, permet-

tant une souplesse des fenêtres de sauvegar-

de. L’outil permet aussi de cloner desvolumes et de les déplacer sur un SAN ou un

autre serveur.

Le serveur comprend de plus un système

automatique de restauration et une interface

de virtualisation de disque. Cette API prend

en compte les couches basses, même en

direct Attached Storage. (DAS).

Une sécurisation accrueUn aspect important et novateur du serveur 

provient d’une sécurisation renforcée. La qua-

lité du code a été revue en même temps que

l’architecture. La surface d’attaque possible a

été réduite, avec une vingtaine de services

non installés par défaut. L’installation par 

défaut est la plus sécurisée. Ainsi, le serveur 

Web IIS n’est pas installé par défaut et il est

possible de bloquer son accès par des straté-

gies de groupe, par exemple.

Autre exemple, il n’est plus possible de réali-

ser des attaques par mot de passe à blanc.

Par défaut, seuls les logiciels dits de confian-

ce, ou explicitement désignés, peuvent s’exé-

cuter sur un poste client à partir du serveur.

Les procédures d’authentification forte,

comme les PKI, trouvent là une installation etune administration simplifiée avec une plus

grande intégration, avec Activ Directory.

Media 9.0 et un serveur de communication

temps réel sécurisé. Très " communicant ", le

serveur intègre la téléphonie, la vidéo confé-rence et le partage d’applications, et se fonde

sur le protocole SIP. Il intègre de plus, le ser-

vice Sharepoint qui sera aussi présent dans la

prochaine version d’Office, qui devrait voir le

jour à la fin du premier semestre 2003. Un

serveur DRM, Tungsten, permet de structurer 

la stratégie d’entreprise pour la classification

des documents. Il est ainsi possible de gérer 

les documents par niveau d’importance, avec

des classifications comme : confidentiel ou à

ne pas modifier.

Ces différents produits sont disponibles sépa-

rément. Ils représentent des fonctions supplé-

mentaires, mais non nécessaires au bon

fonctionnement du serveur.

Dernière innovation, et non la moindre, le ser-

vice Remote Desktop Connection 5.2 améliore

la gestion de la bande passante par rapport à

la version antérieure et permet, par exemple,

de désactiver les fonds d’écrans, les styles en

fonction du type de connexion. Le logiciel

sauvegarde les paramètres de connexion et

clarifie les messages d’erreurs possibles en

les rendant plus " lisibles " pour l’utilisateur.

Il accepte aussi la redirection des ressources

(audio, disques et imprimantes locaux ou

réseaux) les lecteurs de cartes à puces, les

périphériques port séries. Un avertissement

prévient l’utilisateur dans un cas de redirec-

tion de ressources.

A la fois plus simple et plus complexe, Win-

dows Server 2003 répond à bon nombre de

soucis connus des administrateurs et des uti-

lisateurs des versions antérieures. Cependant,

devant les innombrables innovations et chan-

gements dans le produit, même les spécia-

listes mettront du temps avant de dominer toutes les subtilités de la version.  

Bertrand Garé    13

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 4/58Programmez N°50 • FEVRIER 2003

I nterview 

La fin de l’année 2002 a été très riche

pour Parasoft, avec son ralliement au

framework Eclipse et le lancement du

projet Hyades, dans lequel l’éditeur est

impliqué. Par ailleurs, Parasoft a dévelop-

pé différents partenariats avec des éditeurs

de logiciels de développement d’applica-

tions embarquées. Un marché d’importan-

ce dans les années à venir, pour l’éditeur de Monrovia.

Le ralliement de Parasoft à la plate-forme

Eclipse (voir notre encadré) a trouvé rapide-

ment une application concrète, avec le lance-

ment d’un nouveau projet Open Source sur 

l’intégration de tests avancés et d’outils de

traçabilité pour la qualité des logiciels de dévelop-

pement, tout au long de leur cycle de vie. Ce projet

Hyades devrait rendre plus simple l’intégration

d’une large palette de fonctions de vérification, de

tests de qualité et de tests de charge pour la plate-

forme Eclipse et les outils associés. Ce projet est

une première pour établir un environnement " I*E "

ou Integrated Everything Environment. Ce projet va

mettre en œuvre un profil de test UML défini par 

l’OMG dans lequel le cas de test, la traçabilité du

test et les artefacts de vérification seront maintenus.

Parallèlement, l’éditeur a annoncé deux partena-

riats avec deux éditeurs de compilateur de sys-

tèmes embarqués. Parasoft fournira des outils de

tests pour les environnements embarqués en C et

C++ de Wind River et de Green Hill. Ces partenariats

représentent beaucoup pour Parasoft , qui voit

dans les systèmes embarqués un large marché

d’avenir.  

Bertrand Garé 

 Adam Kolawa est venu aux 

Etats-Unis de Pologne en 1983

pour poursuivre un Ph.D.

(doctorat) à l'Institut de

Technologie de Californie.

En 1987, lui et un groupe

d'étudiants de troisième cycle,

ont fondé Parasoft avec

l’intention de créer des produits

qui pourraient améliorer

significativement le processus

de développement logiciel.

Il a orchestré avec succès le

développement de plusieurs

produits logiciels commerciaux 

afin de faire face au besoin

croissant d’amélioration de

la qualité logicielle.

I nterview 

ADAM KOLAWA

Parasoft s’engage sur Eclipse etdans les outils embarqués

Trois questions à Adam Kolawa,président et fondateur de Parasoft 

1) Quels sont les intérêts à la f ois pour 

Eclipse et Parasof t de se rapproc her ? 

Pour Parasoft, Eclipse a de nombreuses fonc-

tionnalités que nous voulons ajouter à nos

produits, par exemple l’intégration avec le

contrôle des sources. Eclipse peut être aussi

utilisé comme interface principale. Ainsi nous

avons décidé que plusieurs de nos produits

n’auront pas d’interface utilisateur spécifique,

mais celle d’Eclipse. Ce sera le cas pour Jtest

5.0. Cela nous permet de gagner beaucoup de

temps et de nous concentrer sur notre métier :

le test, et non de dupliquer des travaux sur les

interfaces utilisateur. Pour Eclipse, L’intégra-

tion de nos outils va aider la plate-forme à

être plus compétitive. Nous allons contribuer à définir les cas de tests pour ce framework.

Notre expertise dans le domaine est reconnue.

Cela va permettre aux utilisateurs d’Eclipse de

créer et de conserver les tests dans tous les

outils coopérant avec Jtest. Les tests pourront

de plus être diffusés dans un format unique,

ce qui pourra aussi les aider dans leur tâche

quotidienne.

2) Pensez-vous que votre spécialisation

dans le test et le debugging va pouvoir 

apporter une avance technologique à Ec lip- 

se par r appor t au  x f r am ework s du marché ?

Nous le pensons vraiment. Eclipse sera la

première plate-forme dont les spécifications

de tests seront intégrées au produit. Cela

veut dire plus de test et de prévention deserreurs dans le code généré. En définitive,

cela va aider a créer du code de meilleure

qualité, ce qui pourra aider Eclipse à devenir 

encore plus populaire parmi les dévelop-

peurs. Cette intégration fait aussi d’Eclipse

un très bon outil pour l’Extreme Program-

ming et les unités de tests.

3) Quelle part allez vous prendr e dans la 

déf init ion des spéc if ications d’Eclipse ? 

Nous allons travailler sur les spécifications

des cas de tests sur le framework, ce qui

veut dire que nous interviendrons sur les

spécifications permettant de savoir com-

ment les cas de tests sont conservés dans

le framework, comment les tests sont exé-

cutés et de quelle manière les résultats sontutilisés ou déployés.

4

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 5/58

I nterview 

Programmez N°50 • FÉVRIER 2003

De quelle manière se positionne Micr osof t, avec sa 

double offre de systèmes embarqués 

( WindowsCE.NET et Win XP embedde d) ? Doit- on y 

v oir une déclinaison g r and public et une dé clinaison

professionnelle ? 

Avec Windows CE .NET et Windows XP Embedded,

Microsoft est en mesure de délivrer des plates-

formes adaptables et évolutives, destinées à despériphériques connectés 32 bits, qui autorisent des

applications et des services étendus. Les deux 

lignes de produits sont dédiées au marché des

développeurs professionnels.

Microsoft® Windows® CE .NET est le successeur de

Windows CE 3.0. Il constitue un robuste système

d’exploitation temps réel, ayant pour but de rapide-

ment construire la prochaine génération de termi-

naux mobiles et périphériques à faible

encombrement. Windows CE .NET fonctionne sur 

quatre familles majeures d’architecture et sur plus

de 200 types de processeurs, avec une utilisation

sur une large gamme d’équipements : PDA, client

“léger” Windows, Smartphone, tablette Web, péri-

phérique Internet, set-top box,

passerelle résidentielle, termi-

naux point de vente et périphé-

rique d’automation industrielle.

Etant donné la très grande modu-

larité de Windows CE .NET, la

taille qu’il occupe en mémoire

peut être facilement customisée

afin de répondre aux spécifica-

tions des différentes catégories

de matériels.

De plus, une amélioration mineu-

re nommée Windows CE .NET ver-

sion 4.1, ajoute des possibilités à

Windows CE .NET, comme le sup-

port du protocole IP v6, des

visionneuses de fichiers et le

nouveau client du système de

gestion de serveurs SMS 2003, ainsi que des correc-

tions liées à des " trous " de sécurité (Quick Fix 

Engineering ou QFEs).

En tant que successeur de Windows NT® Embedded

4.0, Windows XP Embedded est une version livréesous forme de composants de Windows XP Profes-

sionel, qui offre le développement accéléré de péri-

phériques complets et fiables. Basé sur les mêmes "

binaires " que Windows XP Professionel, Windows

XP Embedded autorise les développeurs à sélection-

ner uniquement les fonctionnalités à customiser, ce

qui réduit l’encombrement des périphériques

embarqués.

Windows XP Embedded avec son Service Pack 1

inclut de nouvelles fonctionnalités spécifiques etdes améliorations qui fournissent un déploiement

plus aisé et la gestion de périphériques puissants et

robustes. Cette version ajoute un nombre important

de nouveautés à la version originale de Windows XP

Embedded.

Le mar ch é des OS embarqués est très actif et la 

c oncurrence est rude. Entr e QN X, les OS Java, Linux 

embarqué, Symbian, PalmOS, de quelle manière 

Mic r osof t va-t-il se dif fér encier et sur quelle type de 

solutions ? 

Les produits de la ligne “Windows Embedded”

offrent des capacités de gestion temps réel, des

caractéristiques à la pointe des techniques

actuelles, une fiabilité nécessaire

aux systèmes embarqués ainsi

qu’une technologie éprouvée.

Ces systèmes d’exploitation ont

également rationalisé les outils

de développement, afin d’assurer 

une grande productivité et une

mise sur le marché accélérée aux 

fabricants d’équipements tiers

(OEMs) et aux développeurs, ce

qui répond à la demande grandis-

sante de périphériques embar-

qués spécialisés. Les outils de

développement simples à utiliser 

leur permettent de générer une

image-système embarquée en

moins de 30 minutes. Ces fac-

teurs combinés assurent à nos

clients une réduction du " Time to Market " et

accroissent leur retour sur investissement.

Les OS embarqués de Microsoft sont, de plus, suivis

par un support technique important et très dyna-

mique, qui inclut un vaste réseau de partenaires,une florissante communauté de développeurs et

une variété d’options au niveau du support et de la

Hardy Poppinga a rejoint l’équipe de Microsoft Embedded and AppliancePlatforms Group (EAPG)en tant que ResponsableProduit.

Hardy Poppinga tient lerôle de porte-parole dugroupe EAPG et est encharge des activitésMarketing en Europe.Ces activités comprennent les Relations Publiques, le

 Web Marketing, la Publicitéet l'Evénement dédié aux systèmes d’exploitationsEmbarqués que sont 

 Windows CE.NET et  Windows XP Embedded.

Hardy apporte à Microsoft EAPG plus de sept annéesd’expertise dans ledomaine du Marketing IT.Il a en effet récemment occupé la fonction deDirecteur Marketing deInterwoven, société éditricede logiciels de contenud’infrastructure, qui fournit plus de 700 compagnies,parmi les 2000 plusgrandes sociétés

mondiales. Hardy acommencé sa carrièredans le domaine deshautes technologies en tant que Directeur Général(pour l’Ouest des Etats-Unis) de OAR Inc.,un spécialiste dansle logiciel d'e-processus.

HARTMUT "HARDY" POPPINGA

La stratégie multiple des systèmesembarqués de Microsoft

6

 Bill Gates, Chairman

et architecte logiciel

en chef de Microsoft,

a dévoilé le premier 

 prototype d’un

lecteur media

 portable (PMP) basé 

 sur la plate-forme

“Media2Go” 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 6/58

formation. Ceci illustre l’engagement de nombreux 

intégrateurs, de fondeurs, de vendeurs indépen-

dants de logiciels et de matériels envers Windows

Embedded.

Av ec Smartphone 20 02, le TabletPC, Mir a, le Poc- 

ketPC, les syst èmes estampillés Micr osof t br assent 

l'ensemble des solutions g r and public et prof ession- 

nelles. Quels sont, selon vous, les mar chés les plus 

prometteurs pour 2003 et les anné es à venir et ceu  x 

au contraire qui risquent de stagner, voire de 

r égr esser ? 

La phase actuelle de l’évolution des périphériques

est caractérisée par une connectivité riche, des péri-

phériques intelligents et des utilisateurs expérimen-

tés. Des produits comme le SmartPhone, le Mira ou

le Pocket PC sont des exemples de tels succès dans

le monde de l’informatique embarquée. Durant saconférence au CES 2003, Bill Gates, Chairman et

architecte logiciel en chef de Microsoft, a dévoilé le

premier prototype d’un lecteur media portable

(PMP) basé sur la plate-forme " Media2Go ". Ces

périphériques permettent de se divertir n’importe où

en offrant à l’usager une solution simple, mais néan-

moins complète, pour télécharger, stocker puis

écouter et voir ses contenus numériques favoris,

qu’il s’agisse de vidéos, de morceaux musicaux ou

de photos.

Intelligents, périphériques et services connectés

simplifieront la vie quotidienne des utilisateurs en

révolutionnant la manière de rester en contact et de

s’amuser. Le logiciel continuera également d’amélio-

rer les périphériques utilisés tous les jours à la mai-

son. Microsoft Windows CE et Windows XP

Embedded autorisent déjà le développement rapide

de tels périphériques innovants.

Les prochains marchés à haut potentiel de croissan-

ce sont bien les périphériques mobiles, l’automation

industrielle, les points de vente, les serveurs dédiés,

les périphériques de jeux dédiés, ainsi que les

clients légers.

Grâce à TabletPC et dans une moindr e mesure Mir a,l'inf ormatique mobile est r éellement mobile. Le 

c oncept mêm e de l'or dinateur por table se modif ie 

grâce à des pr oduit s c omme le TabletPC. L'écr iture 

manuscr ite trouve enfin une utilisation pratique 

dans l'univers informatique. Malg ré tout, il manque 

encore une technologie à ce tableau : les t echnolo- 

gies vocales. Verra-t-on enf in dans les f utur s sy s- 

tèm es embarqués de v r aies f onctions vocales telles 

que la r econnaissanc e vocale ? 

Nous ne discernons pas actuellement une forte

demande en faveur de la reconnaissance vocale.

Néanmoins, Microsoft considère certaines caractéris-tiques de cette technologie pour ses produits Win-

dows embarqués.

.NET est au coeur de la stratég ie de 

Micr osof t depuis de nombr eu  x mois.

De quelle manièr e, .NET s'intègre et 

s'intégrera t’il dans les systèmes 

embarqués de Microsof t ? E  xiste-t-il 

des contraintes particulières pour 

mettre en oeuvre du .NET sur des 

solutions mobiles ? 

Microsoft .NET constitue un ensemble

de technologies logicielles destiné à

connecter notre monde d’informa-

tions, de personnes, de systèmes et

de périphériques. Il offre un niveau encore jamais

atteint d’intégration logicielle à travers l’utilisation

de services Web XML : petites, discrètes, ces appli-

cations d’un seul bloc se connectent entre elles et

avec des applications plus larges, via Internet. Les

logiciels bâtis autour de .NET délivrent ce dont lesdéveloppeurs ont besoin pour créer des services

Web XML et les intégrer. Les bénéfices pour tous

sont un partage de l’information plus fluide, moins

complexe. Les technologies .NET implémentées

dans Windows CE .NET incluent XML, SOAP, Pas-

sport, Windows Messenger et le framework compact

.NET qui augmente la productivité du développeur.

Livré en version beta avec Windows CE .NET, ce fra-

mework apporte un cadre applicatif et l’univers des

services Web aux périphériques intelligents, en y

autorisant l’exécution d’applications sécurisées et

téléchargeables. Les programmeurs peuvent aisé-

ment capitaliser sur 

leur expérience et

leur code existant

aussi bien sur le

périphérique embar-

qué, le PC ou l’envi-

ronnement serveur.

Visual Studio .NET

contient maintenant

les outils qui per-

mettent au dévelop-

peur de programmer,

corriger et déployer 

des applications

pour ces périphé-

riques spécifiques

compatibles avec ce

framework. Ces outils incluent des fonctionnalités

dédiées à ce type d’appareils pour Visual C# .NET et

Visual Basic .NET, des possibilités de débuggage à

distance, une émulation des périphériques et tout

un lot d’autres caractéristiques. La dernière version

de la plate-forme et de ses outils supporte Pocket

PC 2000, Pocket PC 2002 et les périphériques

embarqués basés sur la version à venir de WindowsCE .NET.  

Propos recueillis par François Tonic 

Programmez N°50 • FÉVRIER 2003

17

Le concept tabletPCrévolutionne l’ordinateur  portable dans son utilisation.

Emulateur WebPad 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 7/58

I nterview 

MS : Vous avez travaillé depuis de nombreuses 

années avec Micr osof t et ses techniques. Que possède 

donc de si spécial l’init iat iv e Microsof t .NET ? 

 JR : Chaque jour, j’effectue différentes tâches à l’aide

de l’Internet : rechercher des horaires de cinéma, trou-

ver un restaurant, commander un livre ou un CD audio,

payer une facture, etc. Bien que j’utilise l’Internet

depuis plusieurs années, je pense chaque jour à la

façon dont je m’y prenais pour effectuer ces tâches,

avant d’avoir recours à l’Internet. Sans aucun doute,

celui-ci m’a facilité la vie pour la découverte des

choses qui m’intéressent et se charge de mes activitésquotidiennes. L’initiative .NET se borne à trouver l’in-

formation dont vous avez besoin, quand vous en avez

besoin. Il est facile de voir comment l’initiative.NET

affecte tout un chacun dans sa vie quotidienne.

MS : Comment voy ez-v ous l’adopti o n de l’ini tiati ve.NE T ? 

 JR : La première étape consiste à rendre les informa-

tions disponibles sur l’Internet. Heureusement, beau-

coup d’entreprises ont déjà franchi cette étape. Il

existe de nos jours de nombreux sites Web offrant tous

types d’information. Hélas, ces informations ne peu-

vent être exploitées ou mises à jour par du code d’ap-

plication. La seconde étape consiste donc à offrir sur le

site Web une interface programmable (un service Web

XML) comme moyen d’accès à ces informations. La troi-

sième étape exige enfin que les développeurs créent

des sites et des applications Web, intégrant toutes ces

informations en appelant ces interfaces.

Le problème est qu’aucune entreprise ne souhaite

engager les dépenses nécessaires à la production

d’une interface programmable vers leurs données,

avant de trouver une autre entreprise souhaitant invo-

quer ces services. En revanche, bien sûr, le contraire

est également vrai : aucune entreprise ne peut

construire d’application accédant aux données, avant

l’existence d’une interface programmable. C’est pour-

quoi l’avènement des services Web XML risque d’être

lent : certaines sociétés vont devoir prendre quelques

risques, et il est délicat de justifier des ressources ainsi

mises en œuvre. Les services Web XML semblent

aujourd’hui particulièrement adaptés aux entreprises

souhaitant construire des applications consommant

leurs propres informations. Cela peut constituer un

paradigme de programmation très puissant, à envisa-

ger sérieusement. Une fois qu’une entreprise a exposé

des données pour sa propre consommation, il devient

enfantin de les exposer sur l’Internet. Je pense réellement que les services Web XML vont

devoir attendre un temps de lancement avoisinant les

deux ans. Au terme de ce délai, le recours aux services

Web XML devrait faire boule de neige et ne s’arrêtera

plus, alors qu’il deviendra de plus en plus facile pour 

chacun, de trouver et d’actualiser les informations qui

l’intéressent.

MS : Quel rôle joue le Mic rosoft .NET Fr amewor k dans 

ce monde dir igé par les services ? 

 JR : Le Microsoft .NET Framework sous-tend les abstrac-

tions de programmation offertes au développeur de

logiciel. Autrement dit, le .NET Framework fait de la

communication réseau et de l’envoi/réception de don-nées, un jeu d’enfant. Il peut toutefois faire bien plus

que s’occuper de réseaux. Sa conception, orientée

objet, facilite la programmation, tandis qu’il procure

des dispositifs pour travailler facilement avec des

bases de données, des données persistantes, la mani-

pulation de XML, etc.

Il pallie également un certain nombre de déficiences de

Windows, comme l’enfer des DLL (DLL Hell), les pro-

blèmes de version, la désinstallation, la sécurité et la

robustesse. Enfin, outre autoriser les développeurs à

construire des services Web XML, le .NET Framework

assiste également les développeurs, lors de la

construction d’applications et de sites Web.

MS : Votr e livre aide -t-il les lecteur s à devenir ef f icaces 

dans ce nouvel envir onnement de déve loppement ? 

 JR : Sans aucun doute ! Au cœur du .NET Framework,

réside le CLR (Common Language Runtime). Le CLR

définit la façon dont s’exécute le code, comment est

gérée la mémoire, comment les objets sont sérialisés

et chargés, comment sont gérés les threads et la sécu-

rité contrôlée, comment les erreurs sont signalées, le

mode de communication des objets entre eux, et bien

plus encore. Les développeurs doivent apprendre

comment le CLR expose ces concepts, afin de tirer 

réellement parti de cette nouvelle plate-forme de

développement, pour construire des services Web XML

ou des applications et des sites Web. Je me concentre

dans mon livre sur le CLR et sur ces sujets. J’ai été

consultant pour l’équipe Microsoft du .NET Framework

depuis octobre 1999. Au cours de ces années, j’ai

appris beaucoup, par expérience et en aidant les

autres. J’ai en fait travaillé sur le service Web Microsoft

TerraServer ( http://terraservice.net ). J’y ai incorporé

nombre de trucs et astuces exposés dans le livre. En

tant que membre de l’équipe, je suis également

capable d’expliquer pourquoi les choses ont été faites,telles qu’elles se présentent et quelles étaient les

motivations de Microsoft.

 Jeffrey Richter est l’auteur de

l’ouvrage Programmer Micro- 

soft .NET Framework, paru aux 

éditions Microsoft Press en sep-

tembre 2002.

Il est le cofondateur de Wintel-

lect ( www.wintellect.com),

entreprise de formation, de

conseil et de développement,

dont l'objectif consiste à aider

les entreprises à construire plus

rapidement des logiciels de

meilleure qualité. Il est par

ailleurs l'auteur de plusieurs

livres de programmation Win-

dows, comme Programming 

 Applications for Microsoft Win- 

dows et 

Programming Server-Side 

 Applications for Microsoft Win- 

dows 2000. Jeffrey écrit aussi

dans MSDN Magazine où il diri-

ge la rubrique .NET. Il est 

consultant dans l'équipe Micro-

soft .NET Framework depuis

octobre 1999.

JEFFREY RICHTER

Développer un état d’esprit .NET

Programmez N°50 • FEVRIER 2003

19

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 8/58

S écurité 

Programmez N°50 • FÉVRIER 2003

Quelques basesd'espionnageNous vous rappelons deux des aspects

réflexifs de Smalltalk.

Echange de référence. En utilisant la méthode

become:, il est possible de substituer toutes

les références pointant sur un objet par lesréférences pointant sur un autre et inverse-

ment. On dit qu'un objet devient un autre, car 

du point de vue du programme, une variable

pointant sur un objet, pointe sur un autre.

Dans l'exemple, après exécution de pt1 beco-

me : pt2, pt1 pointe sur pt2 et inversement.

|pt1 pt2|

pt1 := 0@0.

pt2 := 10@10.

Transcript show: 'pt1 ' ; show: pt1 printString; cr.

Transcript show: 'pt2 ' ; show: pt2 printString; cr.

pt1 become: pt2. "a partir d'ici pt1 pointe sur pt2 et

pt2 sur pt1"

Transcript show: 'pt1 ' ; show: pt1 printString; cr.

Transcript show: 'pt2 ' ; show: pt2 printString; cr.

Récupération d'erreur. Différentes possibilités

existent pour contrôler les messages envoyés

à un objet, et ainsi créer des messages asyn-

chrones, distribués ou outils d'espionnage

[Duca99]. Nous expliquons la méthode la plus

simple, qui est basée sur la récupération d'er-

reur. Lorsqu'un message m est envoyé à un

objet, si la classe ou superclasse de cet objet

n'implante pas cette méthode, la méthode

doesNotUnderstand: est invoquée sur l'objet

receveur du premier message. Par défaut, la

méthode doesNotUnderstand: lève une

exception, qui aboutit à l'ouverture d'un

débuggeur. En spécialisant cette méthode, on

peut donc contrôler les messages non com-

pris par un objet. Pour contrôler les méthodes

existantes, une des techniques est alors de

créer un objet minimal i.e., qui n'implante

que les méthodes vitales et donc invoque la

méthode doesNotUnderstand: pour toutes les

autres.En Squeak, la classe ProtoObject est

une classe minimale.

Espionnageen SqueakSqueak est un langage surprenant, aux capacités peu connues, etc’est bien dommage. Ce mois-ci, je vous montrerai de quelle

manière on peut créer des espions et outils intelligents. Codes à

ne pas mettre entre toutes les mains…

Un espionUn des exemples typiques d'utilisation du

contrôle de l'envoi de messages est d'espion-

ner des objets à des fins d'optimisation ou de

compréhension des applications. Nous allons

construire un espion très rudimentaire. Sau-

vez votre image avant toute exécution d'ob-jets nouveaux! L'idée est de définir un espion

et de le mettre à la place de l'objet que l'on

veut espionner. Pour cela, nous allons définir 

une sous-classe Spy de ProtoObject ayant

comme variable d'instance spyedObject, qui

représente l'objet espionné. ProtoObject est

une classe minimale, qui ne sait répondre

qu'à un nombre extrêmement limité de mes-

sages et génère des erreurs, que nous allons

capturer pour tous les autres messages.

ProtoObject subclass: #Spy_instanceVariable

Names: 'spyedObject '_classVariableNames:

''_poolDictionaries: ''_category: 'Scaffolding'

Définissez la méthode on: suivante :

Spy>>on: anObject

spyedObject := anObject

Spy>>doesNotUnderstand: aMessage

Transcript

nextPutAll: 'sel>>

'; nextPutAll: aMessage selector printString;

nextPutAll: '

args>> '; nextPutAll: aMessage arguments printS

tring; cr; flush.

^ spyedObject perform: aMessage selec

tor withArguments: aMessage arguments

Ensuite nous définissons la méthode de clas-

se on: qui installe l'espion.

Spy class>>on: anObject

| spy |

spy := self new.

spy become: anObject.

anObject on: spy.

^ anObject

Une fois l'expression spy become: anObject

executée, notez que la variable spy pointe sur 

l'objet et la variable anObject pointe l'instan-

ce de Spy nouvellement créée. Maintenant

ouvrez un Transcript (open...Transcript) etévaluez l'expression suivante dans un works-

pace (open...Workspace)

|t |

t := OrderedCollection new.

Spy on: t.

t add: 3.

t add: 5

Vous devez obtenir une trace des messages

envoyés.

RemarqueCette technique a les limitations suivantes:

on ne peut pas espionner les classes, car 

elles ne supportent pas de become:, ensuite,

si un objet envoie un message à l'espion, qui

lui le renvoie à l'objet espionné, et que celui-

ci retourne self, on peut alors envoyer des

messages à ce résultat et donc court-circuiter 

l'espion. De la même façon, si un objet

espionné est stocké dans une collectioncomme un dictionnaire, la différence entre les

nombres de hachage entre l'espion et l'objet

espionné, peut provoquer des comporte-

ments très étranges. De plus, les morphs ne

peuvent pas facilement être espionnés.

D'autres techniques plus lourdes existent

pour contrôler les objets [Duca99].

Une version plus sophistiquée de la méthode

doesNotUnderstand: peut aussi afficher quel

objet a envoyé le message espionné, grâce à

l'utilisation de la pseudo variable thisContext,

qui réifie à la demande la pile d'exécution.

Spy>>doesNotUnderstand: aMessage

Transcript nextPutAll: 'sel>> ' ; nextPutAll:

aMessage selector printString ;

nextPutAll: ' args>> '; nextPutAll: aMessa

ge arguments printString.

Transcript nextPutAl l : ' sent by ', thisCon

text sender printString ; cr; flush.

^ spyedObject perform: aMessage selec

tor withArguments: aMessage arguments

 A propos du Proxy.L'implantation du design pattern Proxy pro-

posée dans [AWB98] utilise les deux tech-

niques présentées (changement de référence

et récupération d'erreur). Nous décrivons suc-

cinctement l'idée et vous laissons l'implé-

menter. Un Proxy est un objet représentant un

objet complexe, auquel il délègue les mes-

sages le cas échéant. Pour son implantation

en Smalltalk, l'idée est que le proxy est un

objet minimal, qui génère des erreurs qui

sont capturées. Lors de la capture, l'objet que

le proxy représente va être créé puis substi-

tué, via become: au proxy. Ainsi toutes les

références au proxy sont mises à jour, seule-

ment lorsqu'une des fonctionnalités du Proxyest devenue nécessaire, et l'on évite de conti-

nuellement déléguer les messages. Imaginons0

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 9/58

que l'on ait la classe Image et une classe Ima-

geProxy, incluant des informations, afin de

créer une image comme un chemin de

fichier.La méthode doesNotUnderstand: res-

semblerait à la méthode suivante:

ImageProxy>>doesNotUnderstand: aMessage_

|image|

image := Image from: self path.

self become: image.

^self perform: aMessage selector

withArguments: aMessage arguments

Wrappers et ProxiesSqueak utilise cette technique (permutation

de pointeurs) dans la création de wrappers

(encapsulateurs ajoutant des comportements

à des objets) et de proxies (représentantslocaux d'objets distants). La classe ObjectOut

(sous-classe directe de ProtoObject, et non

d'Object), implémente un tel mécanisme. Un

ObjectOut est un représentant (que nous

appellerons Oo) en mémoire d'un objet (que

nous appellerons Oi, pour objet initial), qui a

été stocké sur disque, ou sur une machine

distante (par exemple pour libérer de la

mémoire), et qui n'est donc plus disponible

pour recevoir les messages qui lui sont adres-

sés. Lorsque Oi doit être déchargé de la

mémoire sur le disque, Oi est permuté avec

Oo, et l'URL sur lequel a été stocké Oi est

affectée à Oo. Toutes les variables qui poin-

taient sur Oi pointent désormais sur Oo. Oi

n'étant plus référencé, il est détruit lors du

passage du ramasse-miettes.

Lorsque les accointances de Oi, ignorant sa

disparition de la mémoire, lui envoient un

message, ce message parvient en fait à Oo.

Oo n'implémentant pas la méthode corres-

pondante (le sous-classement de ObjectOut

sous ProtoObject garantissant que Oo ne ®

comprend ̄ vraiment rien), la machine virtuel-

le déclenche la méthode doesNotUnders-

tand:, qui est redéfinie à ce niveau, pour 

prendre en charge le rechargement de Oi

depuis le disque, comme le décrit la méthode

doesNotUnderstand: de la classe ObjectOut

ObjectOut>>doesNotUnderstand: aMessage

| realObject oldFlag response |

oldFlag := recursionFlag.

recursionFlag := true.

realObject := self xxxFetch.

oldFlag == true

ifTrue: [response := (PopUpMenu labels: 'pro

ceed normally\debug' withCRs)

startUpWithCaption: 'Object being fetched for a second time. Should not hap

pen, and needs to be fixed later.'.

response = 2 ifTrue: [self halt]].

^ realObject perform: aMessage selector withArgu

ments: aMessage arguments

L'opération essentielle se passe à la ligne 5.

La méthode xxxFetch reconstruit l'objet depuis

le disque, et effectue les permutations de

pointeurs adéquates (par l'intermédiaire de la

méthode xxxFix). Le message d'origine (aMes-

sage, en argument de doesNotUnderstand:)

est alors exécuté par l'objet reconstruit (ligne

10, la méthode perform: aSelector withArgu-

ments: anArray demande l'envoi du message

aSelector, avec les arguments spécifiés dans

un array). La technique des espions, que nous

avons présentée précédemment, est aussi utili-

sée en Squeak. par les classes ObjectTracer et

ObjectViewer. ObjectTracer ouvre un inspecteur 

sur chaque message reçu par un objet, tout enpermettant à ce message de s'exécuter norma-

lement. Il s'agit d'un wrapper (installé à l'aide

du message on: objetAEncapsuler envoyé à la

classe ObjectTracer), il capture les messages

mais lui retransmet (ligne 7) :

ObjectTracer>>doesNotUnderstand: aMessage

"Ceci est la définition sur ObjectTracer"

Debugger

openContext: thisContext

label: 'About to perform: ' , aMessage selector

contents: thisContext shortStack.

^ aMessage sentTo: tracedObject

ObjectViewer, au contraire, vient remplacer 

l'objet qu'il encapsule, grâce au become:.

Prenons un exemple illustratif de la puissance

de ce concept :

Considérons une application de plusieurs

centaines de milliers de lignes, dans laquelle

un tableau de trois éléments est créé, dans

lequel deux éléments sont insérés (t := Array

new: 3. t at: 1 put: 4. t at: 2 put: 5.). Nous

souhaitons être informés dès que le troisième

élément est ajouté au tableau, afin d'effectuer 

certaines opérations, ou simplement tracer 

les utilisations du tableau. Mais nous ne

savons pas où cet ajout va avoir lieu dans les

centaines de milliers de lignes de code de

l'application (cas malheureusement très cou-

rant dans une application réelle). La méthode

evaluate: unBloc wheneverChangeIn: unAutre-

Bloc, définie sur Object, nous permet d'effec-

tuer cette surveillance : après l'exécution de t

evaluate: [Transcript cr; show: (t at: 3)] whe-

neverChangeIn: [t at: 3], toute modification de

la valeur de la troisième cellule de t (par 

exemple t at: 3 put: 7) provoque l'évaluation

du premier bloc, qui effectue l'affichage de lanouvelle valeur dans le Transcript.

Ce mécanisme, d'apparence quelque peu

magique, fonctionne en fait assez simple-

ment : la méthode evaluate:wheneverChan-

geIn: est définie de la façon suivante (notez

l'utilisation du become: en ligne 5):

Object>>evaluate: actionBlock wheneverChangeIn:aspectBlock

| viewerThenObject objectThenViewer |

objectThenViewer := self.

ViewerThenObject := ObjectViewer on: object

ThenViewer.

objectThenViewer become: viewerThenObject.

objectThenViewer

xxxViewedObject: viewerThenObject

evaluate: actionBlock

wheneverChangeIn: aspectBlock

Lorsque le tableau t, devenu un ObjectViewer,

recoit le message at: 3 put: 7, il ne le com-

prend pas, et la méthode doesNotUnders-

tand: est déclenchée.

ObjectViewer>>doesNotUnderstand: aMessage

| returnValue newValue |

aMessage lookupClass: tracedObject class.

recursionFlag

ifTrue: [^ aMessage sentTo: trace

dObject].

recursionFlag := true.

returnValue := aMessage sentTo: tracedObject.

newValue := valueBlock value.

newValue = lastValue

ifFalse: [changeBlock value.

lastValue := newValue].

recursionFlag := false.

^ returnValue

Le message à exécuter est transmis à l'objet

encapsulé (lignes 5-7). Le bloc de test de

changement est évalué (ligne 8). S'il y a un

changement, le bloc de changement est éva-

lué à son tour (ligne 10). Bug ! Pour tester cet

exemple, il a été nécessaire de corriger ce qui

semble être un bug dans la livraison Squeak

utilisée. La ligne 3 a dû être ajoutée. En effet,

la méthode sentTo: teste la présence de la

lookupClass (la classe à partir de laquelle va

commencer la recherche de la méthode à utili-

ser) du message (qui se trouve ici être Object-

Viewer) dans la hiérarchie du receveur, avant

d'autoriser l'exécution du message. Il est

donc nécessaire de réaffecter la classe de

l'objet encapsulé dans la variable lookup-

Class. Pour annuler l'espionnage d'un objet, il

suffit de lui envoyer le message xxxUnTrace.

Comme l'illustrent ces exemples, la réflexivité

est un outil très puissant pour la construction

d'outils, ou l'introduction de fonctionnalités

depuis l'intérieur même du langage. Nous

n'avons pas eu besoin de changer le compila-

teur ou d'utiliser un pré processeur. Dr. Stéphane [email protected]://www.iam.unibe.ch/~ducasse/ 

Programmez N°50 • FÉVRIER 2003

21

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 10/58

Développement de “Plankalkül” par l’ingénieur allemand Konrad Zuse, inventeur 

du premier calculateur programmable universel non spécialisé, le Z3, en 1941. Ilapplique son langage, entre autres, au développement d’un jeu d’échecs. Ce lan-gage ne sera jamais appliqué sur un ordinateur.En savoir plus : http://ei.cs.vt.edu/~history/Zuse.html

1946

D

O

S

S

I

ER 

Programmez N°50 • FEVRIER 2003

Historique Prospective

Passé, présent et futur :

des langages etdu développement

Un numéro 50 cela se fête ! La rédaction de Programmez a décidé de vous proposer 

un grand dossier qui a l’ambition de vous faire un historique des langages et du déve-

loppement en 100 dates : les 50 dates incontournables et les 50 dates qui le sont un

peu moins ! Si vous voulez épater des amis et être l’intellectuel (le) de la soirée, ce dossier est

fait pour vous ! Cela ne fait pas de mal de revoir de temps en temps les fondamentaux de l’in-formatique : les grandes dates, les grands hommes, les grands penseurs.

C’était aussi l’occasion de faire un point. Que nous réserve l’année 2003 et le futur à 3, 5 ou

10 ans ? La prospective dans l’univers informatique n’est jamais chose aisée. Et le magazine

n’a pas vocation à devenir un nouveau Nostradamus. Cependant, il y a quelques tendances

d’aujourd’hui qui peuvent nous aider à entrevoir ce que pourrait être la programmation de de-

main (après 2003). Si le service Web sera la grande vedette, pour l’avenir plus lointain, tempé-

rons notre ardeur.Nous avons demandé à plusieurs consultants de nous livrer leurs réflexions.

La rédaction vous livrera aussi les siennes. La diversité des réflexions peut vous permettre de

mieux comprendre les éléments clés et les mouvements technologiques d’aujourd’hui qui se

confirmeront sans doute demain.

Bon retour vers le passé… et le futur. François Tonic 

 N U M E R O

 5 0

2

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 11/58Programmez N°50 • FEVRIER 2003

23

Développement de “Plankalkül” par l’ingénieur allemand Konrad Zuse, inventeur 

du premier calculateur programmable universel non spécialisé, le Z3, en 1941. Ilapplique son langage, entre autres, au développement d’un jeu d’échecs. Ce lan-gage ne sera jamais appliqué sur un ordinateur.1946

•   Introduction ..........................................................................................................................................................................................................p 22

• Les 50 dates clés ................................................................................................................................................................................................p 24

• Les autres événements ................................................................................................................................................................................p 34

• Petite généalogie ................................................................................................................................................................................................p 36

• Quelle tendance pour l’informatique en 2003-2004 ........................................................................................................p 37 

• Risque et opportunité ....................................................................................................................................................................................p 38

• I’ll be back .................................................................................................................................................................................................................. p 39

• Perspectives technologiques ....................................................................................................................................................................p 40

• Le magazine qui parle votre langage.................................................................................................................................................. p 42

          S

          O          M          M          A          I          R          E

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 12/58Programmez N°50 • FEVRIER 2003

Les 50 dates clés

4

Historique Prospective

" La meilleure façon de prédire le futur est de l’inventer "  Alan Kay

C’est par cette citation d’Alan Kay, créateur dulangage Smalltalk et initiateur de nombreusesavancées informatiques majeures, que nous

ouvrons ce dossier anniversaire. En effet, quellemeilleure illustration du fourmillement d’idées etd’innovations généré par la création et le dévelop-pement des langages de programmation ?

Il n’est d’ailleurs pas aisé de choisir 50 dates cléspour ce cinquantième numéro de Programmez!tant les événements liés aux langages de pro-grammation et à l’informatique en général ont éténombreux depuis le début des années 40. Mêmesi de grands esprits tels que John Napier, BlaisePascal, Charles Babbage, Ada Lovelace ou encoreGeorges Boole ont défriché les bases de l’informa-tique, nous avons délibérément décidé de ne pasremonter aussi loin et de nous concentrer sur ladernière moitié du XXème siècle.

Toutefois, nous mentionnerons tout particulière-ment Muhkamad ibn Musa al’Khowarizmi, cesavant qui développa, au neuvième siècle, le

concept d’une série d’instructions à suivre pour atteindre un but. Lady Ada Lovelace (voir encadré)lui rendra d’ailleurs hommage, en nommant le pro-cessus logique de fonctionnement d’un program-me " Algorithme ".

De fait, il est communément admis que la secondeguerre mondiale a considérablement accéléré lesétudes dévolues à la programmation, discipline quidevait aboutir à la création d’une nouvelle indus-trie quelques années plus tard et changer consi-dérablement le visage de notre Société.Programmez! étant un magazine essentiellementdédié aux langages, nous nous sommes doncconcentrés sur 50 faits véritablement marquantsqui ont façonné la discipline la plus noble de l’in-formatique. Forcément subjective, cette liste n’estévidemment pas exhaustive, mais vous offre desjalons majeurs, complétés par 50 autres dates,vous rappelant d’autres faits se rapportant aux systèmes d’exploitation ou aux logiciels.

De la première ver-sion de l’assembleur à C# en passantpar APL, ALGOL,SIMULA, PASCAL,C++, PYTHON ouencore PHP,

vous constate-rez qu’en finde compte,seules deux grandes classesde langages ontémergé et emportentactuellement les suffragesdes professionnels : les langages fonctionnelscomme LISP ou PROLOG, plutôt dédiés à l’intelli-gence artificielle et les langages impératifs tels quePASCAL ou BASIC, qui se sont très largement impo-sés avec une orientation objet de plus en plusmarquée chez leurs descendants tels que C++ ou Java.

Et si programmer constitue votre pain quotidien,vous vous rappellerez avec nostalgie ou amuse-ment Madame le Capitaine Grace Hopper qui, alorsqu'elle programmait le MARK-I en juin 1944, pre-mier ordinateur électromécanique, eut à résoudrele premier bug de l'histoire du logiciel. La légenderapporte en effet qu’un papillon s’était infiltré àl’intérieur d’un relais et avait littéralement grillé,provoquant l’arrêt dudit ordinateur ! Depuis lors,tous les programmeurs du monde débugguent, leterme " bug " désignant en anglais un insecte ou

un coléoptère. Bon retour vers le passé !  

1843 : Lady Lovelace,premier programmeurOn doit à Augusta Ada LovelaceByron, fille du poète Lord Byron, ladescription systématique de la calcu-latrice analytique de Babbage. Cettedescription publiée en 1843, préfigu-re l'informatique moderne. On luireconnaît l'écriture des premiers pro-grammes, comme celui du calcul des nombres deBernoulli (calcul exponentiel et infinitésimal) et desnotes sur l'utilisation répétitive de séries de cartes demêmes instructions, préfigurant les sous-routines quel'on connaît dans la programmation moderne sous lenom de boucles et de branchements. Le langage ADAa été dénommé en son honneur.www.scedu.umontreal.ca/sites/histoiredestec/histoire/tdmhiste.htm

D

O

S

S

I

ER 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 13/58Programmez N°50 • FEVRIER 2003

Développement de “Plankalkül” par l’ingénieur allemand Konrad Zuse, inventeur 

du premier calculateur programmable universel non spécialisé, le Z3, en 1941. Ilapplique son langage, entre autres, au développement d’un jeu d’échecs. Ce lan-gage ne sera jamais appliqué sur un ordinateur.En savoir plus : http://ei.cs.vt.edu/~history/Zuse.html

 John Backus d'IBM crée le premier langage de programmation universel évolué, leFORTRAN pour FORmula TRANslator. Mis au point sur un IBM 701, c'est le premier langage informatique de haut niveau, c'est à dire qu'il nécessite un programmeintermédiaire (le compilateur) qui le traduit en instructions compréhensibles par l'ordinateur. L'avantage est que le programme en FORTRAN est indépendant de la

machine, il suffit d'avoir le compilateur adapté. A l’heure actuelle, il est encore uti-lisé dans les domaines scientifiques et techniques.En savoir plus : http://www2.cnam.fr/~lignelet/manuel_f95.html

 John Mc CARTHY, mathématicien fondateur en 1957 du département d'Intelligenceartificielle du MIT, invente le LISP, abréviation de LISt Processing. Ce langage de"traitement de listes" va avoir un impact considérable dans le domaine de laprogrammation objet.En savoir plus : http://www.lisp.org

G. Hopper, décidément très prolifique, met au point le COBOL pour COmmonBusiness-Oriented Language. Sa consécration par le Département de la Défense

américain, qui l'a déclaré indispensable, l'accent qu'il met sur les structures dedonnées et sa syntaxe proche de l'anglais, en ont fait un langage largement utili-sé, particulièrement dans les applications commerciales.Ce langage procédural classique permet d’écrire des programmes composés de 4divisions distinctes qui peuvent comporter des sections : identification, environ-ment, data, procedure. COBOL définit précisément le matériel et les formats d’en-trées et sorties de données et introduit la structure de données RECORD.En savoir plus : http://www.infogoal.com/cbd/cbdhome.htm

A la suite d'une conférence entre Américains et Européens, germe en 1958 uneidée de langage de programmation universel, l'ALGOL 58, contraction de ALGO-rithmic Language. Mais, c’est véritablement l’année 1960 qui marque l’avènementde ce langage, avec l’apparition de ALGOL-60, premier membre de la famille des

langages structurés.C'est le premier langage universel indépendant de la machine, qui introduit lagrammaire BNF (Backus Naur Form) pour réaliser un parseur de syntaxe, la struc-ture de blocs d’instructions et les variables locales aux blocs, ou la récursivité. Ilutilise également des tableaux dynamiques et on peut constater que les langagessuivants, comme Pascal et C, ont donc régressé en utilisant des tableaux sta-tiques pour des raisons de performance. On y trouve aussi le IF THEN ELSE, unFOR assez général, le symbole d'affectation :=, un SWITCH avec des gotos, lesdélimiteurs BEGIN END ainsi que le WHILE.Algol 60 restait un langage orienté vers le calcul mathématique. Pour revenir àl'objectif de langage général, une nouvelle version a été décidée en 1964, l'AlgolX, devenu ensuite Algol 68, qui utilisait =+ pour combiner l'affectation et l'addi-tion. Il apportait la structure d'union et le cast de type. Il ajoute entre autres le

CASE, le GOTO, des opérateurs définissables par l'utilisateur.

1946

1956

1959

1960

25

N U M E R O 

50 

Konrad Zuse

 John Backus

Grace Hopper 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 14/58

D

O

S

S

I

ER 

Programmez N°50 • FEVRIER 2003

6

Historique Prospective

Apparition officielle de PL/I, un langage dont l’une des particularités, hormis sacomplexité, est de ne pas comprendre de mots réservés. Créé par IBM, ce langa-ge assez universel, qui couvre à la fois le champ d'intérêt du FORTRAN et duCOBOL, sera critiqué à cause de son accès difficile.En savoir plus : http://www-3.ibm.com/software/ad/pli/ 

1964

Les professeurs John G. KEMENY et Thomas E. KURTZ de l’université de Dartmou-th inventent le BASIC pour Beginner's All-purpose Symbolic Instruction Code. Il aété conçu en 1963 pour être facile à apprendre et implémenté en 1964/65. La pre-mière version était compilée, puis il est devenu interactif et interprété. Chaqueligne était numérotée pour permettre les branchements par la fameuse instruc-tion GOTO !Ce langage constituera le point de passage obligé de dizaines de milliers de pro-

grammeurs pendant des années, de par sa simplicité d’accès et sa disponibilitésur les principaux systèmes d’exploitation. Microsoft le popularisa dès la créationde la société en 1975 et le renouvellera en 1991 avec la sortie de Visual Basic. Sesversions initiales n'étaient ni structurées ni compilées, alors que les plus récentessont toujours structurées et souvent compilées.En savoir plus : http://www.digitalcentury.com/encyclo/update/kemeny.html

1965

Seymour Papert invente le langage LOGO. Destiné à apprendre la programmationaux enfants, il est proche de Lisp et basé sur le déplacement d'une "tortue" sur l'écran. En France, ce langage se répandra dans les années 80 du fait de sonimplémentation sur la gamme familiale Thomson TO 7 qui sera déployée dans lesécoles.

En savoir plus : http://el.media.mit.edu/logo-foundation/logo/language.html

1966

Le langage SIMULA 67 fut créé par Ole-Johan Dahl, Kristen Nygaard au NorwegianComputing Centre (NCC) à Oslo entre 1962 et 1967. Le but était d'en faire un outilde description de système d'événements discrets ou de réseau, ainsi qu’un lan-gage de programmation de simulation. Il était conçu comme une extension aulangage Algol. Ensuite, son périmètre fut étendu pour devenir un véritable langa-ge d’utilisation générale.Quoique SIMULA n’ait jamais été largement exploité, il a influencé les méthodesmodernes de programmation, en introduisant des concepts importants de la pro-grammation objet, comme les classes, les objets, l’héritage ou le binding dyna-

mique.En savoir plus : http://java.sun.com/people/jag/SimulaHistory.html

1967

Niklaus Wirth crée le langage PASCAL, du nom du mathématicien français BlaisePascal. Ce langage est initialement destiné à l'enseignement et oblige à une pro-grammation structurée. L'UCSD Pascal est la première version sur micro ordina-teur, réalisée par un groupe de programmeurs dirigé par Kenneth Bowles. Ilcompile les programmes en p-code, qui est interprété et portable (comme plustard Java). Il comporte un environnement de développement complet, idée repri-se plus tard avec succès par Turbo Pascal. En 1981, un jeu de rôle écrit en Pascal,Wizardry, connaît un grand succès sur Apple II. C'est avec l'apparition de TurboPascal en 1983, popularisé par Borland, rapide et doté d'un IDE complet, que lelangage s'est répandu.

En savoir plus : http://www-ipst.u-strasbg.fr/pat/program/pascal.htm

1970

ALGOL constitue donc l’ancêtre d’une famille de langages, parmi lesquels ontrouvera plus tard PASCAL, C ou encore ADA. Très théorique, ce langage sera enfin de compte peu utilisé mais très étudié comme modèle.En savoir plus : 

http://www.engin.umd.umich.edu/CIS/course.des/cis400/algol/algol.html

 John Kemeny 

Seymour Papert 

Kristen Nygaard 

Niklaus Wirth

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 15/58Programmez N°50 • FEVRIER 2003

27 

Quasi parallèlement à la création d’UNIX, écrit en assembleur par Ken Thompson,un autre programmeur de Bell Labs, Dennis Ritchie utilise le langage BCPL (déve-loppé en Grande Bretagne, dans une université), mais le trouve inadapté à sesbesoins. Il va réécrire un langage sur la base de BCPL, et l’appellera B (vraisem-blablement la première lettre de BCPL). B ne sortira jamais officiellement des

tiroirs de Dennis Ritchie; aidé par Brian Kernighan, B va connaître un nouveaudéveloppement avec le langage C.En savoir plus : http://cm.bell-labs.com/cm/cs/who/dmr/kbman.html

Les bases du Standard Query Language, autrement dit SQL, sont posées par ledocteur Ted Codd d’IBM. Il propose une nouvelle manière d’aborder les traite-ments automatiques de l’information, en se basant alors sur la théorie de l’al-gèbre relationnel (théorie des ensembles et logique des prédicats). Uneproposition sera faite, pour garantir une plus grande indépendance entre la théo-rie et l’implémentation physique des données dans les machines.La première réalisation connue sous le nom de SQL (82) voit le jour après l’arri-vée de DB2, une avancée significative du System R d’IBM datant de 1979. Le lan-gage SQL est véritablement né en 1979, mais baptisé SQL en 1982. Et c’estcomme ça que vont naître, vers la fin des années 1970 et le début des années

1980, les premières applications, basées sur la proposition du docteur Ted Codd,connues de nos jours sous l’acronyme SGBDR. SQL sera normalisé en 1986 (SQL86 - ANSI), 1989 (ISO et ANSI) et 1992 (SQL 2 - ISO et ANSI). Néanmoins, la ver-sion SQL 2 (1992) est la version vers laquelle toutes les implémentations tendent.En savoir plus : http://ugweb.cs.ualberta.ca/~c391/manual/chapt6.html

1970

Charles H. Moore crée le langage FORTH, initialement nommé Fourth mais réduità Forth pour la contrainte des 5 lettres de l’IBM 1130. Ce langage d’Astronomie,qui utilise une pile à la place des variables, a été défini dans les années 60 maisimplémenté seulement en 1971. Il se voulait être un langage de 4ème génération,d'où son nom. Malheureusement, Forth n'a rien d'intuitif.En savoir plus : http://c2.com/cgi/wiki?ForthLanguage

1971

Le mythique langage C, créé par Dennis Ritchie et Brian Kernighan, est encoreaujourd’hui une référence pour tous les programmeurs. D’où vient son nom ? Dif-ficile de dire à priori si C représente la lettre venant après B dans l’alphabet, ou ladeuxième lettre de BCPL (cf. l’année 1970 avec le langage B). C’est à peu près àcette période que Dennis Ritchie parvient à persuader Ken Thompson de réécrireUnix sur une machine plus performante : un PDP 11. Pour ce faire, au lieu d’utili-ser l’assembleur, on va utiliser le langage de Ritchie :C. Cette décision est àconsidérer comme un des plus importants tournants de l’histoire de l’informa-tique : pour la première fois, on va créer un système d’exploitation écrit dans unlangage indépendant de la machine cible, portable au niveau source. Cette gran-de première va faire le succès de UNIX, et par corollaire, le succès de C.En savoir plus : http://cm.bell-labs.com/cm/cs/who/dmr/chist.html

Le langage PROLOG, signifiant PROgrammer en LOGique, est bâti sur l’idée d'uti-liser la logique comme langage de programmation et se place comme un langagedit "descriptif de l'Intelligence Artificielle". Parmi les premiers à développer cetteidée figurent Robert Kowalski (aspects théoriques) et Maarten van Emden(démonstration expérimentale) tous deux à Edimbourg, et Alain Colmerauer àMarseille (implémentation). PROLOG se dit déclaratif, parce que son systèmed'inférences logiques constitue un mécanisme de résolution.La popularité actuelle de PROLOG est en grande partie due à l'efficacité de l'im-plémentation réalisée par David Warren à Edimbourg au milieu des années 70.PROLOG a été standardisé en 1996 mais il existe de nombreuses extensions dontProlog II, Prolog III, lambda-Prolog, ...

En savoir plus : http://www710.univ-lyon1.fr/~nguin/Prolog/Cours/Prolog1.pdf 

1972

N U M E R O 

50 

Blaise Pascal 

Brian Kernighan

Ted Codd 

Charles Moore

Dennis Ritchie

 Alain Colmerauer 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 16/58

D

O

S

S

I

ER 

Programmez N°50 • FEVRIER 2003

8

Historique Prospective

SMALLTALK, premier véritable langage orienté objet, est créé au Xerox Palo AltoResearch Center (PARC). Les racines de ce langage ont été explorées lors du pro-jet Dynabook, mené principalement par Alan Kay, vision d’un PC portable peucoûteux, destiné aux adultes et aux enfants. Avant de rejoindre le PARC, Kay tra-vailla à l’université de l’Utah, où il faisait partie de l’équipe en charge du déve-

loppement du système de programmation Flex, nouveau concept dérivé deslangages SIMULA et SKETCHPAD. Malheureusement, l’extension de sesrecherches était à l’époque bien au delà des capacités de la technologie…SMALLTALK, le langage de programmation du Dynabook, fut initialement conçucomme un outil ne nécessitant aucune connaissance en informatique, d’où lenom du langage. Sa première version était constituée par un millier de lignes enBASIC et fut rapidement suivie par une implémentation en code assembleur nom-mée SMALLTALK-72, dirigée par D. Ingalls. En 1974, le langage fut porté sur l’or-dinateur Alto puis son successeur, SMALLTALK-76, se verra adjoindre la notiond’héritage. Enfin, la version " 80 " fut la première à être disponible en dehors deXerox.En savoir plus : http://www.smalltalk.org/ 

1972

CP/M-DOS est créé par Gary KILDALL. Control Program for Microcomputers - Disk

Operating System est de fait le premier système d'exploitation pour micro-ordina-teurs (8080 d'Intel). C'est aussi l'inspirateur du QDOS de Tim PATERSON quideviendra par la suite MS-DOS.En savoir plus : http://www.digitalcentury.com/encyclo/update/kildall.html

1974

Apparition du langage AWK tiré des initiales de ses concepteurs, Aho, Weinberger et Kerninghan. AWK est un langage de traitement de texte, basé sur des expres-sions régulières, fonctionnant selon le principe pattern-action. En 1985, une nou-velle version de AWK fut introduite avec des fonctions pouvant être définies par l’utilisateur, des expressions régulières plus étendues et des entrées de donnéesmultiples. Elle se déploya avec Unix system V release 3.1. Beaucoup voient enAWK le père de PERL, langage bien plus répandu que ce dernier.

En savoir plus : http://www.cs.uu.nl/docs/vakken/st/nawk/nawk_toc.html

1978

ADA est conçu par un groupe de travail " the green team " de la CII- Honeywell-Bull, sous la direction du français Jean Ichbiah, suite à un appel d’offres de l’ar-mée des Etats-Unis, qui souhaitait standardiser le développement de sesprogrammes informatiques. En effet, en 1974, le département de la Défense amé-ricain prend conscience qu'il dépensait des sommes excessives en maintenance,pour les applications destinées à des systèmes embarqués. Il lance alors unappel à développement d'un cahier des charges qui permette de définir un langa-ge robuste, fiable. Et c’est donc Jean D. Ichbiah et son équipe qui produiront lecahier des charges final…Ce langage tire en fait sa dénomination du prénom de la comtesse Ada Byron deLovelace, première femme à programmer la machine analytique de Charles Bab-bage, et s’inspire de Pascal et Algol W. La grande nouveauté réside dans l’intro-

duction de la généricité des algorithmes, les paquetages, les modulesindépendants ainsi qu’une sorte d’orientation objet primitive. ADA deviendrad’ailleurs " orienté objet " par la suite, après l’apparition de C++.En savoir plus : http://www.adapower.com/

Le créateur de PASCAL, Niklaus Wirth, lance MODULA 2 pour MODUlar LAnguage.La première version aurait été définie en 1977 et implémentée sur station de tra-vail Lilith à l'origine. L’idée du langage est de réduire le risque d’erreur avec desrègles de programmation coercitives. Cependant, il se rapproche du langage C,en tentant de combler les lacunes de Pascal. Il sera peu utilisé hors du cadre uni-versitaire, parce que ses améliorations (modules, accès matériel) ont été ajoutéesaux distributions de Pascal (avec les units de Turbo Pascal). Une nouvelle version,MODULA 3, a été proposée par un groupe de chercheurs en 1988.

En savoir plus : http://www.engin.umd.umich.edu/CIS/course.des/cis400/modu-la2/modula2.html

1979

 Alan Kay Doug Engel Bart 

Gary Kildall 

Charles Babbage

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 17/58Programmez N°50 • FEVRIER 2003

29

Le langage de programmation REXX a été développé par Mike Cowlishaw d'IBMvers 1979. Originalement baptisé Rex ("Roi" en latin), le langage est maintenantdisponible sur la plupart des systèmes d'exploitation, à l'exception notable duMac OS.Le langage REXX est un langage de programmation structuré, simple à apprendre,

mais puissant, se prêtant bien à l'automatisation de tâches accomplies par lesystème d'exploitation. Contrairement à la plupart des langages de programma-tion courants, le Rexx n'est pas compilé pour produire un programme exécutablemais simplement interprété au moment de l'exécution.Malgré l’amalgame réalisé entre ce langage et le système d’exploitation OS/2d’IBM qui a connu l’échec que l’on sait (sous OS/2, REXX fait partie du systèmed'exploitation), REXX a fait des émules et des versions comme NetRexx ou Objec-tRexx sont apparues.En savoir plus : http://www2.hursley.ibm.com/rexx/ 

1979

Effectivement, MS-DOS n’est pas un langage de programmation mais il était utilede préciser qu’il a été le support du décollage de la micro-informatique et, donc,le système de l’exploitation sous-jacent à de très nombreux langages. En 1980,

IBM s’intéresse enfin aux micro-ordinateurs. Le CP/M est le système présagé pour équiper son futur Personal Computer (PC). Mais Digital Research, la firme de GaryKildall, rate le contrat à cause de malentendus. IBM se tourne alors vers Micro-soft, la firme de William H. Gates.Ce dernier propose le QDOS (Quick & Dirty Operating System) d’un inconnu, TimPaterson. Il s’agit d’un clone de CP/M, écrit pour le processeur 16 bits d’Intel, le8086, sorti en juin 1978. Dans ses premières versions, MS-DOS reprend d’ailleursle fonctionnement de CP/M et l'on doit (entre autres) à cet héritage, sa limitationdes noms de fichiers à (8+3) caractères ! Six versions se sont succédées, respec-tivement en 1981, 1983, 1984, 1988, 1991 et 1995.En savoir plus : http://www.pcastuces.com/windows/msdos/basedos.htm

1981

Le langage de description de page POSTSCRIPT existe depuis 20 ans et a eu unimpact fondamental sur l’industrie de l’imprimerie, avec la commercialisation desimprimantes laser. Il a été développé par John Warnock et Chuck Geschke deAdobe, après leur départ de Xerox.La première version commerciale du langage, Postscript niveau 1, est disponibleen 1984. C’est un langage très puissant qui ressemble un peu au Forth. Il seraimplémenté sur la première imprimante laser d’Apple Computer, la Laserwriter,qui était plus puissante que le Macintosh à laquelle elle était connectée !Destiné à piloter les imprimantes, Postscript est indépendant de la machine, avecune spécification publique qui permet à tout un chacun d’écrire des logiciels lesupportant. Actuellement, le niveau 3 du langage est disponible.En savoir plus : http://www.adobe.com/products/postscript/main.html

1982

Bjarne Stroustrup définit C++, le successeur de C. Plutôt que D ou P (soit la suitede C dans l’alphabet, ou la suite de C dans BCPL), Stroustrup baptise son enfantC++, entendant par là que C++ est "a better C", un C meilleur, incrémenté (++ estl’opérateur d’auto-incrémentation de C). C++ est un bricolage de laboratoire, ence sens qu'il n'y a jamais eu de projet défini pour C++, avant qu'il connaisse lesuccès actuel.Dans l'idée de Stroustrup, C++ devait conserver les idées de base ayant conduit àla réalisation de C (typage statique, efficacité d'exécution, langage compilé) etamener quelques-uns des points forts d'autres langages. Parmi ces points forts,citons la surcharge d'opérateurs (introduite pour la première fois par Algol 68) etles classes (introduites tout d'abord par Simula 67). Ironiquement, les principaux “+” de C++ sont des caractéristiques introduites dans des langages antérieurs à Clui-même, qui est à l'origine de C++.

En savoir plus : http://www.research.att.com/~bs/C++.html

1983

N U M E R O 

50 

Mike Colishaw

Bill Gatesaterson

Bjarne Stroustrup

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 18/58

D

O

S

S

I

ER 

Programmez N°50 • FEVRIER 2003

0

Historique Prospective

Steve Jobs d’Apple lance le Macintosh, livré en standard avec le système d’ex-ploitation System (futur Mac OS). C’est une révolution dans le monde de la micro-informatique qui, pour la première fois, dispose d’un outil basé sur un systèmed’exploitation multi fenêtré, pilotable à la souris. Les concepts de base provien-nent encore une fois de Xerox.

En savoir plus : http://www.platinium.fr/apple/128k.html

Objective C, inventé par Brad Cox, est une autre version orientée objet de C. Sonoriginalité provient de l’absence de surcharge des opérateurs et du fait qu’il fututilisé par les ordinateurs Next et livré en standard sous le système d'exploitationNextStep. Au retour de Steve Jobs chez Apple, lors du rachat de Next Computers,Objective C fut réutilisé dans le système d’exploitation qui deviendra Mac OS X.En savoir plus : 

http://developer.apple.com/techpubs/macosx/Cocoa/ObjectiveC/ObjC.pdf 

Borland a été précurseur dans la livraison de langages de programmation à basprix. Turbo Pascal a été l’un des premiers logiciels de l’éditeur californien, dirigépar le français Philippe Kahn.En savoir plus : http://www.emsps.com/oldtools/borpasv.htm

1984

Conçu par Bertrand Meyer, Eiffel est un langage procédural, totalement orientéobjet, qui implémente la persistance conçue pour la sécurité du logiciel. Le sour-ce Eiffel peut se compiler en C et s'interfacer avec d'autres langages. Il incorporedes éléments de langage fonctionnel, dispose de classes génériques et d'un gar-bage collector. Une version dérivée existe en open source, Sather, qui est le nomde la tour de Berkeley.En savoir plus : http://c2.com/cgi/wiki?EiffelLanguage

1986

La 1ère version de CAML, acronyme de Categorical Abstract Machine Language,est écrite par Suarez, Weiss et Maury. CAML est un langage de programmation,

fonctionnel et fortement typé, de la famille de ML. Les systèmes OCaml (Objecti-ve Caml) et Caml Light sont deux implémentations libres développées à l’INRIA.En savoir plus : http://caml.inria.fr/index-fra.html

Le langage PERL, sigle de Practical Extraction and Report Language, est un langa-ge de programmation dérivé des scripts shell, créé en 1987 par Larry Wall , afinde mettre au point un système de News entre deux réseaux. Il s'agit d'un langa-ge interprété, dont l'avantage principal est d'être très adapté à la manipulationde chaînes de caractères. De plus, ses fonctionnalités de manipulation defichiers, de répertoires et de bases de données en ont fait le langage de prédilec-tion pour l'écriture d'interfaces CGI. Perl possède de nombreuses fonctions per-mettant de manipuler des chaînes de caractères ainsi que des fichiers.En savoir plus : http://www.enstimac.fr/Perl/DocFr.html

1987

Publication de CLOS (Common Lisp Object System) et mise au point de Oberon.Oberon est le nom d'un système d'exploitation conçu par une équipe dirigée par N. Wirth. Oberon est aussi le nom du langage dans lequel a été écrit le systèmeOberon, successeur des langages Pascal et Modula, conçus par N. Wirth. Oberon-2 est une évolution du langage Oberon conçue par H. Moessenboeck en 1991, quiajoute une orientation objet à son grand frère.En savoir plus : http://www-iiuf.unifr.ch/~schweizp/oberon/indexo.html

Créé par John Ousterhout, TCL est l'acronyme de "Tool Command Language".C'est un langage interprété, qui permet de développer rapidement des pro-grammes, fonctionnant aussi bien sous Unix, Windows ou VMS, car l'interpréteur TCL existe pour tous ces systèmes. Il est simple à utiliser car sa syntaxe est trèsréduite, comparée à d'autres langages de scripts, comme PERL.

Un autre avantage de TCL est son mécanisme d'extension, qui en fait un langageréellement universel, et il devient possible de se connecter à une base de don-

1988

Steve Jobs

Brad Cox 

Bertrand Meyer 

Larry Wall 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 19/58Programmez N°50 • FEVRIER 2003

31

On ne présente plus le langage HTML créé par Tim Berners-Lee. L’HyperText Mar-kup Language est un format utilisé pour créer des documents hypertextes. Il estcomposé de balises (tags) qui permettent de modifier la mise en page : type decaractère, taille, couleur, insertion d'image, saut de ligne, insertion d'un lienhypertexte...En savoir plus : http://www.ping.be/~ping9985/html/thehtml.htm

1989

Windows 3.0 est réellement la première version stable et suffisamment finie del’interface graphique qui va devenir la référence absolue du secteur, tout aumoins en terme de parts de marché. Microsoft délivrera ensuite les versions 3.1,

NT, 95, 98, Me, XP, 2000, CE… bref, une famille entière de systèmes d’exploitationmonopolisant l’informatique personnelle et, de plus en plus, celle d’entreprise.En savoir plus : http://www.computerhope.com/history/windows.htm

1990

Python est un langage interprété, interactif, orienté-objet, souvent comparé àTCL, PERL, Scheme ou Java, créé par Guido van Rossum. Il combine une puissan-ce remarquable avec une syntaxe claire, des modules, des classes, des excep-tions, un très haut niveau de types de données dynamiques, ainsi qu’un typagedynamique. Il possède de plus de nombreuses interfaces vers d’autres langageset vers des systèmes tels que X11, Motif, Tk, Mac ou MFC.L’implémentation de Python est portable et fonctionne sous Unix, Windows, DOS,OS/2, Macintosh, Amiga, etc. Pour la petite histoire, le moteur de rechercheGoogle utilise beaucoup ce langage.

En savoir plus : http://www.python.org/ 

Apparition de Microsoft Visual Basic, une révolution dans la catégorie des lan-gages RAD (Rapid Application Development).En savoir plus : http://msdn.microsoft.com/vbasic/ 

Le système d'exploitation libre LINUX, basé à l'origine sur Minix, a été conçu par un jeune étudiant Finlandais nommé Linus Torvalds pour exploiter la puissancedes microprocesseurs Intel 386. Le noyau est de nos jours disponible, aussi bienpour des ordinateurs Macintosh, Sun, Mips et Alpha, accompagné de logicielslibres (ceux de GNU en tête) et est considéré comme une alternative aux sys-tèmes propriétaires, en particulier Windows de Microsoft.En savoir plus : http://www.linux.org/ 

1991

Apple Computers spécifie le langage DYLAN, abréviation de DYnamic LANguage,langage de haut niveau, utilisé dans le développement système et applicatif.Dylan est conçu pour autoriser une compilation statique de caractéristiques nor-malement associées à des langages purement dynamiques.En savoir plus : http://www.gwydiondylan.org/drm/drm_1.htm

1992

Depuis Mac OS X 10.2, RUBY est intégré au système. Inventé par Yukihiro Matsu-moto, Ruby est un langage de script orienté objet, prenant le meilleur des lan-gages Smalltalk, Perl et Python. Les programmes écrits dans ce langage sontfaciles à relire et à modifier. Outre une syntaxe claire, Ruby dispose d'unensemble de bibliothèques bien fournies. Toutes ces possibilités rendent Ruby

très souple et extensible.En savoir plus : http://www.approximity.com/ruby/ruby_fr/siframes.html

1994

nées (Oracle, Sybase, ...), de réaliser des scripts CGI, de manipuler des fichiersXML, de s'interfacer avec un programme Java, etc. TCL possède également uneextension graphique nommée TCL/TK. Ce langage de script portable a d’ailleursété incorporé dans des outils tiers, comme Vignette.En savoir plus : http://www.winnix.com/fr/p03/tcl/hh_start.htm

N U M E R O 

50 

Tim Berners Lee

Guido van Rossum

Linus Torvalds

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 20/58

D

O

S

S

I

ER 

Programmez N°50 • FEVRIER 2003

2

Historique Prospective

UML est l’acronyme pour Unified Modeling Language, que l’on peut traduire par "langage de modélisation objet unifié". Il est né de la fusion, au milieu desannées 90, des trois méthodes qui ont le plus influencé la modélisation objet :OMT, Booch et OOSE. Issu "du terrain" et fruit d'un travail d'experts reconnus(Booch, Jacobson, Rumbaugh), UML est le résultat d'un large consensus de la

part de nombreux acteurs industriels, qui l’ont adopté et participent à son déve-loppement.Fin 1997, UML a accédé au statut de norme de l’Object Management Group, orga-nisme à but non lucratif créé en 1989, qui fédère aujourd’hui plus de 850 acteursdu monde informatique. Actuellement, la dernière version des spécifications UMLest la 1.4, délivrée en septembre 2001.UML permet donc de modéliser une application selon une vision objet, sachantqu’il constitue tout à la fois une norme, un langage de modélisation objet, unsupport de communication et un cadre méthodologique.En savoir plus : http://www.omg.org/uml/ 

ADA se renouvelle avec ADA 95 qui supporte désormais la programmation orien-tée objets.En savoir plus : http://www.sei.cmu.edu/str/descriptions/ada95_body.html

 Java 1.0 est lancé par Sun Microsystems en partant du projet OAK de James Gos-ling. Signifiant "café" en argot américain - en argot français on dit "Kawa" -, celangage objet est principalement utilisé sous forme d'applets en symbiose avecun client Web. Il a pour cela une particularité : le programme est d'abord compiléen "p-code" (byte-code), totalement indépendant de l'architecture. Puis, ce p-code est interprété (c'est à dire transformé au fur et à mesure en code spécifiqueà l'ordinateur) lors de l'exécution du programme.

 Java possède une syntaxe similaire au C++, mais simplifie certains concepts etoblige d'emblée à penser en termes d'objets. Ses grandes forces sont sa portabi-lité, grâce au concept de machine virtuelle, qui permet en théorie d'écrire desprogrammes qui s'exécuteront de manière identique sur différentes plates-formes, et son souci de réduire la complexité de développement pour le pro-

grammeur (quitte à sacrifier l'efficacité à l'exécution, contrairement à laphilosophie du C++). En particulier, il possède une bibliothèque standard trèsfournie, qui encapsule la plupart des tâches complexes dans un ensembled'APIs : gestion de threads, programmation en réseau, sécurité, internationalisa-tion, interfaces graphiques avec Swing.En savoir plus : http://java.sun.com

Netscape introduit JavaScript, un langage de script portable, qui fonctionne aussibien du côté client que du côté serveur, totalement dédié au monde Internet.En savoir plus : http://developer.netscape.com/docs/manuals/communicator/jsgui-de4/ 

PHP, acronyme récursif de "PHP : hypertext processor", est un langage de scriptOpen Source.

Malgré son évolution rapide, il reste essentiellement destiné à ce pour quoi il aété conçu : le développement d'applications Web, pour lequel il est un excellentchoix. En effet, les avantages de PHP sont nombreux.Sa rapidité de développement dérive d’une syntaxe simple (héritée du C et dePerl), avec des fonctions particulièrement adaptées aux applications Web et sonexcellente documentation permet une grande productivité. PHP dispose d'ungrand nombre d'extensions, qui lui permettent de couvrir l'essentiel, sinon latotalité, des besoins relatifs aux applications Web (bases de données, mail,expressions régulières, PDF, XML...). D’autre part, des applications librementréutilisables sont pléthoriques sous PHP : systèmes de template, interfaces degestion de bases de données, interfaces mail, systèmes de publication, etc.En savoir plus : http://www.phpfrance.com/ 

1995

Booch

 Jacobson

Rumbaugh

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 21/58Programmez N°50 • FEVRIER 2003

33

Objective Caml, précédemment connu sous le nom de Caml Special Light, est uneréimplémentation quasi-complète de Caml Light, entreprise par Xavier Leroy en1995, à laquelle s'est joint Jérôme Vouillon en 1996, pour l'implémentation desobjets et des classes. Ses principales innovations sont un système complet d'ob-jets et de classes, mettant Caml au niveau des meilleurs langages orientés-objets

existants, un calcul de modules puissant, mais néanmoins compatible avec lacompilation séparée et un compilateur produisant du code assembleur de hauteperformance pour la plupart des processeurs du marché (Pentium, Alpha, Power PC, Sparc, Mips, HPPA.En savoir plus : http://caml.inria.fr/ocaml/ 

1996

Le C++ accède au statut de standard ANSI.En savoir plus : http://www.ncits.org/standards/pr14882.htm

Lancement de Java 2 par Sun. Cette nouvelle mouture apporte des différencessignificatives avec les premières versions, notamment en terme de conception,de robustesse et d'ajout de bibliothèques.En savoir plus : http://java.sun.com/j2se/ 

1998

XML, eXtensible Markup Language, est un "langage de balisage extensible",développé par le W3C. Ceci signifie que XML n'est pas limité, au contraire duHTML, à un balisage prédéfini extrêmement figé, mais que tout un chacun pourradéfinir ses propres balises. Le XML cherche avant tout, à dissocier les données deleur mise en forme. Le HTML lui aussi a évolué dans ce sens, en introduisantdepuis quelques années la notion de feuilles de style, mais ceci n'a rien à voir avec la dissociation beaucoup plus structurée établie par le XML.En savoir plus : http://xmlfr.org/w3c/TR/xpath/ 

1999

Le langage C# (prononcer C sharp) a été conçu par Microsoft pour en faire le lan-

gage de prédilection de la plateforme .NET. Il peut être vu comme une réponse deMicrosoft face au langage Java de Sun, étant donné qu’il est directement inspirédu C++ et de Java, et possède également une inspiration de Visual Basic. En par-ticulier, le C# met en oeuvre un garbage collector pour libérer le programmeur dela gestion de la mémoire, les variables sont automatiquement initialisées et lesconstructions qui peuvent introduire des erreurs lorsqu'elles sont mal utiliséessont défavorisées.De plus, un programme écrit en C# sera converti d'abord en un langage intermé-diaire, analogue à la machine virtuelle de Java, commun aux différents langagesde la plate-forme .NET. Microsoft a soumis le langage à l'organisation ECMA pour en faire un standard reconnu et a obtenu gain de cause en décembre 2001.En savoir plus : 

http://msdn.microsoft.com/vstudio/techinfo/articles/upgrade/Csharpintro.asp

2000

Pour finir ce dossier, un revenant, en la personne de Fortran 2000 ! Son draft aété approuvé en septembre 2002 et la spécification définitive devrait être dispo-nible cette année.En savoir plus : http://www.j3-fortran.org/ 

 Jean Vidames

2002

N U M E R O 

50 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 22/58

D

O

S

S

I

ER 

Programmez N°50 • FEVRIER 2003

4

Historique Prospective

Les autresév énements

1842 Ada Lovelace, premier programmeur.

1854 Boole publie son fameux ouvrage sur les processus logiques.

1944 Le premier bug est découvert par G. Hopper, une phalène entrée dans le Mark II de Harvard.

1949 Premier langage de programmation appliqué sur un ordinateur, Short Calc doit être compilé à

la main avant d’être introduit dans la machine.

1950 • Invention de l'Assembleur par Maurice V. Wilkes, de l'université de Cambridge.

• Dans un célèbre article de la revue Mind, en 1950, Alan Turing décrivit le test de Turing,

l'une des premières avancées en intelligence artificielle.

1951 Invention par Mary Grace Hopper du premier compilateur A0, qui permet de générer un pro-

gramme binaire à partir d'un code source.

1960 Percée dans les systèmes d'exploitation avec Fred Brooks d’IBM qui conçoit System/360, une

série d'ordinateurs de tailles variées, avec la même architecture et le même ensemble d'ins-

tructions.1961 Fernando Corbato et Robert Fano du MIT font la démonstration de CTSS (Compatible Time

Sharing System), le premier système d'exploitation multi-utilisateurs.

1962 Définition par Kenneth Ivarson du langage APL, A Programming Language, qui utilise un jeu

de caractères propres et nécessite donc des terminaux d’entrée-sortie dédiés. Ce langage est

basé sur une notation mathématique, composée d’opérateurs, avec un seul type défini, le

tableau.

1963 Premier logiciel graphique interactif utilisant un stylo optique créé par Ivan Sutherland.

1964 Création du code ASCII.

1968 • Environnement graphique à fenêtres et souris par Douglas C. Engelbart.

• Faisant suite à FORTRAN 66, LISP2 et LOGO, c’est l’apparition de ALGOL68, un langage qui

n’a plus grand chose de commun avec son prédécesseur, et qui s’avère un challenge pour les implémentateurs.

1969 • UNIX par Ken Thompson.

• Début de la construction d’ARPAnet, le précurseur d'Internet.

1973 • Le premier prototype de la station de travail Xerox Alto démarre pour la première fois avec

une interface graphique.

• Création de Superpaint, logiciel de dessin en couleurs et d'effets vidéo numériques, par D.

Shoup.

1974 • Création du mot "logiciel" par Jean-Erick Forge, informaticien co-fondateur du CXP, le

Centre d'eXpérimentation des Packages.

• La méthode Merise, basée sur les entités-relations, est créée par Hubert Tardieu.

1975 • Première version du BASIC Microsoft, écrite par Bill Gates et Paul Allen.• Bravo, 1er traitement de texte WYSIWYG, est développé au PARC sur Xerox Alto par Charles

Simonyi.

1978 Premier traitement de textes Wordstar, par John Barnaby.

1979 • Le premier tableur, Visicalc, par Dan Bricklin et Bob Frankston.

• Lancement en France du programme Télétel à la norme Vidéotex, connu sous le nom de

Minitel.

1980 Introduction de Dbase II par Ashton-Tate.

1981 • Lotus 1.2.3 par Lotus Corporation.

• Xerox commercialise le Star 8010, une machine dotée d'origine d'une interface entièrement

graphique utilisant au maximum le "Drag and Drop" (cf. travaux sur Alto).

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 23/58Programmez N°50 • FEVRIER 2003

35

Développement de “Plankalkül” par l’ingénieur allemand Konrad Zuse, inventeur 

du premier calculateur programmable universel non spécialisé, le Z3, en 1941. Ilapplique son langage, entre autres, au développement d’un jeu d’échecs. Ce lan-gage ne sera jamais appliqué sur un ordinateur.En savoir plus : http://ei.cs.vt.edu/~history/Zuse.html

1946

1982  John Warnock et Chuck Geschke développent au Xerox PARC Interpress, un langage de des-

cription de page pour imprimante.

1983 Interface graphique LISA d’Apple.

1984 • Bull introduit G-COS 7, nouveau système d'exploitation pour sa gamme DPS 7.

• Digital Research commercialise son interface graphique GEM pour IBM PC.

1985 • Windows 1.0 par Microsoft.

• Aldus lance son logiciel de PAO Page Maker pour le Macintosh.

• Commodore présente l'Amiga 1000, une machine révolutionnaire pour l'époque avec son

système d'exploitation multi tâches, muni d'une interface graphique, le Workbench.

1986 • Le MIT publie la première version de son environnement graphique XWindows v10.4, pour 

station Unix.

• Adobe lance Illustrator pour le Macintosh, 1er logiciel de dessin Postscript.

• Berkeley Softworks lance l'interface graphique Geos pour Commodore 64.

1987 Lancement du système d’exploitation OS/2 par IBM.

1988 Commercialisation du système d’exploitation Next Step1.0 par Steve Jobs, le fondateur 

d’Apple.

1989 Novell lance la version 3.0 de son système d’exploitation réseau Netware.

1990 C++ V2.1 introduit les templates et les exceptions.

1992 Windows 3.1 et 3.11 chez Microsoft.

1993 • 1ère version de Windows NT chez Microsoft.

• Lancement du Newton d’Apple, 1er PDA avec un OS à reconnaissance d’écriture.

1994 • NCSA Mosaic, 1er navigateur Web.

• Invention du streaming sur Internet par Real Networks.

1995 • Borland revisite le langage Pascal avec Delphi.

• Lancement de Windows 95 par Microsoft.

2001 Lancement de Windows XP, l’OS fédérateur de Microsoft.

N U M E R O 

50 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 24/58

D

O

S

S

I

ER 

Programmez N°50 • FEVRIER 2003

6

Historique Prospective

Petite généalogie des langages et des IDEConnaissez-vous les liens entre les différents langages ? Le schéma ci-dessous vous donne unaperçu simplifié des ascendants et des descendants de vos langages préférés.

François Tonic 

Environnement/IDE

Langage de programmation

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 25/58Programmez N°50 • FEVRIER 2003

37 

N U M E R O 

50 

 A près des années devaches grasses mar-quées par le passage

à l’euro, les projets an 2000et l’émergence du web, ledéveloppement de l’infor-matique marque le pas. Laplupart des grands comptesont réduit leur budget de

manière drastique et les projets se font aujour-d’hui plus rares. Pour autant faut-il en déduireque nous rentrons dans une période de crise ?

Il est permis d’en douter, pour plusieurs raisons.En premier lieu la révolution technique continueet les éditeurs innovent sans cesse pour amélio-rer leurs produits; le lancement réussi de la plate-forme .NET de Microsoft l’atteste. Ensuite, parceque la multitude de projets lancés ces dernièresannées, a abouti à des systèmes d’informationfragmentés, pas toujours cohérents et peu évolu-tifs. Il en résulte un très fort besoin d’intégrationdes systèmes existants. Enfin l’arrivée desréseaux sans fil haut débit (GPRS, UMTS…) vapermettre de tenir les promesses d’hier en matiè-re d’informatique mobile.

Sur le plan technique, on note déjà une très nettebipolarisation des plates-formes de développe-ment : d’un coté l’offre Java, menée par IBM, BEAet dans une certaine mesure SUN, de l’autre, par Microsoft qui mène une large offensive en vued’imposer .NET. Ces deux plates-formes semblentêtre les seules capables de répondre aux nou-veaux besoins des architectures distribuées etdes applications Web. Cette tendance devraits’accentuer dans les mois qui viennent, et l’hypo-thèse d’un monde bipolaire IBM/Microsoftdevient de plus en plus plausible. Une chose estsûre, le développement RAD revient en force.Avec des technologies comme ASP.Net et JSF

(Java Server Faces), le développement webdevient enfin productif !En ce qui concerne l’intégration, il faut aussi s’at-tendre à une consolidation de l’offre et à unemontée en puissance des solutions d’IBM et deMicrosoft sur ce segment. Là encore, Microsoftattaque le marché par le bas avec Biztalk Server,produit fiable, robuste et simple à mettre enœuvre. Le périmètre de ce produit englobe à lafois la communication inter-applicative (E.A.I.) etle B2B, puisqu’il sert de point d’entrée pour lesflux EDI ou ebXML. C’en est donc terminé desprojets d’intégration pharaoniques, consomma-

teurs de ressources colossales, pour des résul-

tats pas toujours visibles ! Les prochains projetsd’intégration auront un périmètre fonctionnelplus limité, mais devront apporter des solutionsrapides et économiques. Auparavant, l’intégra-tion se faisait traditionnellement par les données(qui étaient partagées ou dupliquées). Demain,elle se fera obligatoirement par des échanges demessages, faisant appel à des serveurs d’intégra-tion tels que Biztalk. A noter aussi les besoins enmatière d’intégration d’interfaces, avec la pro-bable généralisation des portails.Du coté des métiers de l’informatique, il faut

aussi s’attendre à des changements importants.L’époque de l’informaticien enfermé dans sa tour d’ivoire est révolue : l’intégration des applica-tions implique nécessairement un plus grand dia-logue avec les utilisateurs et les différenteséquipes projet. Le métier d’informaticien, tout enrestant dominé par les compétences techniques,va nécessiter de plus en plus de qualités relation-nelles. Il faut également s’at-tendre à un niveau d’exigenceaccru de la part des utilisateurs,quant à la qualité et à la fiabilitédes applications livrées. Dans ce

domaine, l’informatique est loind’atteindre les standards dequalité totale, en vigueur dansd’autres industries, comme l’au-tomobile. La gestion de la pro-duction va devenir un aspectcritique du système d’informa-tion, pour la bonne et simpleraison que les entreprises ensont de plus en plus dépen-dantes, et que les projets d’intégration vontrendre ce besoin encore plus sensible. Les appli-cations devront être administrables et supervi-sables à distance, et les anomalies devront être

détectées avant qu’elles ne deviennent des inci-dents d’exploitation. Les outils de gestion de laproduction comme NetIQ AppManager ou PreciseIndepth vont devenir indispensables.En conclusion, pas de révolution en vue pour l’in-formatique, mais plutôt une série d’évolutionsqui devraient la normaliser un peu plus et la faireressembler davantage aux autres industries, touten gardant ses spécificités.  

Médéric MOREL

Directeur technique de Neoxia

Intégrateur de systèmes spécialisé dans les nou-

velles technologies de l’information.

[email protected]

Historique Prospective

Quelles tendances pour

l’informatique en 2003-2004 ?

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 26/58

D

O

S

S

I

ER 

Programmez N°50 • FEVRIER 2003

8

Historique Prospective

P

our réparer, en temps réel, dedrôles de machines qui tom-

baient sans cesse en panne,les premiers conducteurs automo-biles roulaient accompagnés deleurs mécaniciens. Les grandesorganisations, pour faire fonction-ner les premiers ordinateurs, entre-tenaient des équipes d’ingénieurset de techniciens, seules capables

d’intervenir sur les langages et les machines. Lacréation de réseaux de réparation automobileaccélère la démocratisation des nouvellesmachines. Les sociétés de service informatiquegrandes et petites se multiplient à partir desannées 60 pour ouvrir les entreprises moyennes

aux nouvelles technologies. Dans le mêmetemps, l’automobile gagne en fiabilité et l’indus-trie passe de l’ère de la réparation à celle del’échange standard… L’intervention du mécaniciense limite au changement de composants et lesgarages diminuent en nombre.Peut-on, sur la base, d’une telle comparaison

annoncer la mort des SSII, à l’instar de celle des

réseaux automobiles ? Ce serait aller trop vite en

besogne, même si les bouleversements des deux 

dernières années ont poussé bon nombre de SSII et

autres webs agencies à fusionner ou à disparaître…

Il est bien loin l’âge d’or du bug de l’an 2000, des

ERP, de l’e-business et de l’euro, quand les com-pétences étaient rares et s’arrachaient à prix d’or … Sur-capacitaire, le marché est maintenantdominé par les clients. Et, les grands comptes,obsédés par la réduction de leurs coûts, ne seprivent pas pour imposer leurs diktats en matièrede prix et de contrats aux sociétés de Service.Prestations payées 200 Euros par jour, garanties de qualité de serviceet de contributions aux résultatsimposées par contrat caractérisent cenouveau rapport de force. Y aura t’ilun adoucissement de ces contrainteslors de la sortie de la crise ? On peut

en douter car les clients autorisentrarement la remontée des prix qu’ils ont réduits …Plus de qualité dans les développements, plus derigueur dans la mise en œuvre, plus de transpa-rence dans les prestations et dans les coûts …telles sont les exigences durables des grandscomptes et à travers leur exemple, celles de l’en-semble des clients.En chinois, le mot crise se compose de deux idéogrammes, " Wei " veut dire risque et " Ji "signifie opportunité.L’arrivée à maturité des technologies de l’infor-mation et le fait qu’elles irriguent toutes les

facettes de la vie économique et sociale, garantit

que les besoins en développement iront crois-sant. Mais la croissance sera différente.

L’Internet a ouvert de nombreuses possibilitésnouvelles, communication, recherche, travail col-laboratif, commerce, et autant de nouvelles disci-plines et nouveaux marchés. L’Internetrévolutionne aussi la façon dont on programme,en rendant possible le partage des développe-ments entre des centres distants. Triviale, cettenouvelle réalité a donné le jour à des générationsd’outils et de méthodes qui permettent d’appli-quer au travail des développeurs, les principeschers à Taylor, de l’organisation scientifique dutravail ! Un travail plus morcelé, plus formel avecplus de procédures et moins d’indépendancefigure au menu des changements annoncés pour 

bien des développeurs. A ces bouleversements, ilfaut également ajouter la recherche de toujoursplus de productivité, au diapason des contraintesimposées aux sociétés de service.Mais alors la " belle ouvrage ", la programmationélégante, celle qui relève plus de la création artis-tique que de la science, va-t-elle disparaître ? Cer-tainement pas !Les grands éditeurs, pour leur part, ont toujoursbesoin de talents qui leur permettent de rendreleurs logiciels toujours plus intelligents, plusconviviaux et plus faciles à utiliser.Les sociétés de service, quant à elles, recher-

chent les compétences pointues à proposer àleurs clients. Qualité logicielle, sécurité, stockage,connaissance de J2EE, .NET ou C# figurent déjàparmi les spécialités qu’elles recherchent. Et,dans de nouveaux secteurs industriels, desbesoins métiers voient le jour pour des adapta-tions et des développements spécifiques, dans la

santé, le tourisme ou les services, par exemple.L’accès à l’information, au commerce,à la communication est à la fois uni-versel, omniprésent et surtout mobileet génère, là encore, des demandesfoisonnantes en développement,

même si l’UMTS et autres GPRS n’ontpas encore dévoilé leurs vrais potentiels d’usage.Enfin, pour ceux qui sont employés, en entrepri-se, dans un service informatique, la capacité àmanager et à animer des équipes sera toujoursdavantage recherchée car il s’agira, avant tout, decoordonner les talents et les ressources interneset externes. Certes, comme le rappelait JacquesChirac, les prévisions sont difficiles, surtout lors-qu’elles concernent l’avenir. Mais, heureusement,la seule chose dont on soit sûr, c’est que l’avenir ne s’y conforme jamais.  

 Jean-Claude Vaudecrane

Directeur de la rédaction

Risque et Opportunité !

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 27/58Programmez N°50 • FEVRIER 2003

39

N U M E R O 

50 

S

i on regarde lesfilms fantastiques,

de science-fictionou, mieux encore, d’anti-cipation, la vision du

futur varie souvent d’un extrême à l’autre. Sidans Star Trek, on peut entrevoir une société pluségalitaire où la technologie n’est pas faite pour détruire le monde, la plupart de ces films décri-vent un monde où la technologie supplantel’Homme.S’il ne faut pas être (encore) alarmiste sur cepoint, cela pose une bonne question : la place dela technologie dans notre civilisation. En articu-lant la réflexion sur l’avenir du langage et lesenvironnements de développement, peut-on des-

siner les futures orientations ? Si certains veulentcroire à la disparition du développeur tel qu’on leconnaît aujourd’hui, la réalité est tout autre. Pluson avance dans le temps, plus on aura besoin dedéveloppeurs spécialisés dans des domainespointus. Car finalement, au lieu de simplifier réel-lement le modèle de développement, il s’alourditde plus en plus, même si une tendance actuellesemble contredire cela.Depuis quelques mois, on va vers une sorte defusion entre outils UML et IDE. Je pense que latendance dans les prochaines années sera effecti-vement une intégration / interaction totale entre

UML (ou un autre modeleur) et l’IDE. On auradonc à terme un processus de développement,sans doute plus simple et plus souple (à partir d’un modèle), mais cela oblige le développeur àposséder une parfaite maîtrise de la modélisa-tion, en plus du langage et de l’IDE. Je vois aussiune seconde tendance lourde : les composants.Arlésienne par excellence, le composant nous estpromis depuis des années sans qu’on le voievraiment. Je crois que l’on peut prévoir uneexplosion de l’offre composant et du modèlecomposant d’ici 3 à 4 ans, le temps que les tech-niques soient totalement matures. Attention, si lecomposant simplifiera le développement, il ne

résoudra pas tous les problèmes. Je me demandeaussi si le composant sera capable de dépasser le stade des fonctions de base d’un projet infor-matique…Bref, va-t-on réellement vers une simplificationdu développement ? Pas vraiment. Si pour l’utili-sateur, l’application et l’ordinateur seront plussouples et plus simples, pour le développeur, ledéveloppement deviendra d’une extrême com-plexité, à cause de la simplification de l’utilisa-tion.Plus que jamais, où sera l’esprit du génial Hyper-Card ? Pour moi, ce mythique logiciel d’Apple,

créé par Bill Atkinson, reste inégalé par sa simpli-

cité et son approche " naturelle " de l’applicationet des langages de programmation. Le langage

est dit langage naturel, donc le plus proche pos-sible du langage parlé. Aujourd’hui, la plupartdes langages restent incompréhensibles pour lamajorité des utilisateurs d’ordinateur. Pourquoi,au lieu de vouloir rendre complexe le moindreélément, les éditeurs ne retourneraient ils pasvers des concepts simples et rapides ? Il n’y aqu’à voir les langages modernes. C truc est plusobjet que son concurrent. Je ne parle même pasdes IDE. Chacun y va de son discours plus oumoins compréhensible. À l’époque, HyperCardvoulait rendre accessible la programmation à toutle monde à une période où le langage de l’infor-maticien était obscur.

Demain, rien n’aurachangé…Dans les prochainesannées, avec des sys-tèmes de plus en pluscomplexes, inutile d’es-pérer des IDE et lan-gages simples.L’étudiant devraapprendre et maîtriser toujours plus deconcepts. Quid deschefs de projets et

autres responsables entout genre ? Des misesà jours sont à prévoir.Pour l’avenir, je verraibien des agents dedéveloppement intelli-gents, capables d’adap-ter automatiquementdes composants entreeux, de détecter à lavolée les défauts d’uncode, des compilateurstoujours plus multi plates- formes. Espéronsaussi l’apparition d’un véritable langage univer-

sel compréhensible partout et par tous ! Laconvergence de l’informatique, du bureau, l’infor-matique mobile et les appareils personnels sontà ce prix. Car sans une standardisation poussée,les applications auront de plus en plus de mal àintégrer les différents types de terminaux. Lemodèle actuel est déjà trop complexe, trop lourd.

 Je terminerai par le service Web. Si dans le futur très proche, cette technologie sera une des starsdu développement, dans un futur plus éloigné,son avenir est peut-être obscur et incertain. Ilexiste aussi un turnover dans les technologies.  

François Tonic 

Rédacteur en chef Programmez ! 

I’ll be back ?

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 28/58

D

O

S

S

I

ER 

Programmez N°50 • FEVRIER 2003

0

Historique Prospective

Progr ammez : Pouvez-vous faire un

point sur la pénétr ation de Linu  x dans 

le monde ?

Stéf ane Fermigier : En France les entre-prises sont encore lentes à adopter Linux. Les raisons de cette frilosité sontessentiellement liées à notre culture.En effet, les directions informatique y

sont globalement plus conservatrices qu’ailleurs.Mais si nous regardons les statistiques, nous

constatons que la répartition des développeursde logiciels libres est équilibrée entre l'Amériquedu Nord et l'Europe, et que le marché du libre,notamment dans l’administration, est plus impor-tant en Europe. L’année 2002 a aussi montré dessignes de progression forte en Chine et plusgénéralement en Asie du Sud-Est. Le gouverne-ment chinois souhaite s’affranchir de la domina-tion américaine. Avec le logiciel libre, legouvernement chinois impose à ses industrielsune informatique performante sans avoir besoinde reverser des royalties aux occidentaux.

Progr ammez : A votr e av is quelles sont les entre- prises qui parient sur le log iciel libr e ?

Stéfane Fermigier : Historiquement, Linux a péné-

tré dans les entreprises par la base, mais il y a

aussi des entreprises qui ont misé sur le libre à

un niveau stratégique, comme par exemple les

opérateurs télécoms, qui ont basé toute leur 

infrastructure sur Linux. Plus généralement, nous

assistons à deux types de migration. Tout d’abord

les utilisateurs Unix qui souhaitent se rapprocher 

de Linux, en recherchant des solutions stables,

performantes et économiques. Et aussi les utilisa-

teurs de Windows qui migrent vers Linux car il

sont de moins en moins satisfaits par les poli-

tiques de licences de Microsoft. Sur ce marché,

nous assistons à une percée des serveurs

appliances plus simples, et donc moins chers à

administrer et plus rapides à déployer que leurs

équivalents sous Windows. Il est en effet admis

qu’un administrateur système Unix / Linux peut

couramment administrer de deux à dix fois plus

de serveurs que son homologue Windows.

Progr ammez : En matièr e de ser v eurs cr it iqu es,

Linux est encore peu pr ésent dans les entre- 

prises. Pourquoi ?

Stéfane Fermigier : Il faut encore du temps pour 

que Linux s’impose sur les serveurs critiques et

les bases de données, mais on en voit les pre-miers signes, par exemple dans les institutionsfinancières américaines. Pratiquement tout lemonde est prêt à migrer des serveurs Unix versLinux, les éditeurs de logiciels tels qu’Oracle ouIBM recommandent, dans des publicités diffuséeslargement, d’utiliser Linux pour faire tourner leursbases de données et leurs serveurs d’applica-tions sous Linux, pour plus de stabilité et de per-formances, et un TCO moins élevé que Windows.

Ce qui me fait dire que le marché Unix sera captépar Linux d’ici 4 à 5 ans.

Programmez : Les DI et les DSI ont long te mps r epr o- 

ché à Linu  x son manque de suppor t et de st r ucture 

dans la distribution. Est-ce toujours un frein ? 

Stéf ane Fermigier : Non. Le salon Linux Expo estla preuve que les prestataires se mobilisentautour de tout cela. Il existe désormais trois caté-gories de prestataires : les généralistes qui mon-tent à présent des cellules ou des business unitsautour du libre, pour répondre aux demandes deleurs clients, les spécialistes du libre et les

petites SSII d’envergure locale qui proposent aux entreprises un service de proximité. Tous propo-sent des prestations autour du logiciel libre : ins-tallation, support, formation, adaptation etdéveloppements spécifiques.

Pr og r ammez : La pr esse parle beaucoup des ser- 

v ices Web. Pourquoi la communauté du libre 

r est e discr ète à ce sujet ? 

Stéf ane Fer migier : Il n’y a pas à faire de sensa-tionnalisme car les services Web existent depuislongtemps dans le logiciel libre. XML-RPC, le pro-tocole le plus utilisé à l’heure actuelle et prochede SOAP, est né de la collaboration entre déve-

loppeurs de logiciels libres et non libres. Il s’estrapidement démocratisé, grâce à des implémen-tations libres dans la plupart des langages dedéveloppement. Apache est l’un des projetslibres les plus impliqués dans les services Web. Ilintègre une multitude de composants dont uneimplémentation SOAP. On trouve aussi des implé-mentations des Web Services dans les principaux langages de programmation libres, comme Perl,Python ou PHP.Cependant, on retrouve dans ce domaine le pro-blème des brevets logiciels. En effet, les Web Ser-vices sont normalisés par le consortium W3C,

mais IBM et Microsoft ont tous deux déposé des

Linux : les perspectives

technologiquesINTERVIEW DE STÉFANE FERMIGIER, PRÉSIDENT DE L’AFUL (ASSOCIATION FRANCOPHONE DES UTILISATEURS DELINUX ET DES LOGICIELS LIBRES) ET DIRECTEUR DE NUXEO

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 29/58Programmez N°50 • FEVRIER 2003

41

Développement de “Plankalkül” par l’ingénieur allemand Konrad Zuse, inventeur 

du premier calculateur programmable universel non spécialisé, le Z3, en 1941. Ilapplique son langage, entre autres, au développement d’un jeu d’échecs. Ce lan-gage ne sera jamais appliqué sur un ordinateur.En savoir plus : http://ei.cs.vt.edu/~history/Zuse.html

1946

brevets sur certains des protocoles. Pour le W3Cc’est un véritable dilemme, car comment promul-guer un standard avec des brevets qui traînentsur les protocoles. Un débat intense a lieudepuis plus d’un an à ce sujet.

Pr ogrammez : Mais IBM impose ses brevets. Est- ce que cela n’est pas contr adict oire avec la philo- 

sophie du libr e ?

Stéf ane Fermigier : Absolument. Le fait qu’IBM

cherche, par une activité de lobbying intense

auprès des gouvernements européens, à imposer 

les brevets logiciels en Europe est très mal perçu

par la communauté du libre. Les brevets logiciels

sont en effet un moyen pour les grosses entre-

prises comme IBM ou Microsoft de tuer les petites

et les développeurs indépendants, car à partir du

moment où toutes les tech-

niques de programmation

seront brevetables, il devien-

dra pratiquement impossible

d’écrire un logiciel original

sans violer au moins une

dizaine de brevets.

Programmez : Pratiquement 

tou s les constructeur s pr opo- 

sent désormais Linux sur le ur s 

gr ands sy stèmes. Quel est l’in- 

térêt pour les entrepri ses ?

Stéf ane Fer migier : Mon sen-

timent est positif. IBM par 

exemple a organisé au mois

de décembre un forumautour du logiciel libre, avec

pour objectif principal de

montrer qu’il ne s’agit pas

d’une simple opportunité mais d’une action à long

terme, un investissement stratégique pour le

constructeur. En outre, comme les autres construc-

teurs, IBM emploie des dizaines de développeurs

qui travaillent sur les composants clés de Linux,

afin que ce dernier puisse monter en gamme sur 

les serveurs. Le point important est que ces déve-

loppements ne sont pas "propriétaires", ils sont

reversés à la communauté du libre.

Pr ogrammez : Quelle est vot r e posit ion par r ap- 

por t à l’initiativ e J2EE de Sun ?

Stéfane Fermigier : Sun n’a pas joué d'entrée dejeu la carte du libre. Résultat : Java sous Linux n’apas pris l’ampleur qu’il aurait dû avoir. Il existecependant, de nombreux projets Java libres, par exemple ObjectWeb et JBoss, deux implémenta-tions libres de J2EE. Cependant ces éditeurs n’ontpas le droit de dire qu’ils sont J2EE, car le prix des certifications J2EE est prohibitif pour un pro-jet libre. Reste que J2EE représente une offred’environnement applicatif performant, permet-tant d’ouvrir les couches basses des infrastruc-

tures aux applications Linux.

Pr ogr ammez : A moy en terme, quelles perspec- 

tiv es envisagez-vous ?

Stéfane Fermigier : Le marché Linux se décline en

trois segments principaux : les serveurs, l’embar-

qué et la bureautique. Sur le marché de serveurs,

il y a une réelle force en position pour remplacer 

le marché d’Unix. Nous observons la montée engamme chez les constructeurs IBM, HP, Bull, etc.

Tous les constructeurs ont intégré Linux dans leur 

stratégie et se battent maintenant pour se posi-

tionner comme les leaders de ce marché. Cela

signifie que le marché à ce niveau est mûr.

En ce qui concerne le marché de l’embarqué,Linux commence une pénétration massive, enparticulier au Japon et en Asie du Sud Est, où desindustriels comme Samsung ou Sony ont investilargement sur la plate-forme. En outre, de nom-

breuses start-up ont choisile virage Linux pour l’em-barqué. On devrait prochai-

nement voir arriver enFrance, avec un à deux ansde retard sur le Japon, desapplications concrètes dansce domaine. Enfin du côtéde la bureautique, si leposte de travail commenceà intégrer Linux, via d’unepart les amateurs de tech-nologies et les étudiants,d’autre part les grandscomptes qui souhaitentréduire le TCO que leur 

impose la politique delicences de Microsoft, resteque pour le grand public il ya encore beaucoup d’efforts

à faire. Mais on peut aussi signaler que les appli-cations bureautiques libres progressent égale-ment sous Windows et MacOS X: signalons par exemple Mozilla, qui est une véritable plateformede développement d’applications clientes, Ope-nOffice.org, la suite bureatique libre de SUN, ou,plus récemment, l’annonce faite par Steve Jobsde Safari : un navigateur web basé sur le compo-sant KHTML du projet libre KDE.

Pr ogr ammez : Et si v ous av iez un message à f aire 

passer aux développeur s ?

Stéf ane Fermigier : Il est simple : il faut lutter contre la proposition de directive européenne sur le brevet logiciel. Celui-ci représente un véritabledanger dans la progression du développementlibre, tout comme pour l’industrie Européenne dulogiciel en général. Et pour le développeur, leprincipal changement qu’apportera le brevet logi-ciel, c’est d’enlever tout plaisir à l’activité de pro-grammation, qui est avant tout une activité decréation.  

Propos recueillis par Annie Lichtner

N U M E R O 

50 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 30/58Programmez N°50 • FÉVRIER 2003

47 

à urbaniser, capable à la fois d’utiliser au mieux l’existant, mais

suffisamment souple, agile, pour intégrer les technologies à venir.

D’autre part, la DSI oriente son fonctionnement vers la notion de

service à l’utilisateur. Conséquence directe, des métiers tech-

niques comme le technicien ou le pilote d’exploitation doivent

intégrer des compétences nouvelles : meilleure connaissance des

outils pour les utilisateurs, des systèmes informatiques de l’entre-

prise et de leur fonctionnement.

Dernier exemple d’évolution : le métier de développeur multimé-

dia. Internet et le multimédia ont favorisé à leurs débuts des

postes marqués par la polyvalence. Celle-ci a vécu. La disparition

de la distinction entre " développeur " et " développeur multimé-

dia " dans les référentiels du Cigref en est l’illustration. Le web-

master, cet homme à tout faire, développeur, animateur,

communicant, " marketeur " a quasiment disparu dans les

grandes entreprises. Internet et intranet ne sont plus des pla-

quettes numériques mais bien des composantes, parfois centrales,

du système d’information. Que ce soit en Java, flash ou C++, le

développeur multimédia est avant tout un professionnel de l’infor-

matique.

Le retour à la confiance et la création de valeur grâce aux sys-

tèmes d’information dépendent de notre capacité à mobiliser leshommes, à faire évoluer les compétences de tous ces acteurs, à

faire preuve de pédagogie et de conviction face aux enjeux 

majeurs pour nos entreprises et pour la société.  

 Jean-Pierre Corniou

Président du Cigref www.cigref.fr 

Les fondamentaux du métier

D

epuis toujours, je suis profondément convaincu que le seul

facteur de différenciation dans l’économie, c’est la connais-

sance et la compétence. Lorsque nous avons vécu cetembrasement de la nouvelle économie, nous avons été un certain

nombre, au Cigref et ailleurs, à dire : attention, entre le " brick and

mortar " et le click tout court, il ne faut pas trop prendre de

claques ! Ce qui s’est produit malheureusement et brutalement,

c’est que ce projet de nouvelle économie qui n’était pas fondé sur 

des valeurs fondamentales de compétence, de travail, de durabili-

té, de mesurabilité des services, s’est effondré bruyamment en

laissant beaucoup de désarroi. Et c’est ce qui est le plus grave

parce que, au-delà de la nouvelle économie, il y a effectivement la

société de l’information et ultimement, la société de la connais-

sance. Nous devons repenser les fondements de la société de l’in-

formation. Nous avons brûlé les feux en confondant innovation etnouveauté. En confondant résultats trimestriels et transformation

de la société. Nous avons été victimes de notre propre illusion.

Nous devons redonner aux dirigeants des entreprises ainsi qu’aux 

collaborateurs de terrain, l’envie profonde de s’intéresser à nou-

veau aux technologies de l’information.

Non aux gadgets technologiquesLa seule matière première qui ne s’use que si l’on ne s’en sert pas,

c’est la matière grise. Nous avons, nous, la responsabilité, direc-

teurs des systèmes d’information et professionnels des technolo-

gies de l’information, de reprendre cette longue marche vers le

savoir et la compétence en reprenant nos fondamentaux. Cela ne

se décrète pas. Intégrer la technologie dans les entreprises est

important, essentiel même. Mais cela ne suffit plus. Il faut mainte-

nant franchir une étape supplémentaire : développer et créer du

sens pour amener nos entreprises, nos dirigeants, l’ensemble des

responsables de la société, à prendre conscience que les outils

que nous manipulons ne sont pas des gadgets technologiques

que l’on jette au bout de six mois d’usage, mais sont des outils de

transformation de la relation de l’homme avec son environnement.

Le Cigref a d’ailleurs déjà identifié les prémices de cette évolution.

On peut observer dans les grandes entreprises une ouverture

accrue de la direction des systèmes d’information aux autres

métiers. L’entreprise est prise en compte dans sa globalité, y com-pris en intégrant sa stratégie. Pour le système d’information, cela

signifie en particulier la nécessité d’être non seulement fiable et

ouvert, mais aussi agile. Cela s’illustre par la montée en puissance

de la fonction d’urbaniste. À côté de l’architecte émerge l’urbanis-

te, chargé de gérer le système d’information comme un ensemble

Jean-Pierre Corniou

est président du CIGREF,Club informatique des grandes

entreprises françaises, qui

regroupe les 115 premiers

grands comptes.

Il est par ailleurs directeur

des technologies et systèmes

d'information de Renault.

Il a été consacré par la presse,

en 1999, "directeur

informatique " de l'année.

Diplômé en Sciences Eco,

Sciences Po et ENA,

il a également un certificat en analyse et conception de

Systèmes de l'Université de Montréal.

Il a publié : "Qui a encore peur de l'informatique ?, précis à 

l'usage des managers " 

(1990), " La société de la connaissance, nouvel enjeu pour 

les organisations " (2002).

 Notre objectif : REALISER VOTRE MAGAZINE IDEAL

Votre avis nous intéresse : SONDAGE EN LIGNE

http:/www.programmez.com

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 31/58

C#

E

Depuis quelques mois, Programmez évoque C# et plusieurs articles de programmation sur ce langage ont été publiés. Nous avons voulu

aller un peu plus loin, en vous proposant un cahier pratique spécial C#.Vous y retrouverez de la programmation et aussi un avis d’expert

plus porté sur la stratégie à adopter envers C#. On a très souvent l’habitude de comparer C# et Java. Il faut dire que les deux langages se

ressemblent beaucoup. Cette ressemblance devrait encore s’accentuer dans les mois et années à venir.Aujourd’hui, C# est utilisable sur

trois plates-formes :Windows, FreeBSD et MacOS X.Un peu limité pour le qualifier de langage universel comme l’est en théorie Java. Pour dévelop-

per en C#, très peu d’outils sont disponibles :VisualStudio, Eclipse via un add-on et le terminal Unix sous MacOS X.Pas de quoi être une menace

envers les environnements Java… pour le moment.

Premier constat : le développeur VB migrera vers C# Faisons tout d’abord un constat simple. La majorité des développeurs VB migreront sans aucun doute tôt ou tard vers C#.Aujourd’hui, C# tend à

être le langage de référence pour développer des applications Windows. Si le programmateur VB peut garder VB et migrer vers VB.NET, est-ce réelle-

ment l’avenir ? On peut en douter.De plus, C# est largement mis en avant par Microsoft dans son environnement .NET.

Second constat : C# = Java ?Quand on compare Java et C#, on adore mettre face à face les héritages de deux langages.C# descend du C++ et en garde certains aspects. Java des-

cend de SmallTalk. Mais en même temps, Java et C# se ressemblent. Les deux utilisent des machines virtuelles : JVM pour l’un, CLR pour l’autre et les

deux implémentent des compilateurs JIT.Les deux langages sont des langages orientés objets et un grand nombre de points techniques sont iden-

tiques. Quoi qu’il en soit, C# est en quelque sorte un Java-like dans certains domaines. Java reste plus indépendant au niveau de la plate-forme que

C#. Il existe aussi une différence de taille : C# (en fait le CLI) est un standard reconnu par l’ECMA.Un grand

nombre de développeurs apprécie C# car, il est plus facile à l’utilisation et peut-être plus moderne

dans sa structure et sa syntaxe. Java est de conception déjà ancienne (10 ans) et avec les

ans, Java a hérité d’une multitude de fonctions et de composants, faisant exploser

le nombre de classes disponibles.

Troisième constat : migration vers C# ?Verra-t-on dans l’avenir une migration des développeurs Java

vers C# ? Personne ne peut répondre à cette question. Il

est trop tôt. Si on veut réaliser des projets Windows,

.NET ou des Web Services, C# sera en tête de liste.

 Java est encore en retard sur les services Web.Tout

dépendra, une fois de plus, du type de projet et

de développement. C# ne peut servir aujour-

d’hui à faire des applications multi plates-

formes.Mais, lorsque C# sera disponible sur

tous les systèmes (et en particulier Linux), on

verra sans aucun doute l’apparition de nou-

veaux IDE. Là, on pourra parler de réelleconcurrence à Java.

Quatrième constat : faites-vous une opinionSi les longs discours sont parfois utiles, rien ne vaut

une comparaison point par point entre C# et Java et des

tests approfondis. Les guerres pro Java et pro C# existent

depuis la sortie du langage de Microsoft.

Longue analyse comparative C# - Java (en Anglais) :

http://www.25hoursaday.com/CsharpVsJava.html

Cinquième constatIl ne me reste plus qu’à vous souhaiter

bonne lecture de ce dossier pratique spécial

C#. François Tonic 

C# : le nouveaulangage universel ? 

C# : le nouveaulangage universel ? 

P

A

T

I

QU

Programmez N°50 • FEVRIER 2003

0

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 32/58

1•PROGRAMMEZ WINDOWS AVEC C# 2EME PARTIE

Nous avons appris à construire une

application C# avec les outils gratuits

à notre disposition. Il est maintenant

temps d'aborder la programmation

Windows proprement dite.

Le mois dernier,nous avons acquis quelque sa-voir-faire, pour être en mesure de construire

des programmes en C#, uniquement à partir d'ou-tils gratuits ou Open Source. Nous allons mainte-nant aborder chacun des points requis au dévelop-pement d'une application Windows bien formée.Nous sommes dans un pays libre, où chacun peutfaire ce qui lui plaît… Toutefois, il est de bon ton dese conformer à une convention,qui veut qu'une ap-plication Windows soit systématiquement dotée decertains éléments consécutifs et soit capable debien se comporter dans l'environnement multi-

tâches Windows. Par exemple, une application sedoit d'avoir un menu, lui même organisé conven-tionnellement et la fenêtre de l'application doit êtrecapable de s'adapter à des changements de taille ouà des recouvrements de fenêtres. Vous pouvezconsulter à http://msdn.microsoft.com le do-cument intitulé

"Generic:Anatomy of a Simple Win32 Application".Bien entendu, vous prendrez ce document au se-cond degré, vu que les exemples de codes sont enC et non en C#. Il n'empêche que les indicationsd'ordre général restent valables.

Mise en Form

On s'en doutait, une application Windows classique

se doit d'avoir au moins une fenêtre dite fenêtre

principale. La première chose que nous allons faire

est donc d'ouvrir une fenêtre. Le mois dernier, nous

avons dit que C# venait avec un énorme jeu de

classes regroupées par thème, dans des espaces de

noms. Ces espaces de noms sont imbriqués les uns

dans les autres, un peu à la façon des poupées gi-

gognes, avec une certaine logique. Cette organisa-

tion peut aussi être vue comme une hiérarchie,avec

au sommet l'espace de nom 'System' qui contient

tout, c'est à dire ce qui concerne la programmationWindows proprement dite et le reste. La program-

mation Windows proprement dite est à son tour

encapsulée dans l'espace de nom 'Windows', auquel

on accède comme ceci:System.Windows.Enfin, ce

qui concerne les fenêtres, baptisées 'Forms' dans

Figure 1: Le framework SDk C# vient avec une documen- 

tation exhaustive.

Programmez N°50 • FEVRIER 2003

51

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 33/58

P

A

T

I

QU

Programmez N°50 • FEVRIER 2003

2

C#

l'univers C#, est encapsulé dans l'espace de nom

Forms, inclus dans l'espace de nom Windows. On

accède donc à ce qui concerne les fenêtres, avec le

qualificateur System.Windows.Forms.Cet espace

de nom contient une ribambelle de classes, aux uti-

lités diverses.Vous pouvez obtenir la liste de ces

classes dans la documentation incluse dans le Fra-mework SDk (figure 1). Plus besoin d'aller sur le site

de la MSDN.Tous les composants d'une application

Windows, tels que boutons, boîte liste, contrôle

d'édition ou autres, font partie de cet espace de

nom. Nous vous encourageons donc vivement à

consulter cette documentation,qui vous permettra

de sortir du strict cadre de cette série d'articles et

d'acquérir de l'autonomie et de donner libre cours

à votre créativité.

Pour l'instant, nous écrivons une application mini-male, qui ouvre une simple fenêtre à l'écran:

class Hello1 {

public static void Main(){

System.Windows.Forms.Form form =new System.Windows.Forms.Form();form.Show();

}}

Comme expliqué le mois dernier, vous pouvezcompiler ce programme d'un coup, ou si vous pré-férez, vous pouvez utilisez le makefile qui accom-pagne ce code sur le Cd-Rom.Quelle que soit la méthode choisie, vous aurez lasurprise de constater que la fenêtre surgit à l'écran,pour disparaître aussitôt. Nous allons remédier à

cela un peu plus loin.Cette série d'articles, n'a pas pour vocation d'ex-pliquer le langage C# lui même.Disons malgré tout,quelques mots de ce premier programme.

• C# est un langage objet.Tout code doit doncêtre intégré à des classes, ce que nous avons fait.

• Nous créons une fenêtre (Form) en instanciantun objet Form au moyen de l'opérateur new.Une classe Form est donc une classe comme lesautres du point de vue du langage.

• Nous accédons à la classe Form, via les espaces de

nom, ce qui alourdit considérablement l'écriture.

Pour éviter les qualificateurs longs comme des jours sans pain,C# propose la directive using. Il est

alors possible d'accéder directement aux classes del'espace de nom,pointées par une telle directive.Nous devons maintenant faire en sorte, que notrefenêtre ne nous échappe pas.Une application Win-dows est pilotée par les événements. Un événe-ment est quelque chose qui survient extérieure-ment à une application, mais qui influence celle-ci.Par exemple, lorsque la fenêtre principale d'une ap-plication voisine recouvre notre fenêtre, des évé-nements sont générés. Lorsque l'utilisateur mani-pule la souris au dessus de notre fenêtre, oulorsque l'utilisateur appuie sur une touche du cla-vier,d'autres événements sont générés.Windows

transmet les événements aux applications, par le

biais d'un processus de messages, assez compliqué.Ensuite une routine de l'application se charge dedispatcher les messages vers les composants del'application, réellement concernés par les dits évé-nements.Tout ceci est assez complexe et lourd àgérer dans du code C.Avec C# c'est tout simple.

Dans l'espace de nom System.Windows.Form,exis-te une classe nommée Application, qui encapsule lemécanisme décrit ci-dessus. Il est important denoter que la classe Application ne peut pas être ins-tanciée, car elle ne possède pas de constructeurpublic. Déclarée 'sealed,' elle ne peut pas non plusêtre dérivée.Toutes les méthodes de la classe Ap-plication sont déclarées 'static' et donc accessiblesdirectement, via un qualificateur. La méthode Runde cette classe lance une boucle, qui se charge derécupérer tous les messages en provenance du sys-tème, pour les dispatcher à bon escient vers lescomposants. Il n'y a donc rien de plus à faire, qu'ap-peler cette méthode en lui transmettant la fenêtre

principale de l'application en argument.Dans ce cas,il n'est plus nécessaire d'invoquer la méthode Show,comme nous l'avons fait dans le premier program-me d'exemple, car C# se charge de la besogne.Nous obtenons une seconde version de notre pro-gramme rudimentaire:

using System.Windows.Forms;

class Hello2 {public static void Main(){

Form form = new Form();Application.Run(form);

}

}

Le comportement de notre application est mainte-nant beaucoup plus satisfaisant, puisque notre fe-nêtre attend gentiment que nous cliquions sur lebouton de fermeture pour disparaître. Ce clic desouris étant unévénement récu-péré et dispatchépar la méthodeRun de la classeApplication. Mal-heureusement,notre fenêtre est

désespérémentvide (figure 2),ceà quoi nous al-lons remédiermaintenant.

Le tour du propriétaire

Une classe C# contient des membres publics aux-quels le programmeur peut accéder. Ces membressont, soit des méthodes que l'on peut invoquer, soitdes propriétés. Les propriétés sont une fonction-nalité de C#, qui masque en fait des appels à des

méthodes particulières.Pour le programmeur, tout

Figure 2: Notre fenêtre est déses- pérément, tristement vide.

E

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 34/58Programmez N°50 • FEVRIER 2003

53

se passe comme si les propriétés étaient de vul-gaires variables,mais en sous main, le compilateurremplace les affectations par des appels à des mé-thodes 'get' ou 'set', selon le sens de l'affectation.Ces méthodes spéciales get et set,sont écrites parle concepteur de la classe.Ce mécanisme astucieux(qui existe depuis Delphi :) simplifie la vie du pro-grammeur utilisateur, tout en permettant auconcepteur de s'assurer que les propriétés ne sontpas affectées n'importe comment, en procédantaux vérifications requises dans le code des mé-thodes get et set.

Pour connaître le nom des méthodes et propriétésaccessibles, consultez la documentation de la clas-se, accessible depuis la page de l'espace de nom sys-tem.Windows.Form,puis une fois dans celle-ci, cli-quez sur le lien (en bas à gauche) "Form Members".Vous arrivez alors à la page montrée figure 3. Enconsultant cette documentation nous comprenons,par exemple, que les propriétés BackColor et Textgèrent respectivement la couleur de fond de la fe-nêtre et le titre.Nous pouvons donc personnalisernotre fenêtre comme ceci :

using System.Windows.Forms;using System.Drawing;

class Hello3 {public static void Main(){

Form form = new Form();form.BackColor = Color.White;form.Text = "Demo en C#";

Application.Run(form);}

}

Ce qui donne le résultat montré figure 4. Ce codeest simple, mais mérite toutefois une remarque.Dans l'environnement C# les noms de couleurssont des propriétés statiques de la classe Color.Cette classe ne fait pas partie de l'espace de nom

Windows.Forms.Les concepteurs des librairies C#

ont voulu clairementdissocier les fonctionna-lités des fenêtres, desfonctionnalités de des-sin, ces dernières étantregroupées dans une

nouvelle librairie Win-dows GDI+,qui rempla-ce l'ancienne librairieGDI. En C#, GDI+ estencapsulée dans l'espa-ce de nom System.Dra-wing, ce qui expliquel'ajout d'une nouvelle di-rective using dans notreprogramme d'exemple.

Tirer partide l'héritage

Notre dernier program-me d'exemple peut être mieux écrit, c'est à direplus dans l'esprit de la programmation objet en gé-néral et de C# en particulier. Nous obtiendronsalors un code mieux organisé et nous éviterons lesabus de notation pointée,pour affecter les proprié-tés de notre fe-nêtre. Ce quenous devons faireest d'écrire uneclasse, qui dériveexplicitement dela classe Form et

initialiser les pro-priétés de notreobjet dans uncons tructeur .Dans nosexemples précé-dents, les classesdérivaient implicitement de la classe System.Ob- ject, qui est la base de la hiérarchie d'objets en C#.La classe System.Object est très éloignée de la clas-se Form. C'est pourquoi dériver de cette dernièreest plus avantageux.Voici un nouvel exemple quimet en application ce principe:

using System.Windows.Forms;using System.Drawing;

class HelloForm : Form {

public HelloForm(){

Text = "Demo C";BackColor = Color.White;

}

public static void Main(){

Application.Run(new HelloForm());}

}

Figure 3: Toutes les propriétés et méthodes publiques sont documentées dans le 

Framework SDK.

Figure 4: Nous commençons à personnaliser notre fenêtre.

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 35/58

P

A

T

I

QU

Programmez N°50 • FEVRIER 2003

4

C#

Réagir aux événements

Comme nous l'avons dit plus haut, une applicationWindows bien élevée, se doit de réagir aux événe-ments extérieurs, point que nous abordons main-tenant. Si vous revenez à la documentation de la

classe Form,vous verrez que cette classe compor-te un grand nombre de méthodes protégées (Pro-tected Méthod). Parmi toutes ces méthodes,beau-coup ont un nom qui commence par la syllabe 'On'.Par exemple OnPaint,OnResize,etc. Ces méthodessont ce que l'on appelle des gestionnaires d'événe-ments.Le fait de dériver notre classe de la classeForm,nous permet de redéfinir ces méthodes, cequi serait impossible autrement, puisque ces mé-thodes sont protégées. Dans un tel cas nous au-rions quand même pu nous en sortir, en utilisant lemécanisme C# des délégués.Toutefois, afin de nepas alourdir cet article nous préférons nous limiterau plus simple.

Nous allons redéfinir le gestionnaire d'événementOnPaint de notre fenêtre. Ce type d'événement'Paint' est envoyé systématiquement à l'application,lorsque la fenêtre apparaît à l'écran,est redimen-sionnée, ou lorsqu'elle réapparaît après avoir étérecouverte, totalement ou partiellement, par uneautre fenêtre. Le gestionnaire d'événement On-Paint est donc l'endroit tout désigné pour contenirle code, qui dessinera ou écrira ce que l'on voudradans notre fenêtre.La documentation nous informe que ce gestionnai-re recevra en argument, de la part du système, uneréférence sur un objet PaintEventArgs. Il convient

donc que notre propre gestionnaire d'événements'attende à recevoir le même argument. Ensuite,nous devons aller consulter la documentation rela-tive à cet objet. Nous apprenons alors que celui-cicontient une référence sur un objet de type Gra-phics,puis en consultant la documentation relativeà ce dernier, nous constatons que celui-ci met ànotre disposition de nombreuses méthodes pourécrire ou dessiner quelque chose. L'exemple ci-des-sous met tout ça en œuvre:

using System.Windows.Forms;using System.Drawing;

class HelloForm : Form {

public HelloForm(){Text = "Demo C#";BackColor = Color.White;

}

protected override void OnPaint(PaintEventArgs pea){Graphics g = pea.Graphics;Font font = new Font("Times", 24);SolidBrush brush = new SolidBrush

(Color.Black);g.DrawString("Programmez!", font, brush, 10, 10);

}

public static void Main()

{Application.Run(new HelloForm());

}}

Le résultat est montré figure 5. La partie intéres-

sante de cet exemple est bien sûr le gestionnaired'événement OnPaint.Dans celui-ci, nous commen-çons par récupérer la référence sur l'objet Gra-phics de PaintEventArgs.Ensuite, nous créons unepolice de caractères, c'est à dire un objet Font.Cette opération est simple et ne nécessite pasd'explications. Ensuite nous créons une brosse so-lide, de couleur noire.Cette brosse servira à colo-rier les caractères du texte que nous allons écrire.Ceci peut étonner le lecteur habitué à la program-mation graphique Windows dans un autre langage(C ou C++ par exemple) ou à la programmationgraphique sous un autre système. En effet,dans cescontextes, les librairies graphiques comportent

toutes une couleur par défaut, une brosse par dé-faut, etc. Avec GDI+ les choses sont différentes.GDI+ est un système dit 'sans état,' ce qui contraintle programmeur à expliciter toutes les opérationsqu'il souhaite faire.Voilà pourquoi nous créons unebrosse noire, alors que cette opération n'était pasnécessaire en C,car ce dernier aurait invoqué unefonction de la librairie, avec état GDI. Nous com-prenons que le code de dessin est un peu lourd enC#.Toutefois, il y a des facilités pour soulager leprogrammeur. Par exemple, la classe Brushescontient une ribambelle de membres statiques,quisont des références sur des brosses prêtes à l'em-

ploi. Nous aurions pu alors écrire:

g.DrawString("Programmez!", font, Brushes.Black, 10, 10);

Quoi qu'il en soit, l'appel à DrawString requierttoujours un nombre important d'arguments,quelleque soit sa version (La méthode DrawString est

surchargée denombreuses foisau sein de la clas-se Graphics).Tou- jours pour lamême raison:GDI+ est un sys-

tème sans état. Ilfaut donc tout luidire à chaqueopération.La prochaine foisnous approfondi-rons nos connais-

sances sur les gestionnaires d'événements, puisnous verrons comment doter notre application demenus et de boîtes de dialogue et autres élémentsconstitutifs d'un programme Windows bien élevé.

Frédéric Mazué

 [email protected]

Figure 5: Nous apprenons mainte- nant à dessiner dans notre fenêtre.

E

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 36/58Programmez N°50 • FEVRIER 2003

55

En général un programmeur débutant

hésite à surcharger. Le risque est en effet

de rendre son code plutôt indigeste à une

compréhension ultérieure. Nous allons

découvrir comment procéder pour sur-

charger en C# et pourquoi il est utile de

pratiquer de cette manière.

Comparons C#, C++ et javaLe C# est assez proche cousin du C++ et de java.Comparons rapidement leurs caractéristiques res-pectives :

C++ java C#  Héritage multiple des interfaces Oui Oui Oui

Machine virtuelle Non Oui Oui

Garbage Collector Non Oui Oui

Classe de base Non Oui Oui

Strong Type Checking Non Oui Oui

Pointeurs Oui Non Oui

Modèle de classe Oui Non Non

Surcharge des méthodes/fonct ions Oui Oui

Surcharge des opérateurs Oui Non Oui

La surcharge des opérateurs représente par consé-quent un point fort de C# et de C++ par rapportà Java.

La surcharge des méthodes :du C au C# en passant par le C++

Si en C il est interdit de définir plusieurs fonctionsportant le même nom,en C++ et en C# cette in-terdiction est levée. L’idée est de permettre à plu-sieurs fonctions/méthodes, qui ont à la base uneopération commune,mais des paramètres de typesdifférents, de partager le même nom.Voici d’abord un exemple en C++ :

#include <iostream>

int Multiplie(int i,int j){

cout << "Appel de la première fonction";

return (int) i * j;

}

double Multiplie(double i,double j)

{

cout << "Appel de la deuxième fonction";

return (double) i * j;

}

int main(void)

{

cout << " avec deux entiers : " << Multiplie(13,8) << "\n";

cout << " avec deux réels : " << Multiplie(13.8,19.69) << "\n";

}

Et son équivalent en C# :

using System;

namespace Surcharge_Exemple_1

{

class Class1

{

static int Multiplie(int i,int j)

{

Console.WriteLine("Appel de la première

fonction");

return (int) i * j;

}

static double Multiplie(double i,double j)

{

Console.WriteLine("Appel de la deuxième

fonction");return (double) i * j;

}

[STAThread]

static void Main(string[] args)

{

Console.Write("Multiplie(13,8) ==> avec

deux entiers : ");

Console.WriteLine(Multiplie(13,8));

Console.Write("Multiplie(13.8,19.69) ==>

avec deux réels : ");

Console.WriteLine(Multiplie(13.8,19.69));

Console.ReadLine();

}

}}

Nous avons deux fonctions qui portent le mêmenom "Multiplie". Le compilateur C# les accepteratoutes les deux.Lors de l'appel de Multiplie (13,8),ce sera la première fonction qui sera appelée, car13 et 8 sont des entiers tandis que lors de l'appelde Multiplie (13.8,19.69), ce sera la deuxième.Pourquoi surcharger ? La surcharge est intéressan-te lorsque vous souhaitez définir un ensemble deméthodes effectuant la même action,mais avec destypes de paramètres différents. Par contre, la sur-charge n’est pas intéressante quand des noms deméthodes différents rendent le code source plus

facile à comprendre…

2•L’OVERLOAD EN C# 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 37/58

Dans le jargon C#/C++ on dit que le nom d’unefonction et sa liste typée de paramètres constitue"sa signature".Le compilateur sélectionnera la fonc-tion à appeler d’après sa signature.Le compilateurdispose d'un ensemble de règles lui permettant dedéterminer la meilleure fonction à prendre encompte.Si lors du processus de résolution de sur-charge le compilateur trouve des ambiguïtés, il gé-

nérera une erreur.En résumé ce processus est le suivant :

A Identification de l’ensemble des fonctions candi-

dates et des propriétés de la liste des arguments ;

B Sélection des fonctions viables depuis la liste desfonctions candidates.Ce choix est effectué selonle nombre et le type des arguments ;

C Sélection de la meilleure fonction en classant lesconversions appliquées aux arguments pourqu’ils correspondent aux types des paramètres.

Il est intéressant de réaliser ici un parallèle avec java. Une méthode FonctionSurchargee(), est sur-chargée en java quand elle est déclarée plusieurs

fois dans une même classe, ou ses classes dérivées.Elle porte le même nom,mais possède des para-mètres de types différents.

class Classe1{void FonctionSurchargee (int entier){

// Corps de la méthode}void FonctionSurchargee (float nombre){

// Corps de la méthode}

}

class Classe2 extends Classe1{// Classe2 hérite de Classe1 : Classe2 déclare// implicitement toutes les méthodes de Classe1

void FonctionSurchargee (float nombre, short param){

// Corps de la méthode}

}

 Java autorise de surcharger une méthode en utili-sant des paramètres de types différents pourchaque méthode. Les valeurs de retour peuventêtre différentes, mais il est interdit de créer deux

méthodes avec des paramètres identiques et un

type de valeur de retour différent. Une classe héri-te de toutes les méthodes de la "super classe" dontelle dérive,même si elle surcharge une,ou bien plu-sieurs,des méthodes de sa "super classe".Contrai-rement au C++, les méthodes que l'on invoque surun objet de classe Classe2 sont les trois méthodes

FonctionSurchargee (int entier), FonctionSurchargee(float nombre) et FonctionSurchargee (float nombre,

short param). Si vous essayez de réaliser ce schémaen C++, la surcharge de la méthode FonctionSur-

chargee () dans Classe2 interdira à un objet de Clas-se2 d'appeler directement les méthodes surchar-gées de Classe1.Notez bien qu’en C# deux méthodes d’une mêmeclasse ne peuvent pas porter le même nom, accep-ter les mêmes arguments et être seulement dis-tinctes par le type de la valeur de retour.

La surcharge des opérateurs

Un opérateur surchargé se déclare dans le corpsd’une classe de la même manière qu’une fonctionmembre, mis à part son nom, qui se compose dumot clé operator (en C#, comme en C++).La surcharge d’opérateurs simplifie souvent la lec-ture du code source. Elle permet au programmeurde définir pour des opérandes d’un type de classe,de nouvelles versions d’opérateurs prédéfinis.Examinons d’abord le cas du C++. Les opérateurssuivants ne sont pas surchargeables en C++ : "::",".*", " .", "?:", "sizeof ". En outre, le sens prédéfinid’un opérateur pour les types prédéfinis ne peutêtre changé.

Les restrictions sont les suivantes :

- On ne peut pas changer la priorité d’un opérateurprédéfini ;

- Ou changer son associativité ;- Ou changer sa pluralité ;- Ou créer de nouveaux opérateurs.Voici un excellent exemple qui présente la surchar-ge des opérateurs :

#include "iostream.h"

class fraction {private:

int num;

int den;

public:fraction();

fraction(int, int);

fraction operator+(fraction);fraction operator+(int);fraction operator-(fraction);fraction operator*(fraction);fraction operator/(fraction);

friend ostream& operator<<(ostream &, fraction);

};

P

A

T

I

QU

Programmez N°50 • FEVRIER 2003

6

C#

E

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 38/58

extern void reduce(int &, int &);

fraction::fraction() : num (0), den (1) {}

fraction::fraction(int n, int d) : num (n), den (d) { reduce(num, den);}

fractionfraction::operator+(fraction b) {return fraction( (num*b.den)+(b.num*den) , (den*b.den) );

}

fractionfraction::operator+(int b) {

return fraction( num +(b*den) , den );}

// La soustractionfractionfraction::operator-(fraction b) {

return fraction( (num*b.den)-(b.num*den) , (den*b.den) );}

// La multiplication

fractionfraction::operator*(fraction b) {

return fraction( (num*b.num) , (den*b.den) );}

// La divisionfractionfraction::operator/(fraction b) {

return fraction( (num*b.den) , (den*b.num) );}

// La fonction d'affichageostream& operator<<(ostream& os, fraction x) {

return os << x.num << '/' << x.den;}

int pgcd(int a, int b) {int t;

if (a < 0) a = -a;if (b < 0) b = -b;

// Algorithme d'Euclide.while (b) { t = b; b = a % t; a = t; }

return a ;}

void reduce(int &num, int &den) {int g = pgcd(num, den);

num /= g; den /= g;if (den < 0) { num = -num; den = -den; }

}

int main() {fraction a(1,2), b(3,9), c(3,4), r;

r = a + b + c;

cout << a << " + " << b << " + " << c << " = " << r << '\n';;

r = a + 3;

cout << a << " + " << 3 << " = " << r << "\n" ;

exit(0);}

En C# ce sont les opérateurs +-,-=,/= ,&&,|| et new

qui ne peuvent être redéfinis.Les restrictions en C# sont les suivantes :- la fonction ne peut admettre qu’un seul argument

du type de sa classe (cas d’un opérateur unaire);- elle doit envoyer une valeur du type de sa classe

(cas d’un opérateur unaire) ;

- la fonction doit admettre deux arguments, le pre-mier devant être du type de sa classe (cas d’unopérateur binaire) ;

- la valeur de retour sera de n’importe quel type(cas d’un opérateur binaire).

Voici un exemple assez simple en C# :

using System;

class Trio{private int x;private int y;private int z;public Trio()

{ x=1; y=1;z=1;

}public Trio(int i, int j, int k){x = i; y = j;z = k;}

public void AfficheTrio(){

Console.WriteLine("{0} {1} {2} ",x,y,z);}

public static Trio operator -(Trio c){Trio temp = new Trio();temp.x = -c.x;temp.y = -c.y;temp.z = -c.z;return temp;}}

class Surcharge_Exemple_2{public static void Main(){Trio c1 = new Trio(10,20,30);

c1.AfficheTrio();Trio c2 = new Trio();c2.AfficheTrio();c2 = -c1;c2.AfficheTrio();Console.ReadLine();}}

L’objet c1 est composé de trois nombres.Via unesurcharge de méthode, c1 est d’abord initialisé à(10,20,30). L’objet c2 est créé, il vaut au départ(1,1,1). Puis on fait appel à l’opérateur unaire "-".Celui-ci a été redéfini : public static Trio operator -(Trio c). Et donc finalement nous obtenons bien -

10,-20 et -30.

Programmez N°50 • FEVRIER 2003

57 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 39/58

P

A

T

I

QU

Programmez N°50 • FEVRIER 2003

8

C#

Les possibilités sont nombreuses.

Peut être trop.Abordons les choses

le plus simplement possible.

P lus les langages évoluent et plus la gestion desentrées/sorties devient complexe.Avec C, tout

était simple, pour ne pas dire rudimentaire.AvecC++ beaucoup moins.Avec Java c'est épouvantable.C# quant à lui, est plus complexe que C++ mais

moins que Java.Cette complexité des langages mo-dernes est à la fois un avantage et un inconvénient.Un avantage du point de vue de la richesse des pos-sibilités et de la sûreté à l'exécution, un inconvé-nient du point de vue de l'apprentissage, car l'abon-dance des classes et la rigidité du système de typesne rendent pas l'approche facile.Aujourd'hui, nousabordons les entrées/sorties de C# par le petitbout de la lorgnette, notre propos étant d'ap-prendre le plus vite possible à faire quelque chose.

Super flux

En C# toutes les entrées/sorties sont vues commedes flux (ou flots, si vous préférez).Un flux est une

chose sur laquelle on peut effectuer des opérations

de lecture/écriture. La console de Windows est un

flux,des données circulant sur le réseau le font dans

un flux, il est possible d'organiser des flux en mémoi-

re, etc. Et bien évidemment, le fichier est un flux par-

ticulier.Toutes les classes de gestion de toutes les

sortes de flux, sont regroupées dans l'espace de nom

System.IO.Cet espace de nom contient une quanti-

té de classes qui a de quoi faire peur (figure 1). Lesclasses sont organisées selon une hiérarchie (figure2).Au sommet de la hiérarchie se trouve la classeStream.Cette classe est abstraite et ne peut être

utilisée en l'état.Parmi les classes dérivant immédia-tement de Stream, vient la classe FileStream quinous intéresse aujourd'hui, puisque cette classes'occupe des flux particuliers que sont les fichiers.

Travailler avec FileStream

La classe FileStream permet potentiellement detout faire, bien qu'avec elle il ne soit possible de lireet d'écrire que des tableaux d'octets. Un octet cor-respond au type byte de C#. Si l'on veut procéderà des opérations plus complexes, il est toujourspossible d'écrire des routines pour manipuler les

types et les convertir en bytes.Ceci est la solution

3•MANIPULER

LES FICHIERS

AVEC C# 

La redéfinition de l’opérateur binaire "+" est aussisimple :

public static Trio operator +(Trio c1,Trio c2){

Trio temp = new Trio();

temp.x = c1.x+c2.x;temp.y = c1.y+c2.y;temp.z = c1.z+c2.z;

return temp;}

Ajoutez ceci à votre méthode static void Main() :

…Trio c3 = new Trio();c3 = c1 + c2;c3.AfficheTrio();

Console.ReadLine();

Nous obtenons bien (0,0,0).

La surcharge est utile mais àune seule condition…

Nous avons vu qu’une méthode peut être redéfiniedans une classe dérivée.Une telle méthode ne seraplus interprétée de la même manière par le compi-

lateur, par rapport à la métho-de de base. Les opérateurspeuvent aussi être redéfinis. Et

si seulement un sous-en-semble des opérateurs C# estredéfinissable, c’est tout sim-plement pour ne pas rendre lecode illisible.Ce qui irait à l’en-contre d’un des objectifs duC# qui est de rendre le codeplus facile à écrire et à relire.Le plus important si vous pro-venez du monde C est de biencomprendre qu’au-delà desnouvelles techniques (sur-charges, espaces de noms,etc.), il n’existe qu’une seule

(bonne) voie pour program-mer avec le C# : il faut aller dans le sens de l’utili-sateur de la méthode et ne pas rendre un code plusillisible par une trop grande surcharge. Retenonsque la surcharge des opérateurs en C# ne facilitepas la vie du programmeur, mais bien celle de l’uti-lisateur de la classe ! C’est dans ce sens que doitaller l’informatique de demain. De même qu’un journaliste doit rédiger son texte en se mettant àla place du lecteur, l’informaticien doit écrire soncode en prenant le point de vue de l’utilisateur (cequi comprend le cas de figure où l’utilisateur de laclasse est un autre programmeur).  

 Xavier Leclercq

RappelLorsque l’on discute de surcharge

d’opérateurs en C#, il faut bien

comprendre la distinction entre

opérateurs unaires et binaires. Un

opérateur unaire n’opère que sur

une seule opérande tandis que

l’opérateur binaire agit sur deux 

opérandes.

Exemple :

-128 ( le signe ’-‘ est unaire)

130 – 128 (le signe ‘-‘ est binaire)

E

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 40/58Programmez N°50 • FEVRIER 2003

59

qui permet de faire exactement ce que l'on veut,mais qui peut demander beaucoup de travail. La so-lution du paresseux consiste à se servir de classesqui interviennent sur le flux de base, pour écrire,qui des chaînes,qui des types natifs, etc.

Instancier un objetFileStream

Comme tout objet,un FileStream est instancié parl'opérateur new qui invoque un constructeur.Lesconstructeurs sont au nombre de 9 pour FileS-tream. Nous n'en présentons ici que 3, les "purs"C#, si l'on peut dire, qui ne dépassent pas le cadrede cet article. Nous éliminons les quatre construc-teurs qui reçoivent un argument de type IntPtr, quiencapsule un handle de fichier. Un handle est unnombre renvoyé par le système d'exploitation, lorsde la création d'un fichier par un appel à une mé-thode native, à travers le langage C, par exemple.

Ces constructeurs intéresseront donc le program-meur averti, qui veut établir un pont avec de l'an-cien code C/C++. Nous éliminerons encore lesconstructeurs qui permettent d'intervenir sur lataille du tampon ou qui visent à créer des flux ca-pables de travailler de façon asynchrone.Voici doncles 3 constructeurs qui nous intéressent :

• FileStream(string, FileMode)

• FileStream(string,FileMode, FileAccess)

• FileStream(string, FileMode,FileAccess,FileShare)

Dans tous les cas, le constructeur reçoit une chaî-ne décrivant le nom du fichier, ce nom pouvantcontenir un chemin de répertoire complet. N'ou-

bliez par de faire précéder un séparateur de nomde répertoire \ par un autre \.Ou encore, utilisezle sucre syntaxique prévu à cet effet.Veuillez vousreporter au deuxième listing pour voir un exempled'utilisation de ce sucre syntaxique.

FileMode est une énumération de drapeaux, pourajuster le comportement de l'objet selon le cas,comme ceci :

Membre de FileMode SignificationCreateNew Echec si le fichier existe.

Create Création systématique.

Le contenu d'un fichier pré

existant est perdu.Open Echec si le fichier n'existe pas

OpenOrCreate Crée un fichier s'il n'existe

pas l'ouvre sinon.

Truncate Echec si le fichier n'existe pas

Supprime le contenu.

Append Echec si le fichier est ouvert

en lecture.

Crée un nouveau fichier si le

fichier n'existe pas déjà,

puis va à la fin du fichier.

Echec signifie qu'une exception est levée. Il n'est pasquestion ici de tester une valeur de retour, puis-

qu'un constructeur C# n'en retourne pas.Veuillez

consulter la documentation pour connaître lestypes d'exceptions susceptibles d'être lancées.

FileAccess est également une énumération,dont lasignification des membres tombe sous le sens :

Membre de FileAccess SignificationRead Lecture seule. Echec pour

FileMode.CreateNew,

FileMode.Create, Filemode.

Truncate ou FileMode.Append.

Write Echec si le fichier est

en lecture seule.

ReadWrite Echec pour FileMode.Append

ou si le fichier est en lecture seule.

Il nous reste à comprendre FileShare.Windows estun système multi-tâches, et il peut être souhaitableque d'autres processus puissent accéder à notre fi-chier. C'est ce que gère FileShare :

Membre de FileShare Signification

None Accès interdit aux autresprocessus.

(C'est la valeur par défaut)

Read Les autres processus peuvent

lire le fichier.

Write Les autres processus peuvent

écrire dans le fichier.

ReadWrite Les autres processus peuvent

lire et écrire dans le fichier.

Un premier essai.Nous voulons écrire "coucou" dans un fichier, sui-vant en cela la tradition. Pour ce premier essai nous

plaçons les caractères dans un tableau d'octets:

Figure 1: Tout ce que vous voulez savoir sur les flux C# se trouve dans la documentation du Framework SDK.

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 41/58

P

A

T

I

QU

Programmez N°50 • FEVRIER 2003

0

C#

using System.IO;

class demo1 {

public static void Main() {FileStream fs = new FileStream("fichier.txt", File

Mode.CreateNew);byte[] texte = {(byte)'c', (byte)'o', (byte)'u',

(byte)'c', (byte)'o', (byte)'u'};fs.Write(texte, 0, texte.Length);fs.Close();

}}

Ce programme fonctionne une seule fois. En raisondu drapeau FileMode.CreateNew, une exceptionest levée la deuxième fois.Nous ne pouvons imaginer mettre les caractèresde texte dans un tableau d'octets à chaque fois.Nous allons donc nous faire aider d'une classe d'en-codage qui récupère sous forme d'octets les carac-tères d'une chaîne. Nous interceptons égalementl'exception.Voici ce que cela donne:

using System;using System.IO;using System.Text;

class demo2 {

public static void Main() {try {

FileStream fs = new FileStream(@"sousrep\fichier.txt",FileMode.CreateNew);

string chaine = "coucou en fichier\n";

ASCIIEncoding ae = new ASCIIEncoding();byte[] caracteres = ae.GetBytes(chaine);

fs.Write(caracteres, 0, caracteres.

Length);fs.Close();

}catch(IOException e) {

Console.WriteLine(e.Message);Console.WriteLine("Le fichier existe deja\n");

}}

}

Ce code reste assez lourd. Nous le simplifions enfaisant intervenir la classe StreamWriter, qui est làpour aider les paresseux, comme nous l'avons dit

au début de cet article. Nous obtenons:

using System;using System.IO;using System.Text;

class demo3 {

public static void Main() {try {

FileStream fs = new FileStream("fichier.txt",FileMode.Create);

StreamWriter sw = new StreamWriter(fs, newASCIIEncoding());

string chaine = "coucou en fichier";

sw.WriteLine(chaine);sw.Close();

}catch(IOException e) {

Console.WriteLine(e.Message);}

}}

Frédéric Mazué 

Figure 2: Un aperçu de la hiérarchie des flux C# tiré du Framework SDK.

E

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 42/58Programmez N°50 • FEVRIER 2003

61

4•IMPRIMER AVEC C# 

Imprimer avec C# est facile.Voici le mini-

mum vital que vous devez connaître.

C 'est bien connu, développer des GUIs, c'estlong et difficile et imprimer des documents

c'est le cauchemar ! Il faut toutefois reconnaîtreque C# simplifie considérablement le travail sousWindows.Avec cet article, nous allons acquérir lesconnaissances de base requises,pour se lancer avecprofit dans des travaux d'impression. Le lecteur quis'est déjà essayé à faire de l'impression en APIWin32 pure et dure, sera à même d'apprécier lesfacilités apportées par C#.

Faire ses classes

Dans le domaine de l'impression, comme ailleurs,C# met à notre disposition un jeu de classes dontla quantité est ... impressionnante. Si l'on considèreque faire de l'impression c'est comme dessiner surune fenêtre en papier, on ne sera pas surpris de re-trouver la classe 'Graphics' encapsulant le contex-te de périphérique.On ne sera pas surpris non plusde découvrir que toutes les classes relatives à l'im-pression, sont rangées dans l'espace de nom 'Sys-tem.Drawing.Printing' (figure 1). Le problème estde savoir par où commencer.Avec C# tous les tra-vaux d'impression s'articulent autour de la classePrintDocument. Cette classe encapsule à elle seule

l'initialisation de l'imprimante, la création du jobd'impression et l'impression des pages.Fort agréa-blement, cette classe nous dispense de travailleravec les horribles sandwiches 'BeginDoc - EndDoc'd'une part et 'StartPage – EndPage,' qui ont eu ledon de vous agacer en API WIn32. Un simple appelà une méthode 'Print' lance et contrôle le travaild'impression, au moyen d'un mécanisme d'événe-ment qui se charge d'appeler une méthode de rap-pel à chaque nouvelle page imprimée. La marche àsuivre est donc celle-ci :

•Au sein d'une classe qui veut imprimer quelquechose, définir une méthode de rappel, qui feraeffectivement les tracés.

• Instancier un objet PrintDocument

• Installer un délégué pour l'événement PrintPagede l'objet PrintDocument qui se chargera d'in-voquer notre méthode.

• Lancer l'impression, en invoquant la méthodePrint de l'objet PrintDocument.

Ceci posé, examinons plus en détail le travail d'uneméthode d'impression, travail que l'on peut scinderen trois parties

• La méthode doit s'enquérir de la taille du papier,de son orientation,de la résolution de l'impri-mante et en tenir compte.

• La méthode doit savoir quelle page elle est en

train d'imprimer. (ce qui implique de beauxcasse-tête pour les documents volumineux :)

• La méthode doit signaler la fin de l'impression.

Une méthode de rappel reçoit en argument unobjet PrintPageEventArgs, qui permet de s'acquit-ter de tout cela.En effet cet objet comporte,parmid'autres, 5 propriétés des plus intéressantes:

• Graphics.Tout comme pour dessiner sur une fe-nêtre,un objet Graphics,dans ce contexte,per-met de tracer sur le papier. En outre il est pos-sible de connaître la résolution, en consultantses propriétés DpiX et DpiY.

• HasMorePages. C'est en affectant ce booléenque l'on demande une continuation ou un arrêtde l'impression.Affecter true lance l'impression

d'une nouvelle page, affecter false arrête le tra-vail d'impression.

• PageBounds est un rectangle correspondant auxdimensions du papier.

• MarginBounds est le rectangle imprimable, c'està dire le rectangle de la feuille de papier, moinsles marges.

• PageSettings. Cet objet contient des renseigne-

ments plus détaillés sur les réglages de la page.

Contrairement aux propriétés précédentes, les

propriétés de PageSettings ne sont pas en lectu-

re seule.Vous pouvez donc, si le coeur vous en

dit, les modifier à la volée, par exemple, pour im-

primer alternativement une feuille en orientationportrait et une feuille en orientation paysage :)

Figure 1: L'espace de nom 'System.Drawing.Printing'. Un 

grand éventail de classes.

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 43/58

P

A

T

I

QU

Programmez N°50 • FEVRIER 2003

2

C#

Nous pouvons donc nous lancer dans l'écritured'un petit programme console imprimant quelquechose :

using System;using System.Drawing;using System.Drawing.Printing;

class PrintDemo {

PrintDemo() {PrintDocument pd = new PrintDocument();pd.PrintPage += new PrintPageEventHandler

(this.MyPrintPage);pd.Print();

}

private void MyPrintPage(object sender, PrintPageEventArgs ev) {

int leftMargin = ev.MarginBounds.Left;int topMargin = ev.MarginBounds.Top;float xdpi = ev.Graphics.DpiX;float ydpi = ev.Graphics.DpiY;

string texte = "Programmez!";string str;GraphicsUnit pu = ev.Graphics.PageUnit;float ep = ev.Graphics.PageScale;

Font font = new Font("Times", 10);str = string.Format("Marge gauche {0}", leftMargin);Console.WriteLine(str);str = string.Format("Marge superieure {0}", top

Margin);Console.WriteLine(str);

str = string.Format("Resolution horizontale {0}",xdpi);

Console.WriteLine(str);str = string.Format("Resolution verticale {0}", ydpi);Console.WriteLine(str);

str = string.Format("Echelle de page {0}", ep);Console.WriteLine(str);str= string.Format("Unite de tracé {0}", pu);Console.WriteLine(str);

ev.Graphics.DrawString(texte, font, Brushes.Black,

leftMargin, topMargin + 10);

ev.HasMorePages = false;}

public static void Main() {PrintDemo demo = new PrintDemo();

}

}

Quelques remarques sur ce code: Comme pour les

dessins sur fenêtres, C# passe par GDI+ pour les

tracés sur imprimantes. Il convient d'être averti que

GDI+ est un système sans état, ce qui veut dire qu'il

ne se rappelle pas où se situe le dernier point tracé,

quelle est la fonte courante etc.D’ailleurs, il n'y a

même pas de fonte par défaut.C'est pour cette rai-

son que le programme d'exemple crée une fonte. En

clair, il faut toujours tout dire à GDI+. Ensuite vou-

loir tracer part d'un bon sentiment, mais la question

qui se pose est de savoir avec quelle unité ? Pour

éclaicir ce point, j'ai demandé à mon application

console de m'afficher quelques valeurs, toute ex-traites de Graphics :

Résolution horizontale 300

Résolution verticale 300

Echelle de page 1

Unité de tracé Display

Les deux premières valeurs correspondent à la ré-solution de mon imprimante,qui est réglée par dé-faut en mode brouillon (l'encre coûte cher ! :), soitune résolution de 300 points (dpi) par pouces.Il estici question de pouces logiques ET physiques,puisque nous travaillons sur papier.Vient ensuite un coefficient d'échelle. "Le coeffi-cient entre les unités du monde et les unités depages" nous dit Microsoft. Ce qu'il faut com-prendre, c'est que le monde : c'est nous.Ainsi, sipour un coefficient de 0.5 nous disons "Je trace untrait d'une longueur de 100", le résultat sera le

tracé d'un trait d'une longueur de 50. Ceci posé,quelle sera la longueur réelle physique du trait surle papier ? Cela dépend de la dernière valeur, l'uni-té de tracé. Ces unités sont définies dans l'énumé-ration GraphicsUnits,comme ceci :

Membre de l'énumération SignificationDisplay 1/75 pouce

(1 pouce = 25.4 mm)

Document 1/300 pouce

Inch 1 pouce

Millimeter 1 millimètre

Pixel 1 "device pixel" c'est à dire un

point de résolution

Point 1 point d'imprimante, c'est àdire 1/72 pouce

World Pas de transformation.

Pour nous fixer les idées, reprenons l'exemple cidessus. Nous voulons tracer un trait 'du monde'd'une longueur de 100. Nous supposons être réglésur 'Point'. Le coefficient d'échelle est de 0.5.Nous traçons donc un trait de (100 x 0.5)/72 =0.694 pouces.C'est à dire 17.63 millimètres :)

Méfiez vous de Display qui semble donner des ré-sultats fantaisistes. Peut être que Display, comme

son nom pourrait l'indiquer, doit être réservé à l'af-fichage sur écran, ce que Microsoft ne précise pas.Nous en resterons là pour aujourd'hui.Nous en sa-vons largement assez pour travailler. Bien sûr, noussavons pour l'instant, imprimer uniquement surl'imprimante définie par défaut au sein de Win-dows.Une prochaine fois nous apprendrons à tra-vailler avec la boîte de dialogue d'impression et àsélectionner une imprimante par programmation.A bientôt.  

Frédéric Mazué 

 [email protected]

E

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 44/58Programmez N°50 • FEVRIER 2003

63

Cu cœur de la plate-forme .NET de Microsoftse trouve C#, un langage de programmation

de haut niveau, conçu spécifiquement pour le dé-veloppement d’applications autour du Framework .NET, et de manière générale, de l’environnementlogiciel Microsoft.Ce langage, souvent décrié par lacommunauté Java, comme une pâle copie de leurlangage de prédilection, recèle néanmoins des fonc-tionnalités particulièrement intéressantes,qu’ellessoient issues d’autres langages (comme la surchar-ge d’opérateurs), ou bien qu’elles soient des inno-vations (comme la notion d’attribut).Devant l’émergence de .NET au sein des entre-prises, et devant les promesses techniques de la

plate-forme, C# n’est-il pas en train de devenir lenouveau langage universel ? Celui que tout déve-loppeur spécialisé dans les nouvelles technologiesse doit de maîtriser,qui sera au cœur de tous lesdéveloppements futurs, quel que soit l’environne-ment technique.

Un héritage conséquent

C# est le fruit du travail d’Anders Hejlsberg, origi-naire du Danemark.Après avoir longtemps travaillépour Borland,où il a notamment conçu les environ-nements de développement Turbo Pascal et Delphi,

Hejlsberg rejoint Microsoft en octobre 1996, où ilparticipe de manière active au développement de.NET, dont la naissance officielle a été publiée en juin 2000.Dans la logique de ses précédents travaux chezBorland,Hejlsberg a pensé C# en mettant l’accentsur la productivité et la modularité des développe-ments. Un langage doit être suffisamment richepour exprimer le maximum d’instructions séman-tiques,sans pour autant introduire une complexitégénératrice de bugs.Hejlsberg s’est donc inspiré es-sentiellement du langage C++, et non du langage Java,contrairement aux idées reçues.Même si le langage C# est syntaxiquement proche

de Java (notamment concernant les mots-clés), ilréutilise de nombreuses fonctionnalités présentesdans C++ qui n’existent pas dans Java. Citons parexemple, la surcharge d’opérateurs, qui permet laredéfinition de la sémantique d’opérateurs simples,du type +,*, ==, ou encore !=.Cette fonctionnalitéest souvent au cœur de débats entre communau-tés de développeurs.Elle apporte un tel niveau desouplesse au langage, que les abus sont possibles, leplus classique étant de redéfinir un opérateur sansconserver sa signification " intuitive ".Pour limiterces abus, le langage C# interdit la surcharge de cer-tains opérateurs, comme new, (), ||, ou =.Parmi les

apports importants de C++, citons enfin la gestion

des énumérations, via lemot-clé " enum " et la pré-sence des pointeurs, qui peuvent être utilisés uni-quement dans une méthode déclarée " unsafe ".Hejlsberg ne s’est pas inspiré uniquement du lan-gage C++. Il a notamment puisé dans Java,Modula2, C ou bien encore SmallTalk, pour produire unlangage complètement orienté objet. Grâce à cethéritage, riche des meilleures pratiques des princi-paux langages de programmation actuels, C#semble bien armé pour devenir le nouveau langagede référence.

C# : pour quelenvironnement ?

La question peut paraître dénuée de sens, néan-moins, pour qualifier un langage d’universel, il estimpossible de faire abstraction des différents envi-ronnements d’exécution.Aujourd’hui, seule la plate-forme J2EE permet uneréelle indépendance vis-à-vis de l’environnement

d’exécution sous-jacent,en utilisant le concept de" machine virtuelle ", qui permet l’exécution decode générique sur un environnement techniqueparticulier. De manière comparable, le Framework .NET introduit un environnement d’exécution (laCLR,pour Common Language Runtime),au rôle si-milaire à celui de la machine virtuelle Java.La CLR,comme la JVM, manipulent un format généré à lacompilation (le bytecode pour Java, le MSIL pour

.NET), pour exécuter une application.

5•C# EST-IL LE NOUVEAU LANGAGE

UNIVERSEL ?

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 45/58

P

A

T

I

QU

Programmez N°50 • FEVRIER 2003

4

C#

A l’heure actuelle, la seule implémentation de laCLR existante, est celle de Microsoft pour Win-dows. Il existe bien quelques initiatives open sour-ce visant à porter le Framework .NET sous Linuxou Unix (Mono, DotGNU),mais ces projets sontencore en développement. Ils utilisent d’ailleurs

grandement les efforts de Microsoft en matière destandardisation ; la spécification du langage C# aainsi été approuvée par l’ECMA (consortium euro-péen de standardisation) en octobre 2001, et suitactuellement un cycle accéléré de certification ISO.De plus,Microsoft distribue le code source d’uneimplémentation de référence des spécificationsECMA, intitulée Microsoft Shared Source CLI Im-plementation. Elle fait office de version allégée etsimplifiée du Framework .NET,destinée à guider leséventuels développements de CLR sur des sys-tèmes autres que Windows.Quoi qu’il en soit, tout programme écrit en C# estpour l’instant limité aux systèmes d’exploitation

Microsoft. Même si les développements surd’autres systèmes aboutissent, il est impossible dedire aujourd’hui si ces travaux peuvent devenir àterme des options sérieuses de déploiement.

C# : pour quelles applications ?

Comme chaque langage de programmation,C# est

positionné sur un domaine d’application bien parti-

culier. Son ambition n’est évidemment pas de détrô-

ner des langages institutionnalisés, comme le langa-

ge C,le Fortran,l’Ada,ou même le COBOL.Chacun

de ces langages reste quasiment incontournable

dans son domaine d’application : le C pour des dé-veloppements proche de la machine (systèmes,pi-

lotes), le Fortran pour les applications scientifiques,

l’Ada pour l’informatique embarquée, et le COBOL

dans les applications sensibles de gestion.

Au contraire, le langage C# est un langage orientéobjet de haut niveau. Les classes du Framework .NET offrent aux développeurs un niveau d’abstrac-tion élevé par rapport à l’environnement tech-nique, leur permettant de se concentrer sur la mo-délisation objet de leur application.Grâce à la richesse du Framework .NET, le langageC# trouvera sa place dans des applications pure-ment " Web ", à base de WebForms et de Web Ser-

vices, mais aussi au sein d’applications tradition-nelles client-serveur, grâce aux WinForms(composants graphiques pour créer des interfacesWin32).Tout comme Java, le langage C# peut êtreutilisé dans toutes les " couches " d’une application,de la couche de présentation, qu’elle soit Web ounon, à la couche d’accès aux ressources (donnéesrelationnelles, annuaires, ou services externes parexemple). La puissance de la modélisation objetsera utilisée dans la couche métier,et,à bon escient,pour limiter les dépendances entre couches.Le domaine de prédilection de C# est donc bienl’informatique de gestion,mais aussi,d’une manière

plus générale, toute application mettant en œuvre

les standards du Web au sein du système d’infor-mation. Il entre donc – et cela n’a rien d’étonnant,en concurrence directe avec Java, ce que C++ ouVisual Basic n’ont jamais réussi à faire.

C# : pour qui ?

Pour un développeur, maîtriser la syntaxe d’un lan-gage de programmation n’est pas le plus long.Certes, un développeur maîtrisant C++ ou Javamettra moins de temps à assimiler la syntaxe de C#qu’un développeur Visual Basic, mais le gros du tra-vail n’est pas à ce niveau. Il est en effet bien pluslong de maîtriser la bibliothèque de classes du Fra-mework .NET, et encore plus de connaître lesbonnes pratiques de développement, si C# est lepremier langage de programmation objet que l’onaborde.Maîtriser le Framework .NET n’implique évidem-ment pas de connaître les 4500 classes qui le com-

posent, avec chacune des propriétés et des mé-thodes. En revanche, il est nécessaire de connaîtreles classes les plus couramment utilisées, et sur-tout, pour des fonctionnalités simples,d’avoir le ré-flexe de chercher dans le Framework .NET uneméthode adéquate, plutôt que de la réécrire(comme un algorithme de QuickSort sur une listed’objets comparables,par exemple).L’apprentissage du paradigme objet et des bonnespratiques de programmation associées est certai-nement l’étape la plus longue. Un développeur Javaou C++ est considérablement avantagé par rapportà un développeur Visual Basic, qui n’aura pas les ré-

flexes de programmation propres aux langages deprogrammation orientés objets.Même certains dé-veloppeurs C++ peuvent se sentir bridés, puisqueC# interdit désormais l’héritage multiple de classesnon pleinement abstraites. L’implémentation mul-tiple de classes pleinement abstraites (les inter-faces) est toutefois conservée. Cette maîtrise destechniques de programmation propres aux langagesorientés objets est si importante, qu’il est parfoissouhaitable pour un développeur Visual Basic demonter en compétences sur C# plutôt que sur Vi-sual Basic .NET. En effet, si son délai d’apprentissa-ge est suffisamment grand (donc hors projetscourts), il peut profiter du changement de syntaxe

pour appréhender également une nouvelle maniè-re de programmer.En utilisant Visual Basic .NET, undéveloppeur Visual Basic, évoluant dans une syntaxefamilière, aura tendance à ne pas appliquer les " ré-flexes objets ". Rappelons enfin qu’il ne suffit pasd’utiliser un langage de programmation orientéobjet pour bénéficier pleinement des apports de lamodélisation objet.Le langage n’est qu’un outil, quipeut être utilisé pour mettre en œuvre des prin-cipes avancés de programmation objet (techniquesde gestion des dépendances entre classes, modèlesde conception ou " design patterns ").Que penser alors de la gestion du multi langage au

sein de .NET ? Ce multi langage est régi par la CLS

E

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 46/58Programmez N°50 • FEVRIER 2003

65

(Common Language Specification),qui fait office de " contrat de servi-ce " qu’une bibliothèque .NET doitremplir, pour être utilisable depuistout autre langage supporté par leFramework .NET (c’est-à-dire ca-

pable d’utiliser les classes du Fra-mework .NET et d’être compilé encode MSIL).Concrètement,la CLSpermet de développer plusieursmodules d’une application .NET enutilisant des langages de program-mation différents, en réduisant lesfonctionnalités disponibles (typesde données, déclarations desclasses, etc.). Des compétencespeuvent donc théoriquement êtreréutilisées, mais l’intérêt pratiqueparaît limité, notamment pour leslangages " anciennement " non ob-

 jets (Visual Basic .NET ou COBOL.NET par exemple).Outre le passa-ge à l’objet,ces langages ont subi detelles transformations que le passa-ge à C# est souvent un meilleurchoix.

C# : un outil parmi d’autres

Comme pour tout langage de programmation, lapopularité de C# dépend plus des outils tiers (bi-bliothèques de classes et environnements de déve-loppement), que simplement de sa syntaxe. La ri-

chesse des API utilisables en C# et la qualité desoutils de travail, conditionnent directement la pro-ductivité des développements.Concernant les bibliothèques disponibles, C# bé-néficie d’un ensemble bien fourni.Outre les classesde base du Framework .NET, n’importe quelle APICOM existante peut publier son interface à des ob- jets .NET, grâce à un mécanisme automatisé d’en-capsulation.Les applications .NET sont donc interopérables avec des développements Microsoft exis-tants, et en particulier avec tout logiciel Microsoftpubliant une API (comme Exchange avec l’APICDO). Il est également possible d’appeler des ser-vices propres au système d’exploitation Windows

(authentification sur un domaine, ajout de privi-lèges) par un mécanisme appelé Platform Invoca-tion. Enfin, dans un tout autre registre,même l’APIde développement graphique DirectX 9 fournit desinterfaces .NET.Concernant les outils de développement,Microsofta refondu sa suite Visual Studio dans un seul outil,Visual Studio .NET. Cet outil permet, dans sa ver-sion la plus complète, de prendre en charge toutesles étapes du développement, de la conceptionobjet avec UML, au déploiement, en passant partoutes les étapes de développement pur, qu’ellessoient graphiques ou non. Cet outil est certaine-

ment un des principaux atouts de Microsoft dans

l’adoption de .NET, tant le travail du développeurest simplifié. Il propose un habile mélange de fonc-tionnalités automatisées (création de Web Services,de packages de déploiement sous forme de fichiersMSI) et de degrés de libertés pour le développeur,qui en font un outil indissociable de tout dévelop-pement en C#.Même si le langage C# dispose de qualités intrin-

sèques indiscutables, il faut bien admettre que c’estla complémentarité des outils (C#, la bibliothèquesde classes du Framework et Visual Studio .NET) quiest un véritable atout pour les développeurs.

Un langage spécifique… maisune référence

Si C# se limite pour l’instant au développementd’un certain type d’applications en environnementMicrosoft, il n’en est pas moins le nouveau langagede référence pour ces développements. Il n’estcertes pas " universel " au sens propre,mais il estamené à occuper une place de choix parmi les lan-

gages de programmation, comme le fait actuelle-ment Java.D’ailleurs, cette dualité C# - Java ne peutêtre que bénéfique pour les développeurs, puis-qu’elle implique une certaine dynamique dans l’évo-lution des langages. Preuve de cette tendance, Sunconduit actuellement une JSR (Java SpecificationRequest), visant à faire évoluer le langage Java, enlui ajoutant quelques fonctionnalités (énuméra-tions, conversion automatique entre types primitifset objets), fonctionnalités remises au goût du jourpar C#.  

 Julien Soyer 

Consultant Architecte

Groupe SQLI

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 47/58

P

A

T

I

QU

Programmez N°50 • FEVRIER 2003

6

C#

Qui dit mariage, dit liste de mariage !

Le Printemps est un des plus importants

dépositaires des listes de cadeaux lors de ce

 joyeux événement.Avec le langage C#

de Microsoft et le framework .Net, Prin-

temps.com la filiale Internet du distributeur,

a rénové le site Web et l’a étendu à de

nouveaux partenaires en un temps record.

Détails d’une migration sans heurt.

Avec 16 000 listes de mariage et de PACS déposéesdans ses magasins en 2001, le Printemps reste uneréférence pour la liste de cadeaux auprès des

 jeunes couples.A travers son réseau de 20 maga-sins, les clients peuventdéposer et gérer leurliste, accueillir les donsde leurs proches etconcrétiser leursachats en magasin. Jusqu’en octobre der-nier, ces listes étaient gé-rées par un systèmeMainframe, que la directioninformatique du Printempsne souhaitait plus maintenir.

En 2000,elle lance un projetde rénovation du système etd’évolution du principe de laliste de mariage à travers unaxe multi enseigne. Le projetest confié à la filiale Prin-temps.com SA,la filiale inter-active du groupe. Pour l’ai-der dans cette tâche derefonte sur la technologie Web d’une pièce nonnégligeable de son système d’information, le Prin-temps s’entoure des compétences de FI System,pour le cadrage fonctionnel, l’intégration et le dé-veloppement technique du projet.En son temps, pionnier du concept de " Web Agen-cy", FI System a assuré des prestations portant sur

l’accompagnement au changement, les modalités de

fonctionnement inter enseignes,les relations fournis-

seurs, la constitution du catalogue en ligne, l’assistan-

ce à la maîtrise d’ouvrage.Une équipe d’une vingtai-

ne de collaborateurs a été mobilisée sur ce projet.

En janvier 2002, la filiale interactive du Printempset la société de services ont décidé, conjointement,de choisir la plate-forme .Net pour le développe-ment de composants métier spécifiques à l’universdu mariage. Les composants sont crées en C# sousVisualStudio.Net et exploitent toutes les potentia-

lités du framework.

Un choix raisonné

Les principaux critères de choix de la plate-formefurent dictés par certaines contraintes liées au pro- jet.Tout d’abord, l’environnement Microsoft est unchoix du groupe Printemps.D’autre part, le projet,au forfait, devait se réaliser dans un cadre strict,pour permettre le transfert des données du Main-frame à la base SQL, sans impact sur le travail enmagasin.Ce transfert s’est réalisé en 15 heures enone-shot, lors d’un week-end (4 à 5 Go de don-nées). Le choix de .Net s’est aussi effectué aprèsdes recherches sur la possibilité de redévelopperle site dans la technologie ASP existante. PierreChiandusso, responsable technique de ce projetpour FI System, explique : " le Printemps souhaitait

avoir une plate-forme pérenne et évolutive.Le pro- jet était aussi de pouvoir déployer cette plate-forme vers d’autres enseignes du groupe.Or la technologie DNA est vieillissante,

si ce n’est en train de mourir. Nous nous sommesdonc orientés vers un autre choix ". Sur le seul dé-veloppement, Pierre Chiandusso estime à 10 % le

gain obtenu par l’utilisation de C# et du framework .Net, par rapport à ce qui aurait pu se faire en ASP.Un autre axe d’étude a été de porter la plate-formesur Commerce Server 2000 de Microsoft. Là, lesfonctionnalités spécifiques du projet faisaient queles composants du serveur Commerce Server2000 auraient excédé leurs possibilités fonction-nelles, avec le risque de ne pas répondre complè-tement aux besoins.Le responsable technique duprojet chez FI System ajoute : " cela aurait été vrai-ment tiré par les cheveux ".Avec l’aide des équipesde Microsoft Consulting et l’exemple de l’applica-tion développée par Microsoft chez L’Oréal, les

partenaires sont alors tombés d’accord sur le choix

6•LE PRINTEMPS SE MARIE AVEC C# !

Printemps.com SA

est la filiale

interactive du

groupe France

Printemps,filiale

du groupe PPR

(Pinault Printemps

Redoute).Créée

en août 2000, elle

gère les activités

Internet du groupe

et intervient en

tant que spécialiste

des technologies

Web.A travers son

magasin phare du

boulevard Hauss-

mann et ses 16

autres magasins, le

Printemps jouit

d’une réputation

internationale.Il

est une des

références dans le

secteur des grands

magasins.

Récemment,à côté

de ces magasins, le

groupe a développé

de nouvelles

enseignes spéciali-

sées dans les

domaines du sport,

de la bijouterie

 joaillerie et des

voyages.

 E N T R E P R I

 S E

E

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 48/58Programmez N°50 • FEVRIER 2003

67 

de .Net " sans avoir plus d’informationsque cela " renchérit Pierre Chiandusso.Un véritable saut dans l’inconnu ! Lescomposants redéveloppés n’ont étéque ceux apportant une valeur particu-lière au projet. Certains composantsexistant en ASP ont donc été conser-

vés.Ces composants migreront en dou-ceur lors des évolutions successives.Une coexistence exemplaire entre an-ciens et nouveaux modèles de pro-grammation !Des serveurs Windows 2000 Advanced

Server, en équilibrage de charge, assurent

la présentation Web par IIS et l’exécution

des objets métier. La gestion des données

est assurée par un serveur de base de

données SQL Server 2000 Entreprise

Edition, en cluster de balancement, pour garantir une

haute disponibilité.Pierre Chiandusso s’enthousias-

me : " j’ai été vraiment surpris par la tenue à la char-

ge. Cela fonctionne vraiment très bien. Les perfor-

mances sont très proches de ce que nous obtenons

habituellement sur une plate-forme JAVA ".

L’intégration avec le système Mainframe a été réa-lisée en échangeant des données XML sur des liai-sons HTTP. Dans le contexte, l’équipe projet a es-timé qu’une infrastructure de services Web surSOAP serait surdimensionnée.Cette approche estcependant retenue pour l’évolution à venir du site,en autorisant la distribution sur un réseau de par-tenaires des offres du site de listes de mariages.Lasolution communique, de plus,en temps réel avecl’ensemble des caisses des magasins, les systèmes

d’autorisation de paiement et se synchronise auxréférentiels produits des différentes enseignes dugroupe, ainsi qu’au back-office monétique du Prin-temps."Le point le plus difficile du projet s’est situé

là. Le printemps avait beaucoup externalisé decompétences. Il nous a été parfois difficile de trou-ver la bonne personne, avec la bonne information,

au bon moment,pour répondre à nos questions surdes protocoles spécifiques, comme par exemple,sur la communication avec les caisses des magasins"se souvient Pierre Chiandusso.

Un lancement réussiLancée depuis le 1er octobre dernier, la plate-forme est accessible par intranet depuis les 20 ma-gasins printemps, sur le site Webprintempsadeux.com, sur le 3615 Printemps etdans les magasins partenaires (Citadium,Confora-ma, FNAC,Printemps Voyages). Depuis sa mise enproduction en juin 2002,le nouveau système a géré

plus de 350 000 dons et 200 000 opérationsd’achats. Il est utilisé par plus de 850 collaborateursen mode intranet et extranet.  

Bertrand Garé 

FI Systemen bref

FI System est une

 société de conseil et de

 services pour les grands

comptes

français et internationaux dans le domaine

des architectures

distribuées,

des systèmes à base

de clients Web et

des problématiques

 multi accès.

L’entreprise est

 implantée en France,

en Grande-Bretagne, en

Belgique et

en Italie. Elle est cotée

 au Nouveau Marché de

 la Bourse de Paris. En

dix ans, l’entreprise a réalisé plus de 2000

 projets et

 missions. Elle a été

classée, premier

 intégrateur spécialisé

e-business et nouvelles

technologies, dans les

classements des études

PAC et Markess en 2001.

Pourquoi avoir fait le choix de C# ? 

Si l’on se replace dans le contexte, cela aété au début un choix d’impulsion. Pourrésumer, le projet était prévu au plus justedans le temps. FI System a su nousconvaincre des gains potentiels d’un pas-sage à un langage plus structuré et au fra-

mework de Microsoft. Les équipes de FIétaient de plus très motivées sur la plate-forme. Elles étaient d’ailleurs très surprisesde la stabilité et des performances. Leursassurances ont emporté la décision.D’ailleurs nous n’avons pas été déçus etnous sommes satisfaits du fonctionnementde la plate-forme. De plus,ce développe-ment se devait d’être de qualité, car il n’estpas là pour quelques mois, mais pour ser-vir de base pendant longtemps aux pro-chaines évolutions du système. Sur cepoint, les assurances de Microsoft nous

ont pleinement rassurés. Un petit regret

peut être,nous aurions pu les associer plustôt au projet et tirer encore plus profit deleur expérience.

Quel a été le plus complexe dans le

 projet ? 

Le plus difficile a été, sans conteste, l’inté-

gration avec les systèmes mainframe. Pourune part, le projet les a remplacés mais ilen subsiste encore, comme le lien avec lessystèmes d’encaissements, la gestion descatalogues produits. Sur certains de cessystèmes, il était difficile d’avoir les bonnesconnaissances, au bon moment, du fait deleur ancienneté. Il a vraiment fallu peaufi-ner l’urbanisme et l’architecture de la so-lution. Au milieu du projet, il nous a aussifallu réaliser une reprise des données,pourles faire migrer de l’ancien système de baseà plat pour les ré éclater vers le nouveau

système relationnel.

Quelle est votre principale satisfaction

aujourd’hui ? 

Il n’était pas évident de faire fonctionnerle projet. Nous n’avions à l’époque aucu-ne assurance sur sa faisabilité en temps eten heure. Nous avons démontré qu’avecce type de technologie, nous pouvions

avoir des programmes ambitieux, sur despièces entières du système d’information.Croyez moi, nous avons surpris tout lemonde sur le temps de déploiement de lasolution ! La flexibilité de la plate-formenous permet de plus, d’être dynamiqueset imaginatifs, pour proposer des nou-veautés sur la plate-forme. Nous avonsainsi mis en place une fonction d’avis decadeaux par SMS pour les couples ayantdéposé leur liste chez nous. Cela auraitété inimaginable sur l’ancienne plate-forme. Cela a pris seulement quelques se-

maines avec celle-ci ! !  

Trois questions à Benoît Rigaut, Directeur technique de Printemps.com SA

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 49/58

Scénario d'utilisation

L’exemple présenté dans cet article implémente une calculette

sous forme d’un web service. Un WebModule sera utilisé pour 

fournir une DLL ISAPI/NSAPI déployée sur un serveur IIS 5 de

Microsoft. C’est lui qui générera les appels distants au web servi-

ce. La partie cliente sera un exécutable qui générera un proxy, à

partir du contrat d’échange WSDL du web service distant.

Créer un web service avec Delphi 7Nous allons créer un web service sous la forme d’une petite calcu-

lette élémentaire.

• Dans le menu principal " Fichier | nouveau | autre… " sélec-

tionnez l’onglet " WebServices".

• Double-cliquez sur l’icône " SOAP Server Application ".

•Appuyez sur le bouton "Ok ".

• Sélectionnez le radio bouton

" Librairie de lien Dyna-

mique ISAPI/NSAPI ".

•Appuyez sur le bouton "Ok "

Une fenêtre de dialogue appa-

raît vous demandant si vousvoulez créer une interface pour

un module SOAP..

Les Web Services en

Delphi 7

fonctionnent sur

plusieurs serveurs

(IIS ou Apache, ou le

débogueur

d’application web de

Delphi).

       P       R       A

       T       I       Q

       U       E

NIVEAU : DÉBUTANT

Programmez N°50 • FÉVRIER 2003

8

Nicolas Sciara

Delphi

Les Web Services

sous Borland Delphi 7

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 50/58

•Appuyez sur le bouton " Oui "

Dans la fenêtre " d’ajout d’un nou-

veau web service " :

• Donnez le nom " Calculette " au

nom de votre service ;

• Cochez la case sur la génération des commentaires ;

• Ne cochez pas la génération d’exemple de méthodes ;

• Comme modèle d’activation du service choisissez : "par requête".

•Appuyer sur le

bouton " Ok ".

Trois fichiers d’unités sont générés.

1 - Le fichier " unit1.pas " qui est l’unité du WebModule ;

2 - Le fichier " CalculetteIntf.pas " qui contient l’interface ICal-

culette, permettant de gérer l’appel au WebService. Son intros-

pection permettra la génération du fichier WSDL ainsi que le

proxy d’appel au web service ;

3 - Le fichier " CalculetteImpl.pas " est la classe TCalculette

implémentée à partir de l’interface ICalculette et fournit l’im-

plémentation des méthodes de la calculette.

La calculette fournit quatre fonctions nommées " Ajouter ", " Sous-

traire ", " Multiplier " et " Diviser ".Notez que chaque fonction doit

être déclarée " stdcall " pour les appels distants.

Voici le code associé à l’interface " ICalculette " de l’unité fichier

" CalculetteIntf.pas " :

{ Invokable interface ICalculette }

unit CalculetteIntf;

interface

uses InvokeRegistry, Types, XSBuiltIns;

type

{ Invokable interfaces must derive from IInvokable }

ICalculette = interface(IInvokable)

['{7C5DF5AA-888D-4B01-846D-A2FF86AFB887}']

{ Methods of Invokable interface must not use the default }

{ calling convention; stdcall is recommended }

function Ajouter(a : Double ; b : Double):Double; stdcall;

function Soustraire(a : Double ; b : Double):Double; stdcall;

function Multiplier(a : Double ; b : Double):Double; stdcall;

function Diviser(a : Double ; b : Double):Double; stdcall;

end;

implementation

initialization

{ Invokable interfaces must be registered }

InvRegistry.RegisterInterface(TypeInfo(ICalculette));

end.

Voici le code du web service implémentant les quatre méthodes de

calcul dans la classe " TCalculette " dans l’unité " Calculet-

teIntf.pas " :

{ Invokable implementation File for TCalculette which implements ICalculette }

unit CalculetteImpl;

interface

uses InvokeRegistry, Types, XSBuiltIns, CalculetteIntf;

type

{ TCalculette }

TCalculette = class(TInvokableClass, ICalculette)

public

function Ajouter(a : Double ; b : Double):Double; stdcall;

function Soustraire(a : Double ; b : Double):Double; stdcall;

function Multiplier(a : Double ; b : Double):Double; stdcall;function Diviser(a : Double ; b : Double):Double; stdcall;

end;

implementation

function TCalculette.Ajouter(a : Double ; b : Double):Double;

stdcall;

begin

result := a + b;

end;

function TCalculette.Soustraire(a : Double ; b : Double):Double;

stdcall;

begin

result := (a - b);end;

function TCalculette.Multiplier(a : Double ; b : Double):Double;

stdcall;

begin

result := a * b;

end;

function TCalculette.Diviser(a : Double ; b : Double):Double;

stdcall;

begin

if ( b=0 ) then

result := -1

else

result := a / b;end;

Programmez N°50 • FÉVRIER 2003

69

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 51/58

NIVEAU : DÉBUTANT

Programmez N°50 • FÉVRIER 2003

0

Delphi

initialization

{ Invokable classes must be registered }

InvRegistry.RegisterInvokableClass(TCalculette);

end.

• Renommez le WebModule de l’unité " Unit1.pas " par " WbMdl-

Calculette".

Voici les composants contenus dans ce WebModule :

• un THTTPSoapDispatcher ;

• un THTTPSoapPascalInvoker ;

• un TWSDLHTMLPublish.

Le THTTPSoapDispatcher est un

composant qui publiera le web ser-

vice en utilisant SOAP. Ce compo-

sant répond à tous les appels SOAP.

Il enregistre les interfaces des Web

Services qui lui sont associés, via

l’invocation du registre d’enregis-

trement InvRegistry. Le THTTP-SoapDispatcher reçoit et envoie les

messages SOAP au THTTPSoapPascalInvoker.

Le HTTPSoapPascalInvoker interprète la requête SOAP pour une

interface écrite en Pascal Objet.Ce composant utilise aussi le re-

gistre d’enregistrement InvRegistry pour la classe qui doit s’exé-

cuter.

TWSDLHTMLPublish publie la liste de fichiers WSDL associée aux

Web Services présents dans le WebModule. C’est ce composant qui

donne l’accès au fichier WSDL par le réseau internet. Ce compo-

sant utilise aussi le registre d’enregistrement InvRegistry.

Sauvegarder l’ensemble du projet par le menu " Fichier | Sauve-

garder le projet sous… " :

• Sauvegardez l’unité "Unit1.pas" par "uWbMdlCalculette.pas" ;

• Sauvegardez l’unité " CalculetteIntf.pas " ;

• Sauvegardez l’unité " CalculetteImpl.pas " ;

• Sauvegardez le projet web avec le nom "ServeurCalculette.dpr".

Déployer le web service

Tout d’abord, vous devez connaître le chemin de déploiement de

vos DLL ISAPI/NSAPI pour votre serveur IIS 5. Dans notre cas, le

répertoire par défaut est : " c:\inetpub\scripts ".

Pour le déploiement :

• Sélectionnez le menu principal " projet | options " ;

• Choisissez l’onglet " répertoires | conditions " ;

• Placez dans le chemin de sortie de la DLL "c:\inetpub\scripts".

•Appuyez sur le bouton " Ok ".

• Dans le menu principal choisissez " Projet |Construire Ser-

veurCalculette ".

• Lancez votre navigateur web et placez vous sur l’URL :

" http://localhost/Scripts/ServeurCalculette.dll. "

Le lien hypertexte "[WSDL]" à côté de "ICalculette" permet de

récupérer le fichier XML WSDL du WebService "ICalculette".

On obtient l’URL suivante au niveau du navigateur :

" http://localhost/Scripts/ServeurCalculette.dll/wsdl/ICalculette ".

Cette URL sera l’URL d’appel de notre web service.

Exploiter un web service avec Delphi 7par une application cliente.

Nous allons créer une application cliente sous la forme d’une fiche

d’appel aux opérations de calcul du web service.

• Créez un nouveau projet par le menu " Fichier | nouveau| Ap-

plication "

• Modifiez la forme principale en ajoutant 3 TLabel, 3 TEdit, 1

TGroupBox et 4 TButton pour obtenir la fiche suivante :

• Renommez ces composants par des noms explicites du type

"EdtA" ou " BtnAjouter " ;

• Renommez cette forme en " FrmCalculette " ;

• Enregistrez l’unité "Unit1.pas" sous le nom "uFrmCalculet-

te.pas" par le menu " Fichier | Enregistrer sous… " ;• Enregistrez le projet sous ne le nom " ClientCalculette.dpr "

par le menu " Fichier | Enregistrer le projet sous… " ;

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 52/58Programmez N°50 • FÉVRIER 2003

71

Pour la connexion au web service, nous allons créer une interface

qui servira de proxy de liaison au web service, grâce au fichier

WSDL récupéré sur le " ServeurCalculette ".

• Dans le menu principal " Fichier | nouveau | autre… " sélec-

tionnez l’onglet " WebServices ".

• Double-cliquez sur l’icône " WSDL Importer ".

•Appuyez sur " Ok ".

• Placez l’URL " http://localhost/Scripts/ServeurCalculette.dll/wsdl/

ICalculette " dans le champ de saisie de la " localisation du fi-

chier WSDL ou URL ".

•Appuyez sur le bouton " Suivant ".

Vous voyez apparaître le code de l’interface qui pourra faire appel

au web service et voir la structure de l’interface " ICalculette "en tant que composant.

•Appuyez sur le bouton " Fin ".

L’interface " ICalculette " propose une méthode " GetICalcu-

lette() " qui servira de proxy de communication auprès du web

service distant.On remarquera que cette interface " ICalculette "

n’est pas exactement celle fournie par le web service du projet

"ServeurCalculette.dpr ".

• Enregistrez l’unité "ICalculette1.pas" sous le nom "Calculet-

teProxy.pas ".

Il ne nous reste plus qu’à appeler dans l’unité "uFrmCalculette

.pas" l’interface " ICalculette ".

Voici le code que vous pouvez utiliser sur l’événement " onClick "

du bouton " btnAjouter ".

unit ufrmCalculette;

interface

usesWindows, Messages, SysUtils, Variants, Classes, Graphics, Controls,Forms, Dialogs, StdCtrls;

typeTFrmCalculette = class(TForm)...

procedure BtnAjouterClick(Sender: TObject);...

end;...

implementation

usesCalculetteProxy;

{$R *.dfm}

varcalculette : ICalculette;

procedure TFrmCalculette.BtnAjouterClick(Sender: TObject);var

a, b : Double;begin

a := StrToFloat(EdtA.Text);b := StrToFloat(EdtB.Text);

EdtResult.Text := FloatToStr(calculette.Ajouter(a,b));end;

...

initialisation

calculette := GetICalculette();

end.

On remarquera ici que l’instruction " GetICalculette() " de l’unité "CalculetteProxy.pas " est celle qui permet d’appeler à distance le

web service placé dans l’objet d’interface " calculette " du type "

ICalculette ".

Conclusion

Cet exemple simple de calculette permet de voir comment on peut

créer un web service. Nous constatons que pour cette technolo-

gie, Delphi 7 garde son orientation composant, notamment au ni-

veau du WebModule du coté serveur.Toute la tuyauterie SOAP est

prise en charge par l’outil. Le développeur ne doit se concentrer

que sur le codage de son interface et de sa classe proposant un web

service.   Nicolas Sciara

Consultant-formateur ASTON 

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 53/58

SGBD

Programmez N°50 • FÉVRIER 2003

SGBD : au cœur du systèmed’information

Les bases de données sont incontournables dans la structure de

l’entreprise. Avec l’apparition des interfaces graphiques et des sys-tèmes modernes, les SGBD n’ont cessé d’évoluer et de s’enrichir 

de nouvelles fonctions. Les besoins et attentes des utilisateurs

changent aussi. Pour mieux y répondre et suivre l’évolution du

marché, les SGBD savent s’adapter et se segmenter. Véritable

aubaine pour ces systèmes, Internet a vu l’apparition d’une nou-

velle race de bases de données. Tous les sites de e-Commerce,

d’information, les intranets, les extranets, ont besoin d’une base

de données ! Mais finalement, malgré toutes les évolutions, les

fonctions de base d’un SGBD restent les mêmes : gérer, manipuler 

et stocker des données, de la plus simple à la plus complexe.

N’oublions pas l’indéboulonnable langage SQL ! Il s’agit du langa-

ge de requête le plus utilisé.

Concurrent etpartenaire des IDECette interrogation vous paraît idiote ? Pourtant, on est en droit de

se la poser, avec l’évolution des SGBDR intégrant des modules de

création d’interface utilisateur, couplés à de puissants éditeurs de

code et des débuggeurs. L’un des pionniers fut 4D, avec lequel il

est bien entendu, hors de question de développer des projets

volumineux. Ce genre de SGBDR est réservé aux applications

nécessitant une gestion de données. Aujourd’hui, bien des fonc-

tions traditionnelles aux environnements de développement sontincluses dans les SGBDR : notions de classes et d’objets, architec-

ture add-on, éditeur de code, débuggeur interne, recherche

indexée, compilateur, multi plates-formes, etc. L’avantage de ces

solutions est leur relative simplicité de développement, contraire-

ment à un Jbuilder ou même un Visual Basic. Dans bien des cas, le

SGBDR suffit amplement dans la conception des applications. Il

existe même des environnements de développement intégrant

une base de données, tels que Jbuilder ou REALBasic. Dans ce cas,

les SGBD deviennent des modules à part entière de l’environne-

ment de développement, facilitant l’intégration et la manipulation

de données dans un projet, même si le développeur ne trouve pas

(toujours) toutes les fonctions d’un véritable SGBD.Si le SGBD peut se retrouver intégré dans un IDE classique, il peut

aussi être un partenaire. Car bien souvent, des bases de données

sont interfacées avec des outils de développement, tels que Visual

Basic avec Access. Sur les sites Web, il y a la plupart du temps, uti-

lisation d’une base de données, via des pages Web. Les dévelop-

peurs ont aussi à leur disposition, non pas des SGBD, mais de

simples moteurs de bases de données. Il s’agit de librairies de

développement, contenant toutes les fonctions de gestion et detraitement des données que l’on trouve dans un vrai SGBD. Ces

SGBD d’un troisième type sont orientés objets (C++ ou Java).

Le rendez-vous manquédes SGBDOOAprès l’apparition des premières bases de données relationnelles,

l’émergence de nouvelles applications et de nouveaux marchés

informatiques, incita à une évolution des SGBD. Cette évolution

était motivée par le besoin de traiter et de manipuler des données

complexes. Les SGBDOO semblaient pouvoir répondre aux lacunes

des SGBDR, tout en offrant la programmation objet. Dès le début,

les SGBDOO se sont concentrés dans des marchés scientifiques ou

la CAO, voire les données multimédia.

Le SGBDOO a commencé son existence au milieu des années

1980. Plusieurs projets se développèrent en France et aux États

Unis. L’environnement Gemstone fut l’un des premiers SGBDOO à

être vendu en 1988. Non sans un certain préjugé : les analystes et

concepteurs prédisaient déjà un effet rouleau compresseur. Que

peut-on en conclure dix ans après ? Pas grand- chose. Mis à part

quelques niches, les SGBDOO n’ont jamais réussi à s’imposer. IDC,

en 1996, estimait que les SGBDOO représenteraient moins de 2 %

du marché des bases de données en 2001 alors que les SGBDR

représenteraient, sur la même période, près de 80 % ! Et finale-ment, ces chiffres restent d’actualité. Avec les années, l’offre SGB-

DOO s’est considérablement amoindrie. Actuellement, seul Versant

propose une véritable solution objet, ObjectStore s’étant dévié de

l’architecture de données objet et O2 n’existant plus.

 Jusqu’à présent, les domaines d’application des SGBDOO étaient

très limités. Deux marchés s’ouvrent à eux : l’Internet et la techno-

logie Corba. De plus en plus, les données traitées, via Internet,

deviennent complexes. Les SGBDOO savent parfaitement manipu-

ler ce type de données, notamment les documents XML. Et Corba ?

Avec l’apparition de Java2, Corba et Java sont très liés. Comme

Corba permet de construire des composants objets, pourquoi ne

pas avoir un processus entièrement objet des données (avec lesSGBDOO) aux clients ? Les capacités objet des SGBDOO peuvent

aussi intéresser les salles de marchés ou les banques, leurs don-

Les bases de données : mise au pointComme bien souvent en informatique, derrière une abréviation se cache une multitude de

catégories, les bases de données n’y échappent pas. On a l’habitude de désigner la base de données

sous le terme SGBD (Système de Gestion de Base de Données) ou plus souvent par SGBDR (R pour

Relationnel). Mais on oublie souvent les SGBDOO, les SGBD, les moteurs de base de données, etc.

2

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 54/58Programmez N°50 • FÉVRIER 2003

nées se complexifiant, il faut pouvoir adapter rapidement les

outils de travail. Encore, une fois, le SGBDOO est un choix intéres-

sant.

Les développeurs et responsables ont vu des SGBDR étranges

apparaître : les " SGBDR/O (Relationnels/Objets) ". Cette nouvelle

génération de SGBDR est censée apporter la souplesse de l’objetà des bases relationnelles. Or, si l’objet apporte de réels avan-

tages dans le développement d’applications de bases de données,

les données manipulées ne sont nullement objet, limitant quelque

peu l’attrait des SGBDR/O. Si des SGBDR classiques possèdent des

notions objets (Visual FoxPro ou Oracle 9i), toutes les bases Java

sont des SGBDR/O. Ce type de base permet un meilleur dévelop-

pement d’application et de manipulation des données.

Internet avant les Web ServicesL’explosion d’Internet et du e-Commerce a bien entendu profité

aux SGBD. Si, au départ, peu de bases de données savaient tra-vailler avec le Web, c’est désormais un argumentaire de vente.

Oracle pousse son ouverture Web depuis Oracle 8i. La multiplica-

tion des serveurs d’applications a permis aux grandes bases de

données de trouver un nouveau créneau. Le SGBD est l’élément

indispensable pour tout site eBusiness !

Comment se traduit cette invasion du Web dans un SGBD ? Il exis-

te plusieurs méthodes pour cette intégration. La plus commune

consiste à générer des pages Web à partir de données, ou à réali-

ser une publication de données (toujours via des pages HTML). A

cela peuvent s’ajouter quelques fonctions intéressantes, telles que

l’intégration d’un serveur Web dans le SGBD. Dans certains cas, il

s’agit aussi d’inclure des balises HTML (ou XML) directement dans

le code de sa base de données. Cette particularité offre une

meilleure interaction entre le Web et la gestion des données.

SGBD sous Linux : la confirmationIl y a encore deux ans, aucun grand SGBD n’avait encore pris le

tournant Linux. Or, depuis, que d’annonces ! Linux est bien enten-

du un système serveur que les entreprises semblent apprécier de

plus en plus. Il devient une plate-forme de développement, au

même titre qu’un Windows ou MacOS. S’il existe une large offre de

bases de données (souvent) en Open Source et gratuites, la quali-

té de celles-ci se pose. C’est seulement avec la sortie de DB2

d’IBM, ou encore d’Oracle, que nous avons pu apprécier un relève-ment qualitatif des SGBD sous Linux.

Le choix de développer une base sous Linux peut poser deux pro-

blèmes : l’ interface graphique et la distribution Linux.

Explications : Il n’existe pas un Linux, mais des Linux, ou plutôt

des distributions Linux. Or, un SGBD pourra fonctionner sous une

version Linux Red Hat, mais pas sur la distribution Corel Linux ou

Linux SuSe, et inversement ! Même problème au niveau interface

graphique. Sous Linux, il existe plusieurs interfaces, les deux prin-

cipales étant Gnome et KDE. Un SGBD peut fonctionner sous KDE

mais pas sous Gnome et inversement !

Si on laisse de côté ces problèmes, l’offre sous Linux devient réel-

lement intéressante et compétitive. En effet, outre les SGBD poidslourds, les développeurs et entreprises disposent d’une panoplie

impressionnante de SGBD libres. Historiquement, Linux possède

deux SGBD de référence : MySQL et PostgreSQL. Ces systèmes

prennent aujourd’hui le chemin de l’interface graphique. Comme

nous l’avons mentionné, vous aurez le choix, aujourd’hui, entre

DB2 d’IBM, Oracle / d’Oracle, Interbase de Borland ou encore

Sybase. Vous l’aurez compris, ce sont des SGBD professionnels.

Pour les petites entreprises et indépendants, l’offre Linux est loind’être pléthorique.

Si l’offre sur Linux peut dans certains cas être intéressante, il exis-

te malgré tout un problème non négligeable : l’offre technolo-

gique. Si vous travaillez en environnement Windows 2000, vous

ne trouverez pas les mêmes technologies sur Linux, pas de sys-

tèmes OLE, ActiveX, Com ou ADO ! Car il ne faut pas oublier que le

choix d’une base de données se fait aussi sur les technologies

système et, sur ce point, les SGBD Linux ont encore quelques

lacunes. Même si, pour les bases comme Sybase ou Oracle, les

technologies sont disponibles en interne.

SGBDR Java etl’univers de l’embarquéL’explosion de Java a, en toute logique, fait évoluer l’offre de

SGBD. Si les premières bases 100 % Java manquaient singulière-

ment de performance et de stabilité, force est de constater que

désormais, l’offre est parfaitement fiable et mature. L’énorme

avantage d’un SGBDR Java sur un SGBDR classique est son aspect

multi plate-forme, à la fois au plan système et au plan matériel !

Bien souvent, il suffit de disposer d’une machine virtuelle Java (ou

 JVM) pour accéder à une base de données, à partir d’un simple

assistant numérique (PDA) ! Un SGBD Java est souvent désigné

pour les systèmes embarqués (PDA et terminaux mobiles divers).

Avec la multiplication des terminaux mobiles de toutes catégories,

les entreprises ont du déployer leurs données sur ces nouveaux 

produits et faire appel aux systèmes embarqués. Les bases de

données s’adaptent aux contraintes de l’embarqué : un poids

réduit au maximum, une empreinte mémoire réduite, réplication,

éventuellement implémentation des fonctions temps réel. Les

bases embarquées étaient jusqu’alors plutôt des bases Java, mais

les SGBD classiques sont de plus en plus utilisés (ex. SQL Server 

2000).

Les bases Java ont du mal à s’imposer, surtout dans l’environne-

ment PocketPC. Microsoft a su intégrer son SQL Server à l’informa-

tique mobile. De plus, le retard de Java dans le domaine des WebServices constitue aussi une autre faiblesse. Le prix de certaines

solutions Java finit de décourager. Si il y a 1 ou 2 ans, l’offre Java

dans les SGBD était intéressante, aujourd’hui, c’est un peu moins

le cas.

XML : incontournableGrâce à l’arrivée des Web Services, de .NET et de la demande de

standardisation des formats, XML a su s’imposer. Aujourd’hui, il

est impensable de ne pas utiliser et déployer une architecture

sans utiliser XML, surtout dans une configuration inter entreprise.

XML est un label. Software AG l’a parfaitement compris.  

François Tonic    73

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 55/58

u que ludiqueludiqueludiqueludique ludique 

La classe de base

CD3DapplicationLa classe de base CD3DApplication permet de

créer des applications avec Direct3D 8.0.

Ainsi, pour créer une simple application

Direct3D, il vous suffit simplement de dériver 

cette classe en une autre classe (dans

l’exemple, cette nouvelle classe dérivée se

nomme CCubiqueApplication ) et de comman-

der les fonctions suivantes selon vos besoins.

La classe dérivéeCcubiqueApplicationLa classe CCubiqueApplication est donc direc-

tement dérivée de la classe de base CD3DAp-

plication. Voici la structure de cette classe

dérivée. Les matrices de l’application sont

d’abord définies :

class CCubiqueApplication : public CD3DApplication

{

// Matrices de l'application

D3DXMATRIX D3DXMatriceTransEnv3D;

D3DXMATRIX D3DXMatriceTransVision;

D3DXMATRIX D3DXMatriceTransProj;D3DXMATRIX D3DXMatriceEnvCtrlSouris;

Ici, trois matrices différentes sont définies. La

première est la matrice de transformation de

l’environnement 3D, la deuxième est la matri-

ce de transformation de la vision et la troisiè-

me est la matrice de transformation de la

projection.

La dernière matrice que vous définissez est la

matrice D3DXMatriceEnvCtr lSouris qui vous

permettra plus tard de contrôler le champ de

vision en manipulant la souris.

Ensuite, vous utilisez deux objets de typeCD3DMesh pour définir les objets 3D de

l’environnement. Ces objets sont la sphè-

ID3DXEffect* ID3DXEffect;

// Note : l'interface ID3DXEffect est utilisée pour

ajuster, requérir

// des effets spéciaux et sélectionner des techniques.

L’objet Direct3D suivant est particulier, il est

utilisé pour le processus de rendu des enve-

loppes environnantes cubiques ou sphé-

riques. Vous le définissez, via l’objet

ID3DXRenderToEnvMap.

ID3DXRenderToEnvMap* ID3DXRenderToEnvMap;

// Note : l'interface ID3DXRenderToEnvMap est utili

sée pour généraliser

// le processus de rendu des enveloppes environnantes.

Les deux variables suivantes, ID3DCubi-

queEnv et ID3DSpheriqueEnv, seront utilisées

pour manipuler les ressources de textures des

enveloppes cubiques et sphériques.

IDirect3DCubeTexture8* ID3DCubiqueEnv;

// Note : les applications utilisent les méthodes de

l'interface

// IDirect3DCubeTexture8 pour manipuler une

ressource de

// texture cubique.

IDirect3DTexture8* ID3DSpheriqueEnv;

// Note : les applications utilisent les méthodes de

l'interface

// IDirect3DTexture8 pour manipuler une ressource de

// texture. Ici, elle est utilisée pour l'enveloppe

sphérique.

N’oubliez pas de créer une variable booléen-

ne permettant de contrôler l’état de la souris.

DirectX et la technique3Dd’environnement cubiqueCe mois-ci, nous allons poser les fondations du projet

et décrire les différents objets de base utilisés pour

concevoir le code source, initialiser l’application et

gérer les événements Windows interagissant avec

l’application.

Par Laurent Jayr 

Seconde partie

ludique 

Programmez N°50 • FÉVRIER 2003

8

re centrale réfléchissante, définie par 

CD3DMeshSphereRef le x, et la boîte de l’envi-

ronnement qui vous permettra de simuler un

environnement tridimensionnel autour de la

sphère et de la caméra. Cette boîte 3D est

définie par CD3DMeshSkyBox. Cet objet porte

généralement le nom de skybox.

// Objets 3D de l'application

CD3DMesh* CD3DMeshSphereReflex;

CD3DMesh* CD3DMeshSkyBox;

// Note : la classe CD3DMesh est utilisée pour

charger et rendre

// des modèles sous forme de fichiers

Vous définissez ensuite l’objet ID3DXEf f ect

qui sera utilisé pour les effets spéciaux que

vous utiliserez dans l’application.

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 56/58Programmez N°50 • FÉVRIER 2003

u que uu queu queludiqueludique ludique udique 

0

// Variable booléenne pour contrôler l'état de la souris

// (fonctionnant comme une trackball) :

BOOL bCaptureSouris;

Enfin, vous terminez l’élaboration de cette

classe en redéfinissant quelques fonctions

dérivées de la classe de base CD3DApplica-

tion.

// Fonctions protégées redéfinies à partir de la

classe de base :

protected:

HRESULT RenderScene( CONST D3DXMATRIX*

pVision,

CONST D3DXMATRIX* pProjection,

BOOL bSphereRendu );

HRESULT ConfirmDevice( D3DCAPS8*, DWORD,

D3DFORMAT );

HRESULT OneTimeSceneInit( );

HRESULT InitDeviceObjects( );

HRESULT RestoreDeviceObjects( );

HRESULT InvalidateDeviceObjects( );

HRESULT DeleteDeviceObjects( );

HRESULT Render( );

HRESULT FrameMove( );

HRESULT FinalCleanup( );

// Fonction protégée, non définie dans la classe

de base :

HRESULT RenderScene3DEnv( );

La dernière fonction définie est MsgPr oc( ).

Cette fonction vous permettra de gérer les

messages Windows à traiter et en particulier 

ceux qui proviennent de la souris. Cette fonc-

tion est aussi dérivée de la classe de base.

// Fonction publique issue de la classe de base :

public:

LRESULT MsgProc( HWND hwnd,

UINT message,WPARAM wParam,

LPARAM lParam );

// Constructeur interne :

CCubiqueApplication( );

};

La définition de votre classe d’application est

ensuite directement suivie par le paramétrage

et l’initialisation de ses attributs.

CCubiqueApplication::CCubiqueApplication( )

{

m_strWindowTitle = _T("Technique d'environnement

cubique");

m_bUseDepthBuffer = TRUE;

bCaptureSouris = FALSE;

CD3DMeshSphereReflex = NULL;

CD3DMeshSkyBox = NULL;

ID3DXEffect = NULL;

ID3DXRenderToEnvMap = NULL;

ID3DCubiqueEnv = NULL;

ID3DSpheriqueEnv = NULL;

}

La fonctionWinMain( )La fonction WinMain( )

est toujours le point

d’entrée de votre appli-

cation, mais elle fait à

présent appel à deux 

fonctions dérivées de la

classe de base : Create( 

 ) pour l’exécution du

processus de création

de la fenêtre de l’appli-

cation et Run( ) pour 

l’exécution du proces-

sus de gestion des mes-

sages Windows. La

fonction Run( ) est utilisée pour assurer le

chargement des accélérateurs clavier (si

nécessaire), pour réceptionner et gérer les

messages Windows en utilisant les fonctions

Win32 PeekMessage( ) ou GetMessage( ),

pour transmettre et distribuer les messages

avec la queue de traitement des messages.

Pour finir, elle permet de procéder au rendu

d’une frame (image) pendant une phase inac-

tive, avec aucun message en traitement dans

la boucle de gestion des messages.

INT WINAPI WinMain( HINSTANCE hInst, HINS

TANCE, LPSTR, INT )

{

CCubiqueApplication d3dApp;

if( FAILED( d3dApp.Create( hInst ) ) )

{return 0;

}

return d3dApp.Run( );

}

Le processusd’initialisationde la scène

Comme toujours, le processus traité en pre-

mier est un processus d’initialisation. Dans le

code du programme env_cubique.cpp, vous

trouvez donc tout naturellement la fonction

InitDeviceObjects( ), fonction d’initialisation

de la scène 3D.

Cette fonction, appelée par Initialize3Denvi-

ronment( ) qui est elle-même intégrée dans la

fonction Create( ) de la classe de baseCD3DApplication. InitDeviceObjects( ) est

donc obligatoirement appelée lors du proces-

sus d’initialisation de l’application.

HRESULT CCubiqueApplication::InitDeviceObjects( )

{

// Chargement de la skybox, mesh 3D décrite dans le

fichier

// au format X "skybox01.x" :

if( FAILED( CD3DMeshSkyBox->Create( m_pd3dDevice,

_T("skybox01.x") ) ) )

{

// Si le fichier "skybox01.x" n'est pas trouvé,

// retourner un message d'erreur :return D3DAPPERR_MEDIANOTFOUND;

}

// Chargement de la sphère centrale. Cette mesh 3D est

décrite

// dans le fichier au format X "sphere01.x" :

if( FAILED( CD3DMeshSphereReflex->Create( m_pd3d

Device, _T("sphere01.x") ) ) )

{

// Si le fichier "sphere01.x" n'est pas trouvé, retourner

// un message d'erreur :

return D3DAPPERR_MEDIANOTFOUND;

}

La fonction d’initialisation procède en premier 

lieu, au chargement des objets 3D (mesh 3D)

de l’application, via la fonction Create( ) défi-

nie dans les fichiers d3df ile.cpp et d3df ile.h. Il

ne faut pas confondre cette fonction avec la

fonction Create( ) définie dans les fichiers

d3dapp.cpp et d3dapp.h. En effet, la fonction

Create( ), issue de la classe CD3DMesh, est

utilisée pour charger et rendre des objets 3D

définis dans des fichiers au format X.

Ensuite, la procédure d’initialisation ajuste les

propriétés de la sphère réfléchissante, par 

l’intermédiaire de la fonction SetFVF( ), défi-

nie dans les fichiers d3df ile.cpp et d3df ile.h.

// Ajuster les propriétés de la sphère réfléchissante

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 57/58Programmez N°50 • FÉVRIER 2003

ue   ludique

l u d i q u e l u d i q u e

81

// via la fonction SetFVF( ).

// SetFVF est définie dans les fichiers d3dfile.cpp et

d3dfile.h

CD3DMeshSphereReflex->SetFVF(m_pd3dDevice,

D3DFVF_XYZ | D3DFVF_NORMAL);

Vous retrouvez, pour finir, la fonction

D3DXCr eateEf fect( ) que vous avez étudiée

précédemment. Cette fonction permet de

créer un certain nombre d’effets spéciaux, en

analysant le contenu de chaînes de carac-

tères, placées en argument avec la liste gEf-

fetsSpec( ).

// Création d'effets spéciaux à partir d'une séquence

de chaînes

// de caractères.

// Chaque chaîne contient une instruction d'effet.

if( FAILED( D3DXCreateEffect( m_pd3dDevice,

gEffetsSpec,sizeof(gEffetsSpec) - 1,

&ID3DXEffect, NULL ) ) )

{

// Si échec :

return E_FAIL;

}

return S_OK;

}

Un peu de théorie :la définition des

quaternionsVous savez que Direct3D peut définir la posi-

tion et l’orientation des vertex. Chaque vertex 

dans une primitive est décrit par un vecteur 

qui donne sa position, sa couleur, les coor-

données de sa texture et un vecteur normal

qui donne son orientation.

Les quaternions ajoutent un quatrième élé-

ment aux valeurs tridimensionnelles x, y, z, en

définissant un vecteur supplémentaire. Les

quaternions sont en fait une alternative aux méthodes matricielles typiquement utilisées

pour la rotation 3D. En effet, un quaternion

représente un axe dans un environnement 3D

et une rotation autour de cet axe. Par 

exemple, un quaternion peut représenter un

axe (3, 3, 1) et une rotation de 3 radians

autour d’un axe précis.

La bibliothèque Direct3DX propose un certain

nombre de fonctions qui peuvent vous aider à

travailler avec des quaternions. Par exemple,

vous utiliserez dans votre application la fonc-

tion D3DXMatrixRotationQuaternionA xis, qui

ajoute une valeur de rotation à un vecteur 

définissant un axe de rotation et qui retourne

le résultat dans un quaternion défini par une

structure D3DXQUATERNION.

Ces capacités sont utilisées dans la fonction

qui suit et que nous allons analyser en pro-

fondeur. Elle permet de gérer le pivotement

de la caméra dans l’environnement tridimen-sionnel. Ces fonctionnalités seront directe-

ment gérées dans la fonction MsgProc( ) qui

permet la gestion des messages de l’applica-

tion.

La gestion desmessages del’applicationLes messages de l’application sont donc

gérés par la fonction MsgProc( ), fonction de

la classe d’application CCubiqueApplication.

Elle permet de paramétrer les événements et

les messages à traiter dans la queue des mes-

sages, en particulier ceux qui sont liés aux 

mouvements de la souris et à l’utilisation de

ses boutons. Grâce à elle, vous pouvez faire

pivoter la caméra sur les trois axes de l’envi-

ronnement 3D, en l’associant au déplacement

du curseur de la souris dans la fenêtre de

l’application et en capturant les clics du bou-

ton gauche de la souris qui fonctionnera ainsiun peu comme une trackball.

Dans cette fonction, vous utiliserez pour la

première fois le concept mathématique des

quaternions pour traiter la rotation de la

caméra, ainsi que quelques fonctions mathé-

matiques permettant de gérer et de manipu-

ler des matrices. Nous n’expliquerons pas en

détail pour quelles raisons sont manipulées

ces matrices car cela nécessiterait un traité

mathématique trop complexe, sortant du

cadre pratique de ce dossier. Nous estimons

donc que cette procédure est transparente

pour le développeur.

LRESULT CCubiqueApplication::MsgProc(

HWND hwnd,

UINT message,

WPARAM wParam,

LPARAM lParam )

{

// Si le bouton gauche de la souris est presséif( WM_LBUTTONDOWN == message )

{

D3DXMATRIX D3DXMatriceCurseur;

Un message signalant une pression sur le

bouton gauche de la souris est d’abord détec-

té, via le message WM_LBUTTONDOWN. Vous

définissez une première matrice de type

D3DXMATRIX nommée D3DXMatriceCurseur.

/*

D3DXQUATERNION est une structure permettant

de décrire un quaternion.

typedef struct D3DXQUATERNION{

FLOAT x, y, z, w;

} D3DXQUATERNION;

*/

D3DXQUATERNION D3DXQuatCurseur=D3DUtil_

GetRotationFromCursor(m_hWnd);

// la fonction D3DUtil_GetRotationFromCursor( ) retourne

// un quaternion pour la rotation provoquée par la

position du curseur

// de l'application.

// Cette fonction est définie dans d3dutil.cpp et

d3dutil.h

Ensuite, vous utilisez une structure de type

D3DXQUATERNION pour retourner un quater-

nion sur la rotation provoquée par la position

du curseur de l’application, via la fonction

D3DUtil_GetRotationFromCursor( ) définie

dans les fichiers d3dutil.cpp et d3dut il.h. Le

résultat de cette opération est renvoyé dans

la structure D3DXQuatCurseur.

/*

La fonction D3DXMatrixRotationQuaternion

construit une matrice

pour un quaternion :

D3DXMATRIX* D3DXMatrixRotationQuaternion

(D3DXMATRIX* pOut,

CONST D3DXQUATERNION* pQ

7/25/2019 Programme z 050

http://slidepdf.com/reader/full/programme-z-050 58/58

u que u queu queludiqueludique ludique udique 

  u);

Paramètres

pOut : pointeur vers une structure D3DXMATRIX qui

est le résultat de

l'opération.

pQ : pointeur vers la structure source D3DXQUA

TERNION.*/

D3DXMatrixRotationQuaternion( &D3DXMatrice

Curseur, &D3DXQuatCurseur );

Vous enchaînez avec la fonction D3DXMatrix-

RotationQuaternion( ) qui construit une matri-

ce pour un quaternion, en utilisant comme

argument d’entrée la structure D3DXQuatCur-

seur  utilisée précédemment. Le résultat de

cette opération est évidemment retourné

dans la matrice D3DXMatr iceCur seur, définie

plus haut.La fonction D3DXMatrixTr anspose( ) retourne

ensuite la matrice transposée de D3DXMatri-

ceCur seur. Cette opération est indispensable

pour la suite de la procédure.

D3DXMatrixTranspose( &D3DXMatriceCurseur,

&D3DXMatriceCurseur );

/*

La fonction D3DXMatrixTranspose retourne la

matrice transposée

d'une matrice :D3DXMATRIX* D3DXMatrixTranspose

(

D3DXMATRIX* pOut,

CONST D3DXMATRIX* pM

);

Paramètres

O t i t t t D3DXMATRIX

une nouvelle matrice D3DXMatriceEnvCtrlSou-

ris.

/*

La fonction D3DXMatrixMultiply retourne le

résultat de deux matricesD3DXMATRIX* D3DXMatrixMultiply

(

D3DXMATRIX* pOut,

CONST D3DXMATRIX* pM1,

CONST D3DXMATRIX* pM2

);

Paramètres

pOut : pointeur vers une structure D3DXMATRIX,

résultat

de l'opération.

pM1 : pointeur vers une structure source D3DX

MATRIX.

pM2 : pointeur vers une structure source D3DX

MATRIX.

*/D3DXMatrixMultiply( &D3DXMatriceEnvCtrlSouris,

&D3DXMatriceEnvCtrlSouris,

&D3DXMatriceCurseur );

Vous utilisez ensuite la fonction Win32 Set-

Capture( ) pour capturer la souris.

/*

La fonction SetCapture ajuste la capture de la

souris sur la fenêtre spécifiée appartenant

au thread courant.

Elle capture la souris si cette dernière est

sur la fenêtre de l'application, ou bien si le

bouton de la souris est pressé pendant que

la souris est sur la fenêtre de l'application et que

le bouton est maintenu pressé. Si le curseur de la

souris est sur une fenêtre créée par un autre thread,

le système dirigera les informations liées à la

souris vers la fenêtre de l'application, seulement

si le bouton de la souris est pressé.

HWND SetCapture

(

HWND hWnd // gestionnaire de la fenêtre

);

Paramètre

hWnd : gestionnaire vers la fenêtre de l'application

dans le thread courant pour capturer la souris.

*/SetCapture( m_hWnd );

bCaptureSouris = TRUE;

return 0;

}

Pour finir, vous traitez le comportement de

l li i i l b h d l i

D3DUtil_GetRotationFrom

Cursor( m_hWnd );

D3DXMatrixRotationQuaternion( &D3DXMatrice

Curseur, &D3DXQuatCurseur );

D3DXMatrixMultiply( &D3DXMatriceEnvCtrlSouris,

&D3DXMatriceEnvCtrlSouris,

&D3DXMatriceCurseur );// La fonction ReleaseCapture libère la la souris

d'une fenêtre

// dans le thread courant et restaure le processus

d'entrée normal

// de la souris.

ReleaseCapture( );

bCaptureSouris = FALSE;

return 0;

}

// Transmission des messages récupérés vers le

gestionnaire par défaut

return CD3DApplication::MsgProc( hwnd, messa

ge, wParam, lParam );

}

Le traitement de la rotation de la caméra est

complexe, car il fait intervenir des concepts et

des notions mathématiques évoluées. Mais, il

n’est pas nécessaire d’assimiler tous ces

concepts au niveau programmeur pour suivre

la procédure ainsi décrite. Cependant, nous

vous conseillons de bien les assimiler si vous

désirez appréhender et développer un proces-

sus similaire, nécessitant l’utilisation des qua-

ternions et la manipulation des matrices dans

un environnement tridimensionnel.  

Laurent Jayr 

[email protected]