Download - Programme z 050
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.
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
R
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
R
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
R
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é
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
R
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
R
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
R
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
R
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é
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
R
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
R
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