Programmation
en Java.
- Développement d’une interface
graphique multiplate-forme.
Programmation
en Java.
1 ère Partie: Des contraintes et des objectifs.
Pourtant, ce stage m’aura permis de conforter mon goût et mes orientations vers les réseaux et ma volonté de travailler plus tard dans ce domaine. De plus, il semble à l’heure actuelle que ce soit un secteur d’avenir qui pourrait bien devenir incontournable dans les prochaines années. Autant ne pas rater le bon wagon !
A l’occasion de ce stage, je voulais travailler hors du monde industriel pour voir un autre cadre que celui de l’entreprise. Je crois pouvoir être satisfait de ma découverte: enrichissante et particulière. Mon choix ne se voulait pas aller à l’encontre d’un système que je ne connais que peu; c’était plutôt pour moi l’occasion de saisir une opportunité qui ne se représenterait sûrement plus. En outre, ce monde de l’entreprise, je le côtoierai plus directement dès cet été, chez Motorola, ceci me permettra d’avoir une perspective plus globale sur les opportunités de tous les secteurs dans lesquels nous, les titulaires d’un DUT, nous pourrons travailler peut être dès demain.
La particularité de mon stage aura été de développer une application dans un nouveau langage: Java; le langage dont on dit qu’il a permis de donner une vie au Web et à l’Internet.
Les programmeurs de Sun Microsytems ont en effet créer ce langage sur les bases du C++, c’est donc un langage orienté objet, auquel il a été ajouté des fonctions et des possibilités totalement dédiés à une utilisation autour des nouvelles technologies « réseaux »: Multimédia, Intranet et Internet.
Ainsi, j’ai travaillé sous un environnement très nouveau mais qui devrait se développer. En effet, ce langage a la particularité d’être multi plates-formes, c’est à dire indépendant de la machine sous laquelle le code est exécuté, et semble être le futur de l’informatique à une époque où les réseaux et le travail entre différents environnements prend de plus en plus d’importance. Développé ces dernières années par Sun Microsytems, Java a été écrit dans une logique de portabilité et d’adaptabilité aux réseaux, et c’est aujourd'hui le langage qui laisse entrevoir le plus de possibilité dans le futur. Cependant, nous ne sommes qu’au début de cette époque, la version 1.1.1 puis la 1.1.2 de Java sont sortis durant mon stage.
La possibilité de travailler sur des technologies nouvelles est à la fois intéressante dans le sens où le travail que l’on fait, même à un petit niveau, porte sa pièce à l’édifice de la nouveauté et fera ou défera le succès de ces nouveaux outils, mais pourra être inutile si le projet et dans ce cas le langage, ne réussit pas à s’imposer. Ainsi, développer en Java et faire confiance à cette technologie, c’est à la fois un paris pour nous, un soutien pour Sun et ce sera un succès pour tous si la mise en commun de nos expériences et de nos compétences aboutit à un résultat probant au travers de nos réalisations en Java.
Être les premiers à travailler sur
une technologie nouvelle met en relation des gens aux travers justement
des réseaux que l’on arpente tous à la recherche d’un nouveau
moyen d’avancer toujours plus loin dans nos connaissances en partageant
ce que l’on sait et ce que l’on voudrait savoir faire. On compare nos résultats,
on échange nos points de vue, nos « croyances ».
Et même si les résultats sont toujours
partiels, on développe un réseau d’entraide et de savoir
faire qui permettra d’améliorer le langage. Ces mises à jour,
même si elles défont une partie du travail accompli, permettent
toujours d’améliorer les outils à notre disposition, d’accroître
les performances du langage.
Je ne veux en aucun cas vous convaincre que Java
sera la technologie du futur des réseaux et de l’informatique mais,
je crois sincèrement au succès de cette technologie que je
vais vous présenter au travers de ce que j’ai réalisé
pendant ce stage.
L’adaptabilité du langage, sa relative
facilité d’emploi et sa faculté de répondre à
la création de moyens de communication entre l’homme et la machine
en font un outil inégalable pour changer les modes de communication
et permettre à tous de s’exprimer dans une même langue. Je
ne suis pas le seul à le penser sinon Java serait déjà
mort, alors qu’il est en pleine expansion.
Je vous présenterai d’abord un cahier des charges de ce que je devais réaliser et la façon dont je l’ai adapté et mis en forme. Puis, suivra un historique de Java et une explication plus technique sur ces capacités et sur ses fonctionna lités et finalement j’exposerai mes réalisations.
Et croyez moi, l’avenir des réseaux et du logiciels sera Java !
Ainsi, l’objectif était de développer une application qui puisse servir d’interface graphique dans un cours de logique ou dans un autre cours. Elle doit permettre de visualiser de manière interactive et « conviviale », les données d’un enseignement, proposer à un élève de travailler seul avec une machine en complément de ce que l’enseignant lui aura donné comme connaissance.
En s’appuyant sur le développement premier du cours de logique, le but est d’obtenir un « assistant informatisé » pour l’enseignement de la logique séquentielle et combinatoire, c’est à dire un cours de logique assisté par ordinateur. Il faut donc une interface qui affiche dans différentes pages des informations concernant une notion proprement dite mais aussi pouvoir à partir de cette page, obtenir des compléments d’information, des exemples en particuliers.
On doit donc pouvoir « naviguer » dans les données, entre le cours, des exemples qui s’adaptent aux pages de cours, et pourquoi pas vers une évaluation afin que l’élève se « juge » tout seul. On a ainsi, un support et à la fois un soutien ou un approfondissement de quelque chose de déjà vu en cours. Cela peut être utile pour travailler de façon interactive, pour réviser une interrogation, pour avoir un repère sur son niveau de connaissance ou encore aller chercher des informations ou encore plus simplement pour aller plus loin dans ses connaissances. En outre, les domaines dans lesquels on navigue peuvent être variés, il suffit d’avoir les informations concernant l’enseignement désiré à disposition, le système de « navigation » restant le même.
Il faut maintenant prendre en compte la façon dont on va consulter ce cours au travers de ce « navigateur ». Cette interface doit donc être utilisable en « stand-alone », c’est à dire sur un poste unique. Dans ce cas, son fonctionnement sera comparable à celui d’un programme sur CD-Rom comme une encyclopédie multimédia où une interaction entre l’utilisateur et la machine permet d’expliquer, de tester, d’apprendre ou encore de compléter les connaissances de l’utilisateur. On peut imaginer trouver une telle application elle-même gravée sur un CD et fonctionner ainsi.
Mais, ce programme doit aussi pouvoir être utilisé en réseau
Intranet. Dans la situation d’un TD par exemple, il n’est pas alors nécessaire
d’avoir autant de CD-Rom que de postes, le programme installé sur
le réseau est suffisant. Les différents postes faisant des
accès au serveur pour récupérer les informations nécessaire
au traitement de chaque « niveau » en cours de consultation.
Toujours dans la même logique, il peut être intéressant
de voire fonctionner ce genre de logiciel directement sur l’Internet. On
peut imaginer ainsi l’étudiant chargeant une page Html dédiée
dans laquelle ou à travers de laquelle il retrouverait son programme
de logique, et dans lequel il pourrait revoir un cours, s’essayer à
un test et voir où il en est dans l’acquisition de ce même
cours. Et cela, de n’importe où puisque situé sur une page
WWW, d’où on appellerait l’application. Cette utilisation serait
assez proche de l’Intranet, à la différence près que
l’on aurait le choix de passer par un « navigateur » pour afficher
l’application dans le réseau local ou, d’appeler la même application
que pour un Intranet.
Si on a la volonté de faire un programme universel qui passe par différents média (stand-alone, Intranet, Internet), on est alors obligé de prendre en compte les différentes machines qui existent sur le marché. En effet, dans l’absolu, un programme qui tourne sous Microsoft Windows, n’est pas compatible avec Sun Solaris ou le System 7 d’Apple par exemple.
Il faudra donc pouvoir afficher: du textes, des images et il devra être
possible de récupérer des réponses à des questions,
générer des enchaînements, répondre à
des événements arrivant sur des boutons de navigation.
De plus, l’interface graphique devra présenter plusieurs modèles
de fenêtres interactives dans laquelle les textes issus du cours
s’afficheront et qui orienteront l’utilisateur pour « naviguer »
dans le programme.
Voilà les deux aspects que doit retenir le programme.
Chaque page présentera une allure quasiment identique, l’ interactivité de chacune sera différente en fonction de son rôle. Les pages qui permettront de progresser ou de reculer dans l’organisation du cours seront celles dénommées « cours ». Depuis celles-ci seront accessibles, à chaque fois, une page « exemple » qui illustrera ce qui a été présenté dans la page « cours ». L’évaluation sera disponible à partir de quelques pages « cours » seulement, pages qui marqueront la fin d’une acquisition particulière, mais elle seront aussi accessible depuis la page de présentation pour permettre d’aller directement s’essayer à un « examen blanc ». Tout ceci hiérarchisera le cours et permettra de garder une certaine rigidité garante de la cohésion du message transmis. Il ne faut pas que l’utilisateur aille n’importe où, il y a certains passages obligés.
Il faut aussi stocker les données qui seront affichés
dans ces fenêtres. Celles-ci pourront se trouver à plusieurs
endroits différents dépendant du mode de travail. Dans le
cas d’un fonctionnement « stand-alone », les ressources seront
situées en local sur la machine sur laquelle on travaille; dans
un fonctionnement réseau, il faudra aller les chercher sur un serveur
pour ensuite les ramener sur le poste de consultation.
Ces données pourraient s’organiser sous la forme d’une base
de données dans laquelle on irait uniquement lire et qui subirait
ensuite un traitement local.
On comprend facilement que pour ce qui est des « cours » et des « exemples », il ne faille que lire dans cette base de données par contre va se poser le problème des pages « évaluation ». Ces pages « évaluation » se présenteront sous la forme de Q.C.M. et donc il sera possible de récupérer des choix de réponses de l’utilisateur. La solution que je retiendrais, serait de traiter les résultats des cases cochées en local. C’est à dire que l’on chargerait en plus de l’affichage, un champ réponse sur la machine de consultation et que ce champ serait comparé avec le champ choisi par l’utilisateur. On pourrait ainsi vérifier si la réponse est juste ou non, puis comptabiliser des points en vue d’une notation. De la même façon, ce champ supplémentaire permettrait de donner un ensemble de réponse et pourquoi pas une explication de la réponse pour corriger les erreurs.
Ranger les données dans une base à plusieurs avantages. On peut accéder et charger facilement des données puisque cette base se présente à la façon d’un tableau à « double entrée ». D’un côté, les différents champs dont on aura besoin à un niveau donné de l’affichage, de l’autre le niveau de progression. Dans les champs, on peut aussi incorporer les enchaînements pour passer dans les pages suivantes, et si le système garde les précédentes en local pour revenir en arrière vers ce que l’on a déjà lu. On retrouve un fonctionnement style « navigateur » Internet, mais adapté à un usage particuliers.
Une base de données comme cela permet de stocker dans les différents champs toutes les sortes d’informations y compris le cas échéant des images. Il est facile de changer les données qu’elle contient et donc de mettre à jour, de compléter les informations si on vient à faire autre chose du programme, on dispose ainsi d’une application modulable à l’infini. Seul le contenu de la base de données oriente ce que l’on en fait. Le seul prérequis pour transformer le logiciel est de connaître tous les champs et le rôle de chacun, afin de bien replacer les données.
Cette base de données peut après, être situé n’importe où en fonction de l’utilisation et de ce qu’elle contient, elle n’est accédé qu’à l’instant des transitions entre pages. A ce moment, les champs sont affectés en local et tant que l’utilisateur travaille sur la page, il n’est plus fait appel à celle-ci. Ceci permet de ne pas surcharger les lignes de communication dans le cas d’un réseau et de ne faire passer sur ces mêmes lignes qu’un minimum d’informations puisque une grosse partie du traitement est fait en local. On optimise aussi la communication en traitant la transition d’un niveau de page en bloc, puisque la communication entre le programme et la base est disponible à ce moment là.
A partir de ce cahier des charges, l’idée avait été de développer cela en Java, nous allons donc maintenant passer à une description de Java, puis nous reviendrons sur les raisons de ce choix de Java.
Dans ce contexte, ils se devaient pour réussir d’être adaptable à tous les systèmes afin de ne plus imposer une nouveauté axée sur le matériel mais bien de créer un système qui soit « pluriel », comme on dit aujourd’hui. Il fallait que ce soit les systèmes logiciels qui adaptent les applications (ce que l’on va appeler la « machine virtuelle Java ») pour que tous le monde informatique « non-PC », puisse adhérer au projet et de plus pour ne pas se trouver directement en concurrence sur le marché de prédilection de Microsoft et bien créer ainsi une alternative et ne plus faire comme la tendance le voulait du PC un passage obligé. Avec une démarche commerciale performante et nouvelle, les gens de Sun ont su trouvé leur place et mettre au point un outil intéressant en faisant leurs alliés des circonstances et des marchés. Seulement, le projet seul n’est pas suffisant, Apple avec le MacIntosh est bien placé pour le savoir. Il était nécessaire que des éditeurs les suivent dans leurs choix.
L’importance du projet, ses perspectives de développement et
ses possibilités l’ont imposé à tous. Ainsi, Netscape,
le premier puis Oracle, Borland, IBM, Adobe, Symantec, Novell et même
Microsoft (??!!, business will always be business !), ont signé
des partenariats afin d’obtenir des licences d’utilisation et d’intégration
de la technologie Java dans leurs machines et logiciels. Sun Microsystems
avait assuré le développement de Java. Entre Mai 1995 et
Mars 1996, ils avaient réussis à persuader le monde de l’informatique
de la nécessité et de l’importance de leur projet. Ils s’étaient
associés avec les plus grands éditeurs mondiaux et avaient
créé un avenir à cette nouvelle technologie.
Le groupe avait un objectif assez ambitieux, il s’agissait de mettre au point un langage qui s’appliquerait de la même façon à tous les dispositifs de commande électronique actuels et futurs ! Le projet portait le nom de Oak, « Chêne » en anglais. La finalité était d’éliminer la compilation spécifique à chaque système que réclame tous autres langages. C’est à dire de supprimer cette étape de l’utilisation d’un programme qui consiste à transformer un code informatique en langage « évolué » à un langage « machine » propre à chaque système.
Au bout d’un certain temps, le projet changea de nom et d’orientation.
Compte tenu de l’évolution fulgurante des techniques de communication
de ces dernières années, on compléta les spécifications
du langage. Il se plaça, alors dans un cadre beaucoup plus large.
Le projet entamait un nouvelle vie sous le nom de Java. En argot américain,
« Java », c’est la pause café, celle que s’accordèrent
les chercheurs ne parvenant pas à trouver un nom convenant
au projet.
Le concept Java était lancé et pouvait encore être
étendu. Un mot nouveau apparut VOD (Video On Demand), et les développeurs
y virent très vite un autre domaine de débouchés pour
Java. La VOD apparaissait comme une innovation majeure pour les temps à
venir et Sun s’employa à faire percer les développements
dans ce domaine.
L’idée de base était claire et novatrice: Java devait
rendre possible l’interaction avec les services de vidéo sur demande.
Les programmes pouvaient être transmis sans problème au travers
du réseau câblé de télévision. On remarquait
ainsi que la diversité des plates-formes en service ne posaient
pas de problème à Java. Mais ce fut un « flop ».
La structure du réseau jouait un rôle de premier plan. En effet, Internet se résume finalement à la mise en relation d’un grand nombre de réseaux décentralisés dont les voies permettent l’échange global d’informations. La notion de village planétaire était née, avec, pour la première fois, la vision d’un système de communication mondial. L’éloignement géographique n’était plus une barrière pour les communications. Se lancer dans une conversation avec un partenaire à l’autre bout de la terre n’était pas plus compliqué que de transférer un fichier vers une autre ville.
Mais les capacités techniques d’Internet furent rapidement dépassées
en raison de son acceptation croissante comme moyen universel de communication.
Le réseau manqua de s’effondrait sous les intérêts
économiques. Les taux de transfert médiocres et l’affichage
de graphisme mettaient les nerfs à rude épreuve et la volonté
de rendre malgré tout dynamique l’Internet demandait de nouvelles
solutions. De plus l’interaction avec l’utilisateur était quasiment
impossible.
Java affichait déjà des qualités capable de combler
les lacunes du réseaux. Ainsi ces qualités pouvaient sûrement
servir à développer des applications dédiées
pour le réseau.
Le succès est considérable. Les éditeurs signent des licences avec Sun et en particuliers Netscape. Celui-ci intègre dans la version 3 de son célèbre navigateur Internet (Browser en anglais), Navigator les attributs (« plug-in ») Java qui rendent compatible la visualisation d’applications au travers des pages Internet. Peu à peu, on appelle ces programmes intégrés au code de description (code en langage Html) des pages WWW (World Wide Web, toile d’araignée mondiale) des applets. Ce sont des programmes qui se lancent sur les machines de visualisation.
Le mécanisme est simple, la source code Html et Java est
chargé sur le serveur. A partir du browser et du plug-in Java, le
code est interprété sur le client sans qu’il soit nécessaire
au serveur d’intervenir sauf si une nouvelle requête est faite. Ainsi,
quelque soit la machine, le même code source est chargé pour
tous les clients quelque soit leur nature, c’est après l’interpréteur,
dans ce cas le browser qui se charge de transformer ce code source en un
résultat alliant tous les moyens de communication moderne: textes,
images, animations, sons...
La position dominante sur le marché de Netscape à cette
période permet très rapidement de convaincre les autres éditeurs,
la voie du succès est tracée pour Java.
On comprend alors aisément comment Java permet de se libérer
des différentes plates-formes. A l’heure actuelle, une nouvelle
solution est envisagée pour rendre les machines compatible Java
à un niveau inférieur et ne plus avoir recours à un
interpréteur. En effet, Sun ferait des recherches qui consisterait
à faire contenir la « machine virtuelle Java », non
plus dans un fonctionnement logiciel mais directement dans la couche matérielle
à travers une puce qui pourrait être intégrée
dans les ordinateurs de tous « formats ». Avec cette solution,
l’interpréteur Java serait intégré au hard et les
possibilités offertes par la technologie Java seraient encore accrues.
Ainsi, un nouveau projet se développe chez les grands éditeurs:
les Network Computers (NC).
Plusieurs avantages à ce système: moins de maintenance lourde des réseaux, moins d’incidents sur le réseaux, moins de dépenses matérielles. Les machines connectées ne sont plus que des serveurs simples sans unité de stockage. Ainsi, les utilisateurs ne se servent que de ce dont ils ont besoin. L’utilisation du réseau est optimisée: ne circule que ce que les administrateurs auront décidé ! Dans ce contexte Java trouve tout à fait sa place. Si le processeur intégré au NC est compatible Java, plus besoin d’autres systèmes d’exploitation sur la machine fini les multiples licences. On se contente de licences réseaux qui permettent à tous d’utiliser un logiciel sur la machine virtuelle Java et de ne pas prendre les ressources du serveur. Il charge sur le NC les programmes utiles, le NC est autonome jusqu’à la fin de la session, puis le serveur récupère le travail de la session. La fin du règne du Personnal Computer dans les entreprises, le début d’une politique informatique hiérarchisée et optimisée.
Voilà, l’un des grand enjeux de Java dans les années qui
viennent. Ce qui manque pour l’instant, ce sont des applications qui tourneront
sur ces NC, mais déjà Netscape et Corel ont fait des efforts
puisque le premier vient de sortir la version 4 de son célèbre
Navigator rebaptisée Communicator, celui-ci devenant un objet de
communication multimédia: du classique e-mail à la visioconférence
en passant par de nouveaux serveurs News et le tout travaillant avec un
minimum de ressources matérielles. Et Corel de son côté
développe une version Java de la suite de logiciels Bureautiques
WordPerfect dont la version Bêta laisse présager de grands
espoirs malgré une lenteur digne des vieilles générations
P.C. Mais n’est t-on pas au début d’une nouvelle génération
de machine, laissons leur le temps d’optimiser leurs produits.
Description d’une Classe.
Description d’un Objet.
Les inventeurs du langage ont voulu supprimer tout ce qui s’avérerait inutile. Les expériences tirées d’autres langages, notamment de C++, ont montré la voie à suivre. C’est ainsi qu’ont été abandonnés les pointeurs, il est donc impossible de provoquer un incident maintenant en Java en manipulant directement la mémoire, et ils ont aussi abandonné la notion de polymorphisme, c’est à dire l’héritage multiple des classes. On a en effet la possibilité en C++ de donner à une classe les caractéristiques de plusieurs classes « mère », en Java il n’y a qu’une et une seule classe « mère ». Pour montrer comment on représente l’héritage d’une classe par rapport à une autres on peut regarder le schéma:
AnotherClass hérite de Aclass.
Ainsi, on visualise d’une façon graphique les caractéristiques
d’un langage orienté objet. Mais Java a bien d’autres caractéristiques.
Par exemple, l’adressage mémoire direct des données, tel
qu’il est souvent pratiqué en C et C++, n’est pas possible non plus.
L’arithmétique des pointeurs ne fait pas partie de la syntaxe Java.
Différents mécanismes de sécurité sont employés
pour éviter les accès mémoire abusifs et se protéger
des plantages des applications et des systèmes d’exploitation. De
plus, Java renonce aux fonctions d’un préprocesseur, aux structures
et aux unions. La surcharge des opérateurs est également
interdite.
Tout ceci peut laisser penser que la puissance de Java est relativement
limitée par rapport à des langages comme C++ ou Pascal. Mais
tel n’est pas le cas. L’équipe de développement de Sun a
juste supprimé les éléments mal compris ou mal exploités
des autres langages.
Bien que des éléments d’autres langage aient été abandonné, Java reste un langage très strict dans sa syntaxe. Il traite avec une grande sévérité les variables, la conversion automatique de type par exemple n’est pas autorisée. En outre, si le code source présente une affectation ou une initialisation erronée, le compilateur détecte l’erreur, évitant ainsi la construction de programmes défectueux à ce stade précoce du développement.
Java organise tout seul la mémoire. Quand un objet est créé, il nécessite un espace mémoire réservé, cela, Java s’en occupe tout seul mais ici, l’utilisateur n’a plus à gérer la libération des ressources. Le système s’en charge au travers d’un processus de récupération automatique de la mémoire: le « garbage collection » qui est l’une des fonctions du système d’exécution du langage, cela restitue automatiquement les zones mémoires qui ne sont plus utilisées. On gère de cette façon toujours la mémoire de façon optimale, et l’exploitation des ressources ne plus sur leurs limites.
Java est un langage sécurisé. Au cours de son développement les programmeurs ont accordé une importance particulière à la sûreté, et les structures de sécurité font partie intégrante du système d’exécution et du compilateur. La solution adoptée pour traiter les erreurs est ici originale. Le programmeur écrit une série de routines de traitement d’erreur et lorsque un événement imprévu se produit, c’est le langage qui détermine automatiquement la routine la plus appropriée pour traiter cette erreur imprévue. Les routines sont ainsi classées de façon séquentielle et parcourues de bas en haut le cas échéant. Quand la méthode qui convient a été trouvée, elle est exécutée et Java essaye de poursuivre le déroulement du programme. Bien sûr, la sécurité n’est pas absolue et il peut se produire des erreurs perturbant la poursuite du déroulement d’un programme. Cependant, à aucun moment le système d’exploitation n’est menacé.
Java, malgré sa conception qui interprète un pseudo-code est rapide, et présente des applications de taille raisonnable. En effet, les bibliothèques de classes requises par un projet ne sont liées qu’à l’exécution, la taille des applets par exemples est ainsi tout à fait réduite. L’exécution du pseudo-code proche du langage machine assure de plus une exécution rapide bien qu’elle soit encore environ 20 fois plus lente que la même application écrite en C++. Mais des accélérateurs sont en cours de développement, en particuliers par Microsoft et Borland. L’objectif est d’atteindre la vitesse du C.
Autre qualité matérielle de Java, il fonctionne sur des systèmes ne nécessitant pas de puissance matérielle excessive: il est économe en ressources. Il n’a pas été conçu pour les ordinateurs personnels au départ d’où un interpréteur qui se montre très économe seuls quelques centaines de kilo octets sont nécessaires. De fait, Java travaille sans problème sur une plate-forme équipée de 4 Mo de mémoire de travail, cela est toutefois à relativiser face aux exigences des systèmes d’exploitation mis en oeuvre.
Sur le plan de la programmation, Java est un système qui permet
de fonctionner en multitâche. C’est à dire qu’il autorise
l’exécution simultanée de plusieurs processus en parallèle.
Ce qui matériellement n’est pas possible compte tenu de l’architecture
monoprocesseur de la plupart des machines. Mais l’industrie informatique
a mis au point le concept de multitâche préemptif. Dans ce
cas, les opérations ne sont pas effectuées en parallèle
mais le temps de travail du processeur est découpé en intervalles.
Plusieurs opérations peuvent alors se partager les ressources de
calcul d’un processeur unique.
Pour permettre la description des algorithmes appropriés, Java
met à la disposition du programmeur la syntaxe des threads. Un thread
est une unité d’exécution isolée. Il est en théorie
possible de définir un nombre illimité de thread. Pendant
l’exécution du programme, les threads accèdent au processeur
par un mécanisme d’interruption. En fonction de la puissance du
processeur, on peut simuler du multitâche jusqu’à un certain
degré.
Java est encore un langage ouvert. Ceci permet à partir de la technologie « mixed languages », d’écrire des modules différents d’un programme en différents langages. On tire ainsi le meilleur de chaque langage. Java accepte sans problème des modules étrangers, cependant cela repose la question de la neutralité de la plate-forme et pose quelques problèmes de sécurité.
Java et Internet...
ARPAnet est resté homogène pendant quelques années, puis il s’est ouvert à d’autres réseaux, c’était la naissance de l’Internet. Ouvert prioritairement aux universités et aux centres de recherche, la structure du réseau a alors subit des modifications radicales. Pour permettre la communication se met alors en place un protocole commun HTTP (Hyper Text Transfert Protocol), il est toujours en vigueur aujourd’hui.
En 1993, Internet connaît un essor énorme. Le grand public s’intéresse à cet outil pour chercheurs ou tout fait en mode texte, pour l’instant. Les chercheurs du CERN en Suisse, travaillent sur un nouveau langage pour l’Internet afin de publier leurs résultats. C’est à partir de leur technologie, le langage HTML (Hyper Text Makeup Language), que l’on trouve le fondement de la base actuelle de l’Internet le World Wide Web, c’est à dire la partie graphique et maintenant multimédia de l’Internet, celle qui est ouverte au grand public. La norme HTML toujours en vigueur permet de crypter des mises en pages à l’aide d’un simple fichier ASCII. On peut en outre y intégrer des images, du sons et même des séquences vidéo. On peut aussi y inclure des liens vers d’autres sites du WWW ce qui a donné naissance à l’expression « surfer sur le Web », puisque l’on passe d’un site à l’autre par un simple clique de souris.
Maintenant, l’Internet est devenu un lieu d’échange, grâce en particuliers à la baisse du coût du matériel, et les entreprises y voient maintenant un enjeu économique. Java y joue un rôle important. En effet, son indépendance vis à vis des plates-formes lui permet d’être lu partout sur le réseau, et en intégrant un appel dans le code Html, le browser disposant du « plug-in » Java va interpréter les donnés de l’applet comme une image ou une séquence vidéo classique et cela dans une zone de l’écran que l’on aura défini. Ainsi, on obtient une véritable façon d’interagir entre le client et le serveur puisque une applet va fonctionner comme un programme en étant toutefois enfermée dans une page Html. De plus, des applets Java n’encombre pas les réseaux puisque elles sont chargées en même temps que le code Html et sont interprétées en local ensuite par la « machine virtuelle Java », d’où un gain en rapidité sur le réseau où ne circule que du texte.
Toutefois, aujourd’hui on ne peux limiter le domaine d’application de Java, Internet, WWW, les futurs NC, où on louerait ou tout au moins chargerait un traitement de texte par exemple juste pour taper ce dont on a besoin. Java est ainsi, la plus récente, la plus vivante et la plus intéressante pour rendre le réseau encore plus vivant.
Dans notre cas, Java permet de développer de façon assez
« intuitive » une interface graphique, il dispose même
d’outil dédié à ce type d’utilisation, en particuliers
la classe AWT (Abstract Windows Toolkit) qui contient par défaut
des outils pour construire des fenêtres et les utiliser. Réciproquement
par ce genre d’applications, on peut tirer le meilleur de Java. Ainsi,
en l’utilisant, on se donne un outil performant qui a été
défini pour réaliser des travaux de cet ordre. D’où
la « parfaite » adéquation entre le projet, son cahier
des charges et ce que le langage va permettre de réaliser.
Dans cette partie, on doit en outre gérer la taille de la fenêtre et son comportement dans un environnement graphique type Windows ou X-Windows. De plus, l’utilisation de Java permet de régler le problème de la compatibilité avec les différentes plates-formes matérielles puisque l’essence même de Java est d’être compatible avec toutes les plates-formes informatiques à la seule condition que cette plate-forme dispose de la « machine virtuelle Java ».
On peut de plus transporter un programme écrit en Java sur n’importe
quel système qu’il soit local ou réseaux, on simplifie la
mise en place de différentes versions, car la version applicative
sera identique aux versions réseaux. En effet, un programme Java
et une applet Java ne se distinguent que par quelques différences
syntaxiques au niveau des classes principales du programme. Mais il est
toutefois possible de ce défaire de cette contrainte en lançant
un programme comme étant une applet (le contraire n’est pas possible)
au travers d’une page Html. Ainsi, lorsque l’on aura une version «
stand-alone », il ne restera à adapter pour les versions réseaux
que la localisation de la base de données.
C’est cet élément qui m’a fait opter pour un choix de solution à partir d’une base de données. En effet, JDBC est une interface logicielle intégrée au JDK qui permet d’interfacer et d’accéder depuis un programme Java à n’importe quelle base de données. Et bien que cette technologie soit toute nouvelle (la documentation officielle de JDBC, réalisé par Sun ne sortira finalement que début Juillet), elle semble particulièrement intéressante à utiliser. Elle est capable de connecter n’importe quel protocole à Java en particuliers celui développé par Microsoft ces dernières années pour Windows: ODBC (Object DataBase Connectivity). Ainsi, par cet outil on se libère encore un peu plus de la plate-forme que l’on utilise puisque même la connexion avec la base de données est géré de façon transparente aux programmeurs qui n’a qu’a déterminé le type de transmission dont il a besoin, un serveur avec un nom de login et un password pour ouvrir une session sur la base de données.
Il n’est plus question pour le programmeur de savoir comment il va accéder à la base de données, il lui suffit de demander à son programme de faire un appel et d’affecter les champs qui viennent de la source d’information. Dès lors, le traitement se fait en local à partir des champs qui sont des objets classiques d’un langage orienté objet et auxquels une des caractéristiques correspond à ce que le programme a ramené de la base de données. on remarque encore un outil de Java qui correspond tout à fait à ce que l’on veut réaliser et qui permet de « simplifier » la programmation ou tout au moins qui contribue à alléger et orienter de façon plus « utilisateur » le code que l’on conçoit.
En effet, je crois bien que la particularité de Java quand on commence à écrire du code est que très vite, on se retrouve dans la position de l’utilisateur et que même quand on crée un objet ou une variable, c’est toujours avec cette optique de rendre le programme interactif quand il sera terminé.
Ainsi, on a une première idée de la forme que j’ai voulu donner à l’application passons maintenant à l’analyse du travail de programmation réaliser pour construire cette application avec les outils Java.
Le JDK, c’est l’outil essentiel de toute personne qui travaille sur Java: le Java Developer’s Kit. Ce « kit » regroupe tous les outils qui permettent de construire applications et applets Java. On y trouve un compilateur: Javac, un interpréteur d’application « le noyau de la machine virtuelle Java »: java, un interpréteur d’applets: AppletViewer, un debogeur: jdb, un décompilateur: javap, un générateur de documentation: javadoc, et un outils d’interfaçage avec le langage C: javah. On y trouve aussi toute une liste d’aide et l’ensemble des composants intégrés au langage comme les classes de bases. Cet élément chargeable en particuliers par FTP sur le site de Sun est l’outil le plus facile à utiliser pour mettre en oeuvres des programmes Java. Il existe bien encore quelques programmes de développement « visuel » comme Visual J++ de Microsoft et Café, Visual Café de Symantec mais face à la gratuité du JDK, ce sont des outils moins utilisés surtout que quasiment tous les mois sort une mise à jour du JDK et que celles ci ne sont pas toujours répercutées par les autres éditeurs.
Cette perpétuelle évolution du langage présente à la fois des avantages mais aussi plusieurs inconvénients sur les travaux que l’on réalise. L’avantage de cette évolution, c’est que le langage ne semble pas être limité par une quelconque barrière car celle-ci ne peut être que temporaire et trouver une solution avec la version suivante du Kit, l’exemple parfait dans le cas de mon application est l’arrivée de JDBC.
D’un autre côté, la perpétuelle mouvance du langage et ses perpétuelles modifications engendrent dans quelques cas des passages brutaux vers de nouveaux modes de programmation. Lors du passage de la version 1.0.2, la version classique depuis environ six mois à la version 1.1.1 définitive (seuls des versions Bêta avaient occupé alors le marché...), la classe Abstract Windows Toolkit a été entièrement revue par Sun pour être rendu plus performante. Première conséquence de ce changement une incompatibilité de compilation entre le code 1.0 et le compilateur 1.1, d’où une transformation obligatoire de toutes les déclarations et scrutations d’événements en particuliers.
Ainsi, bien que cette nouveauté du JDK soit dans l’absolue une
bonne chose, ce fut pour moi toute une partie du travail à recommencer,
car il n’existait pas de transformation automatique. C’était en
effet impossible de part la complexité de l’ancienne construction
de l’occurrence des événements, puisque cela ce faisait autour
d’une construction « If / Else ». Ainsi, avec un nouveau langage,
on est toujours pris entre le manque de documentation qui oblige à
beaucoup chercher pour réussir à faire fonctionner un minimum
d’outils mais d’un autre côté, on a une chance incroyable
de tester, de s’essayer dans un domaine où encore personne n’est
passé. Il est suivant cette démarche sorti, le 7 juin la
version 1.1.2 qui corrige des bugs de Java cependant, nulle part quand
on charge la nouvelle version, on n’explique les changements, d’où
une seule alternative: l’installer et réessayer tous ces programmes
pour vérifier leur fonctionnement...
On obtient ainsi un code Java comme suit:
import java.applet.*;
import java.awt.*;
public class fenetre extends Frame
{
public fenetre()
{
}
public boolean handleEvent(Event evt)
{
if (evt.id == Event.WINDOW_DESTROY)
{
System.exit(0);
return(true);
}
return super.handleEvent(evt);
}
public void paint (Graphics fond)
{
int i, j;
int i1=2000;
int i2=2000;
i = i1;
j = i2;
fond.setColor(new Color(50,250,220));
fond.fillRect(0,0,i,j);
}
public static void main(String args[])
{
fenetre Test = new fenetre();
Test.setTitle("Graphic Interface");
Test.resize(800,600);
Test.show();
}
}
Cette application va donner une fois compilée et exécutée un affichage comme suit, c’est notre première application qui pose la base de ce que doit être notre application finale:
A partir ce cette fenêtre, il faut maintenant utiliser les outils Java de la classe AWT pour pouvoir rajouter un certain nombre de boutons et créer une fenêtre de première interface.
Il semble que ce soit très facile de construire ainsi, une fenêtre et ensuite de développer ce qui va se passer dedans. Seulement le problème par rapport à un autre système reste que la fenêtre est l’élément principal de l’application et que tous les objets qui existeront après seront intégrés à la fenêtre et donc existeront dans des classes qui seront liées avec la classe de construction de la fenêtre.
Comme nous l’avons dit, Java est un langage assez strict et protégé.
Quand on développe comme ça pour la première fois
dans un langage orienté objet, il est difficile de mettre en place
exactement et de façon opérationnelle les classes et les
objets qui constitueront l’application. Si j’avais déjà programmé
en Java autour d’applets, mais surtout en modification de petits programmes
pour des pages Web: animer un petit personnage, faire tourner un logo,
des choses simples. Ici, le problème est plus complexe mais une
fois le concept de langage orienté objet, il est aussi plus simple
à gérer sur de nombreux points.
La difficulté qui persiste et à laquelle on se fait rapidement
toutefois, c’est l’interdiction de l’héritage multiple. En effet,
il semble souvent intéressant de créer des classes héritées
de plusieurs autres, et dans ce cas la limitation de Java permet de ne
pas s’emporter dans des choses difficiles à gérer.
Ce genre de limitation, de garde fou, permettent de se préserver des programmes trop surchargés et illisibles avec un peu de connaissance en Java. La simplicité que l’on doit mettre lors du développement fait aussi que l’on progresse vite car le fonctionnement général est ensuite très cohérent. Un des auteurs du mémoire « Deux cafés, l’addition » affirme même qu’une personne connaissant C++ en a pour moins d’une semaine pour s’adapter à Java et savoir programmer dans ce langage. Pour moi, il aura fallu un peu plus de temps mais c’était mon premier langage orienté objet.
Un problème que l’on rencontre encore dans les débuts avec Java, c’est le manque d’expérience autour du langage. On a beau avoir beaucoup de livres sur le sujet, tous répètent infatigablement la même chose, c’est à dire ce que Sun a sorti comme documentation et il est très difficile de trouver un exemple d’applets ou d’applications qui soit en rapport avec ce que l’on souhaite réaliser. Il reste comme solution de parcourir les pages personnelles de diverses personnes et d’y rechercher des applets pour trouver des exemples d’utilisation originaux.
Par contre si vous cherchez à faire un « hello world »,
là, pas de problème, vous le trouverez en version texte,
graphique, avec des images, avec du sons, en couleur ou non et avec tout
un ensemble de choses toutes plus drôle les unes que les autres.
Et oui, la priorité est de faire des choses simples et dire bonjour
au monde, c’est en effet assez simple, enfin il me semble ...!
D’où le code:
import java.applet.*;
import java.awt.*;
public class Boule extends Frame
{
private int ballX;
private int ballY;
private int maxX;
private int maxY;
private int ballDiameter = 50;
private int incrementX = 1;
private int incrementY = 1;
private Button cb_exit;
private Button nord_exit;
private Button b_back;
private Button b_forward;
private Button b_pause;
private Label lb_status;
private Label label_fen;
public static void main (String args[])
{
Boule bb = new Boule();
bb.setTitle("Java appli : la balle bondissante");
bb.resize(600, 400);
bb.show();
bb.start();
}
public void paint (Graphics fond)
{
int i, j;
int i1=2000;
int i2=2000;
i = i1;
j = i2;
fond.setColor(new Color(0,255,0));
fond.fillRect(0,0,i,j);
}
public Boule()
{
ballX = (ballDiameter / 2) + 123;
ballY = (ballDiameter / 2) + 1;
maxX = 600 - ballDiameter;
maxY = 350 - ballDiameter;
Panel mySouthPanel = new Panel();
mySouthPanel.setBackground(Color.lightGray);
mySouthPanel.setLayout(new GridLayout(1, 2));
mySouthPanel.add(lb_status = new Label(""));
mySouthPanel.add(b_back = new Button("Précédent"));
mySouthPanel.add(b_forward = new Button("Suivant"));
mySouthPanel.add(cb_exit = new Button("Quitter"));
add("South", mySouthPanel);
Panel myNordPanel = new Panel();
myNordPanel.setBackground(Color.lightGray);
myNordPanel.add(label_fen = new Label ("INTERFACE
GRAPHIQUE JAVA"));
myNordPanel.add(b_pause = new Button("Rien pour
l'instant"));
myNordPanel.add(nord_exit = new Button("Sortir"));
add("North", myNordPanel);
}
public void start()
{
Graphics g = getGraphics();
while (true)
{ g.setColor(Color.blue);
g.fillOval(ballX, ballY, ballDiameter,
ballDiameter);
ballX += incrementX;
if (ballX > maxX || ballX < 1)
{
incrementX *= -1;
ballX += (2 * incrementX);
}
ballY += incrementY;
if (ballY > maxY || ballY < 1)
{
incrementY *= -1;
ballY += (2 * incrementY);
}
showStatus("Balle à (" + String.valueOf(ballX)
+ "." + String.valueOf(ballY) + ")");
g.setColor(Color.red);
g.drawOval(ballX, ballY, ballDiameter,
ballDiameter);
try {Thread.sleep(10);}
catch (InterruptedException e) {}
}
}
public void showStatus(String s)
{ lb_status.setText(s);
}
public boolean handleEvent (Event event)
{ // A-t-on cliqué sur "Quitter" ?
if (event.target == cb_exit)
{
dispose();
java.lang.System.exit(0);
}
else
{
if (event.id == Event.WINDOW_DESTROY)
{
System.exit(0);
return(true);
}
else
{
if (event.target == b_back)
{
}
else
{
if (event.target == b_forward)
{
}
else
{
if (event.target == nord_exit)
{
dispose();
java.lang.System.exit(0);
}
else
{
if (event.target == b_pause)
{
}
else
{
return super.handleEvent(event);
}
}
}
}
}
}
return true;
}
}
Voilà comment on peut réaliser un application fenêtrée dans laquelle on voit une balle se déplacer, application redimentionnable en taille comme une fenêtre Windows (par exemple) classique. Dans cette fenêtre, on voit deux barres de menus et un certain nombre de boutons (dont tous ne sont pas attribuer pour l’instant) qui vont permettre d’agir sur la future application. On peut visualiser cela de la façon suivante:
Dans la barre principale, on va mettre le titre de la page que l’on visionne, ce doit être un champ issu de la base de données, comme on a affiché « Interface Graphique java » dans l’exemple ci dessus. Ensuite, on trouvera les boutons « précédent » et « suivant » comme ils sont déjà affichés mais ils seront placés dans l’autre barre de menu. Le bouton « quitter » sera lui aussi dans la barre du haut. Le bouton « suivant » pourra être activé uniquement pour revenir sur un niveau de progression plus avancé quand on aura préalablement cliqué sur « précédent ». On affichera enfin un état de progression dans un cours indiquant le nombre de pages parcourues sur le nombres de pages à parcourir dans ce cours.
Dans la barre secondaire, on placera des boutons contextuels comme un
bouton « exemple », un bouton « évaluation »
pour les fenêtres de cours notées n/n, et divers boutons qui
commanderont un champs qui aura été chargé depuis
la base de données.
import java.awt.*;
import java.applet.Applet;
class CardPanel extends Panel {
Panel create(LayoutManager layout) {
Panel p = new Panel();
p.setLayout(layout);
p.add("North", new Button("quit"));
p.add("West", new Button("back"));
p.add("South", new Button("forward"));
p.add("East", new Button("pause"));
p.add("Center", new Button("stop"));
return p;
}
CardPanel() {
setLayout(new CardLayout());
add("quit", create(new FlowLayout()));
add("pause", create(new BorderLayout()));
add("forward", create(new GridLayout(2, 2)));
add("stop", create(new BorderLayout(10, 10)));
add("back", create(new FlowLayout(FlowLayout.LEFT, 10, 10)));
add("Surprise", create(new GridLayout(2, 2, 10, 10)));
}
public Dimension preferredSize() {
return new Dimension(200, 100);
}
}
public class CardTito extends Applet {
CardPanel cards;
public CardTito() {
setLayout(new BorderLayout());
add("Center", cards = new CardPanel());
Panel p = new Panel();
p.setLayout(new FlowLayout());
add("South", p);
p.add(new Button("first"));
p.add(new Button("next"));
p.add(new Button("previous"));
p.add(new Button("last"));
Choice c = new Choice();
c.addItem("one");
c.addItem("two");
c.addItem("three");
c.addItem("four");
c.addItem("five");
p.add(c);
}
public boolean action(Event evt, Object arg) {
if (evt.target instanceof Choice) {
((CardLayout)cards.getLayout()).show(cards,(String)arg);
} else {
if ("first".equals(arg)) {
((CardLayout)cards.getLayout()).first(cards);
} else if ("next".equals(arg)) {
((CardLayout)cards.getLayout()).next(cards);
} else if ("previous".equals(arg)) {
((CardLayout)cards.getLayout()).previous(cards);
} else if ("last".equals(arg)) {
((CardLayout)cards.getLayout()).last(cards);
} else {
((CardLayout)cards.getLayout()).show(cards,(String)arg);
}
}
return true;
}
public static void main(String args[]) {
Frame f = new Frame("CardTest");
CardTito cardTito = new CardTito();
cardTito.init();
cardTito.start();
f.add("Center", cardTito);
f.resize(300, 300);
f.show();
}
}
Après ce code, regardons maintenant ce que cela donne à partir des 2 captures d’écrans suivantes qui montre des exemples parmi les 6 mises en page possible dans l’applet:
On a maintenant tous les éléments pour construire notre
application, il reste à tout mettre en commun et à intégrer
les composants du JDK 1.1.2. Car pour la programmation, c’est à
ce stade de ma progression que j’ai rencontré une « incompatibilité
» ascendante entre les versions du JDK et avec les nouveautés
de cette version qui bien que plus « efficace » pour nombre
de travaux m’a pas mal dérouté.
J’ai donc du recommencé à chercher de la documentation, et cette fois uniquement en ligne, mais cette documentation était souvent orienté sur les versions Bêta de 1.1 d’où des choses incomplètes et variés entre deux exemples. Bien que la gestion des événements nouvelle ne soit pas compliquée, elle a une philosophie tout à fait différente de celle de la version précédente. Pour illustration, voilà une applet qui affiche un bouton qui produit un « beep » quand on clique dessus:
import java.applet.Applet;
import java.awt.Button;
import java.awt.Toolkit;
import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
public class Beeper extends Applet
implements ActionListener {
Button button;
public void init() {
setLayout(new BorderLayout());
button = new Button("Click
Me");
add("Center", button);
button.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
Toolkit.getDefaultToolkit().beep();
}
}
Maintenant, on ne gère donc plus les événements comme dans une classe particulière mais cette gestion est plus complète, deux packages intégrés au JDK permettent de faire beaucoup de choses autonomes. Ce sont les packages ActionListener et ActionEvent, ils sont capables « d’écouter » le programme et ce qu’il se passe à l’écran et sur tout les périphériques pour provoquer des enchaînements si un événement particulier se produit.
Avec ces outils, la gestion des événements est plus simple et elle contient surtout toutes les méthodes traditionnelles d’interaction avec une machine intégrée. On peut scruter les mouvements de la souris, le clavier, un micro, et une multitude d’autres périphériques de façon plus ou moins évidente. On remarque que l’amélioration est importante, les programmeurs de Sun ont fait un effort pour rendre plus explicite encore la gestion des événements, cependant il est difficile de reprendre en quelques jours ce qu’on fait depuis des semaines...
Le langage s’étoffe de cette évolution et mon travail
lui change d’optique parce que ce n’est pas la seule nouveauté de
cette version, il y a aussi la fameuse plate-forme JDBC.
Elle est donc arrivé en même temps que le nouveau JDK, prenant tous les développeurs de cours, elle n’était pas encore attendue, un peu comme d’autres éléments de cette version en particuliers le Java Beans qui lui aussi permet de nouvelles fonctions d’interface et d’intéractivité. On voit la philosophie de Java aller toujours plus vers son but: remplacer tous les systèmes de commande et de programmation par un système unique, universel et plutôt « intuitif », car c’est bien vers cette « intuition » dans le développement et dans l’utilisation des applications Java que tant le langage.
C’est à partir des premières informations qui sont sorties sur le JDBC que j’ai opté pour une solution autour d’une base de données pour importer le contenu du cours de logique dans mon application Java. En effet, c’était un problème auquel je n’avais pas encore trouvé de solution jusqu’à ce que je lises un descriptif de JDBC et de ces possibilités. L’outil étant original, il me semblait intéressant de tenter de l’utiliser pour rendre l’application la plus évolutive possible. Dans mon idée, plus les outils que j’utilisais serait récent, plus il collerait à l’évolution de la technologie Java. Je crois qu’il faut suivre de très près ses mutations pour ne pas créer dès le départ des applications rapidement obsolètes. Un vieux programme Java marche avec l’interpréteur de la nouvelle version par contre il est impossible de le recompiler sans passer par des options qui expliquent que les anciennes « écritures » ne fonctionnent plus.
Malgré toute les promesses de Sun, la documentation officielle de JDBC, prévu au Printemps 97, n’est toujours pas disponible. Il n’existe pour l’instant que des documentations partielles totalement en anglais (comme toutes les aides d’ailleurs). De fait, je n’ai pu que très partiellement commencer à réfléchir sur l’écriture du code qui correspondrait à mon application. Je n’avais avant cela jamais travailler sur les bases de données, il m’a donc fallu me renseigner dans un premier temps sur celles-ci, comprendre leur fonctionnement et dans le même temps, j’ai du cherché des informations sur certains protocoles de transferts de données dont j’avais lu les noms dans les documentations américaines de JDBC.
Ce fut un travail différent pour moi puisque je travaillais sur quelque chose de totalement inconnu et qui plus est en anglais, ce qui malgré tout est plus difficile. Une « doc » française sur un sujet totalement inconnu, ça peut être déjà difficile mais alors en anglais et incomplète, c’est vraiment difficile par moment. Cependant, c’est une recherche assez passionnante. Elle permet de comprendre comment va fonctionner un système et de chercher à savoir comment on va pouvoir installer un système qui utilisera de la meilleure façon possible les capacités de cette outil pour le moins « virtuel ». Il existe bien des exemples de mise en place de cette plate-forme de communication mais il ne sont que partiel et ne fonctionne pas encore de la meilleure façon.
L’intérêt de JDBC est en effet bien là. Il permet
de servir de plate-forme dans l’acquisition de données ou dans la
relation avec un serveur extérieur. Il permet de donner à
Java la possibilité de travailler avec n’importe quel autre système
suivant le meilleur protocole possible. C’est une technologie très
intéressante qui doit permettre de réaliser de la meilleure
façon ce que j’ai voulu pour intégrer les données
à cette application.
Pour une entreprise, il présente tous les avantages, plus besoin d’uniformiser les plates-formes matérielles, plus de maintenance coûteuse si l’application est réellement développer entièrement en Java. Il dispose en plus d’outils qui seront capable de s’adapter à tous les types de demandes d’une entreprise. Depuis une interface à un programme de gestion ou un accès à une base de données en passant par la création de petites applications style « macro », comme le propose le module JavaBean ou encore la publication pour les réseaux internes et externes. Java serait capable de couvrir tous les domaine.
Plus particulièrement, je regretterais de ne pas avoir eu plus
de temps dans mon stage pour approfondir encore plus ce que j’ai appris
sur le langage et sur ce qui gravite autour. Je pense toutefois continuer
pour moi-même à développer cette application car après
y avoir passé tout ce temps, je souhaite réellement la voir
fonctionner complètement. Ainsi, de mon côté, il est
certain que ce que j’ai fait n’est pas juste un projet, j’ai envie de continuer
à programmer en Java pour produire autre chose que ce que j’avais
déjà fait avant ce stage, c’est à dire des applets
et des modifications d’applets.
Je suis ainsi à la fois content mais frustré. Je n’ai
en effet vu qu’une toute petite partie des possibilités de Java.
Toutes les possibilités de calcul, de création de Bean, au
travers du nouveau JavaBean Developer’s Kit, d’animations, de gestion du
son et de la vidéo...
Les possibilités de ce langage sont si vastes que je n’ai pas
eu assez de temps pour même lire toutes les possibilités décritent
par exemple dans le Tutorial Java.
Ainsi, je crois avoir vécu une expérience intéressante
et originale au travers de laquelle j’aurais beaucoup appris sur mes méthodes
de travail en programmation et dans laquelle j’aurais connu la technologie
de demain Java.
Et pour finir attention, Java est un virus: demain, il sera partout,
dans vos ordinateurs, dans vos applications et même dans votre quotidien
!
;o)
Merci aussi à Monsieur Geoffroy de m’avoir permis de faire ce stage à l’Insa. Stage qui m’aura permit d’apprendre à réfléchir différemment de ce que j’avais fait jusque là autour de Java et d’être totalement conquis par ce langage.
En espérant avoir fait le travail que vous attendiez et avoir l’occasion de nouveau de travailler avec vous, je vous remercie encore de m’avoir accueillis durant ces quelques semaines au sein de l’Insa.
· The Java Book Pages: French Java Books - http://lightyear.ncsa.uiuc.edu/~srp/java/french.html
La liste de tous les livres français dédiés
à Java ou y touchant un peu réactualiser souvent, elle permet
de suivre la publication des documentations en français dans le
temps. En remontant dans l’arborescence de ce serveur on remarque une liste
bibliographique pour toutes les langues européennes.
· Pause Java - http://pausejava.u-strasbg.fr/
Un des plus célèbre site français dédié
à Java par les premiers pionniers de Java. Intéressant il
regroupe des choses intéressantes pas toujours mise à jour
malheureusement.
· Java par Patrick Longuet - Edition Sybex.
Un livre didactique qui explique chaque méthode de Java
et introduit aux langage de programmation orienté objet.
· Java, la toute première fois par Nathan et Ori Gurewich
- Edition S&SM.
Un basic qui explique comment construire une applet ou une application,
bon outils pour debbuger des erreurs de compilation.
· Java, PC Poche par R. Mäurers et K. Baufeldt - Edition
Micro Application.
Une introduction à Java, à sa création,
à sa logique et son avenir au travers de l’Internet.
· HTML & Java par Laurent Viegnes et Stéphane Boix
- Edition Micro Application.
Un livre qui retrace l’historique de la création et l’évolution
des nouveaux langages orientés sur la publication et le développement
d’applications pour l’Internet. Malgré peu de renseignements et
peu de qualité, c’est un livre qui situe bien le rôle des
réseaux et leurs nécessités dans le futur du développement
technologique de l’informatique.
Dans ce contexte, l’idée n’est pas de prendre exactement la place de Microsoft, il ne semble pas possible de détrôner le géant de sa place de domination du marché par contre il est possible de montrer que le monde « Microsoft », fait du PC et de son Windows fétiche n’est pas incontournable, que plusieurs systèmes différents peuvent cohabiter dans le monde de l’informatique en fonction des spécificité de chaque problème mais qu’une plate-forme unique comme Java permet de passer d’un système à un autre sans aucun problème.
C’est tout à tout à fait dans cette logique que s’inscrit Java, il ne va pas se substituer aux systèmes d’exploitation existant, il crée juste un moyen de faire tourner sur n’importe quelle machine un programme développé sur n’importe quelle autre machine sans jamais se soucier de la couche OS que l’on aura dessous quand l’application fonctionnera. C’est cela le pari de Java.
Microsoft semble prendre lui aussi la route pour ne pas se faire dépasser
comme l’a laissé faire en son temps IBM qui ne s’est pas adapté
aux mutations du monde informatique.
On ne sait encore qui gagnera cette bataille mais Sun aura lancé
une belle flèche qui aura posé de nouvelles questions et
qui sûrement va changer l’avenir de l’informatique autant sur le
plan professionnel où Java semble devenir incontournable pour nombre
de progiciel que bientôt dans le monde de l’informatique «
grand public » dès que les Network Computer et les systèmes
dédiés Internet vont arriver sur le marché.
La guerre est engagé, Sun a gagné une bataille avec Java mais il va falloir maintenant que toute la plate-forme virtuelle du système Java se mette en place pour défier et faire tomber Microsoft. Mais déjà, Bill Gates a lancé une contre attaque à la nouvelle fonctionnalité de Java sur le Web, en intégrant à Internet Explorer le langage ActiveX, qui permet lui aussi une « mise en mouvement » de l’Internet.
D’un autre coté les deux grands de l’informatique que sont Netscape et Microsoft sont aussi capable de ne plus se faire la guerre pour promouvoir l’espace de leurs marchés. Ainsi, aujourd’hui où l’on veut que le Net sécurise pour pouvoir commercer dessus, les deux géants ont oublié leurs vieilles querelles et viennent de signer des accords pour inclure de la publicité spécifique dans le Web. Le nom de cet accord « Open profiling Standard ».
L’utilisateur rentrera ses caractérises en matière de goût de loisir et dans le même espace publicitaire sur le Web, tous les utilisateurs ne verront pas la même publicité ou la même information en fonction du profil de la personne qui « navigue ».
Comme quoi même ennemis quand il s’agit de faire de l’argent, les frères ennemis se retrouvent, alors pourquoi pas autour de Java, surtout si Microsoft prend cette route. Et même si dans ce cas la puissance de Microsoft ne sera pas ébranlée, la domination du PC dans l’informatique sera remise en jeu.
En effet, il est paru intéressant d’utiliser directement du code Java dans des pages Html, c’est à dire dans les pages Web. Cela permettrer de ce servir de quelques éléments de Java, les plus caractéristiques et de donner une certaine vie à ces mornes pages Web. Ainsi, le concept était de ne pas toujours devoir créer une applet et de devoir l’appeler depuis la page Html, puisque ce processus implique un certain nombre de contraintes comme le même nom pour la classe principale de l’applet, pour le fichier pseudo-code et pour le fichier Html. Bonjour le lisibilité avec tous ces fichiers qui s’appellent pareil.
Il a été mis au point une version légère de Java qui s’intègre en parallèle de la norme Html 3.2 pour certains éditeurs de logiciels comme Netscape qui a parié sur JavaScript dès la version 2 de son navigateur « Navigator ». A partir ce cette norme des commandes Html ont été rajouté dans cette norme constructeur afin de faire appel au compilateur et à l’interpréteur Java.
Dans le cas de script Java, le code est compilé à la volée au chargement de la page et il est ensuite interprété comme une applet classique au travers du browser que l’on utilise. Cela permet d’intégrer de façon moins lourde dans une page Html de petits éléments profitant de la technologie Java. Par exemple, c’est le moyen de faire « tourner un logo », d’avoir des yeux qui clignotent dans une page Html, de faire quelques choix dynamiques dans un menu par exemple. Il permet d’utiliser ainsi les fonctions dynamiques de Java sans avoir à recourir au langage lui-même.
