[EN] [IT]
[INFO] [ACQUÉRIR] [PLAN] [RESSOURCES]
CHAPITRE
APPRENDRE À PROGRAMMER AVEC FUTUREBASIC
NOTES
L'environnement

Leçon 2 : Là où les choses commencent à devenir sérieuses


On a vu que programmer cʼest dʼabord rédiger du texte en utilisant un langage particulier dont les mots sont prédéfinis, et vous nʼy couperez pas, il vous faudra les apprendre. Fort heureusement, il nʼy en pas tant que ça. La « puissance » dʼun langage ne se mesure d'ailleurs pas à la quantité de ses mots-clés, et curieusement ce serait plutôt lʼinverse qui serait vrai.

Le texte que vous rédigez sʼappelle le code source pour faire la différence avec le code exécutable produit à partir de votre prose par le compilateur.

Le code source peut-être écrit avec nʼimporte quel outil pouvant traiter du texte et le sauvegarder. Par exemple vous pourriez taper votre programme dans SimpleText, mais il ne fait pas de doute que vous choisirez lʼoutil offert par lʼenvironnement. LʼÉditeur de FutureBASIC est extrêmement agréable à utiliser, car cʼest un traitement de texte orienté vers la programmation et il est tout particulièrement étudié pour fonctionner en harmonie avec le Compilateur. Avec FB^3, éditeur et compilateur sont deux applications séparées qui communiquent entre elles, mais en réalité vous nʼaurez pour ainsi dire jamais à vous soucier du compilateur.

Après avoir rédigé votre code source, vous demanderez à lʼÉditeur dʼexécuter votre programme, lʼÉditeur préparera rapidement votre texte dans une forme plus adaptée au travail du Compilateur, puis il appellera automatiquement le Compilateur en lui fournissant toutes les informations dont il a besoin pour accomplir sa tâche. Le Compilateur analysera alors votre code source et en fera la traduction en code exécutable, il finira par créer une application parfaitement autonome et tout à fait régulière sur la plate-forme Macintosh quʼil lancera dans la foulée comme si vous aviez fait un double-clic sur son icône depuis le Finder. Tout cela est très rapide et se réalise de manière transparente pour le programmeur, cʼest-à-dire en lʼoccurrence, pour vous. Lʼaffaire est entendue, la mise en œuvre est extrêmement simple, mais les choses vont maintenant se compliquer un petit peu.

FutureBASIC est un outil qui doit répondre à différents types de besoins et dʼutilisateurs : de lʼamateur qui veut sʼamuser, au professionnel qui veut commercialiser ses applications en passant par lʼingénieur ou le laborantin qui ne veut que produire des résultats de calculs. Pour répondre à ces demandes, FutureBASIC offre la possibilité de choisir un environnement dʼexécution adapté. On appelle ce contexte un runtime. Le runtime contient la définition des mots-clés qui sont disponibles pour un contexte donné. Vous choisissez le runtime en sélectionnant à partir de l'Editeur lʼoption dans le menu Commande qui est appropriée à ce que vous voulez faire.

Le Runtime Console possède un avantage pour le débutant, car il le dispense de gérer lʼinterface utilisateur de son programme, du fait que cette interface est réduite à sa plus simple expression. L'interface utilisateur est constituée des éléments le plus souvent graphiques (menus, fenêtres, boutons, etc.) qui sont présentés à l'utilisateur final de votre application pour qu'il puisse communiquer avec elle. Avec la Console, seules deux fenêtres gérées automatiquement sont disponibles dans cet environnement, lʼune pour lʼaffichage de texte et lʼautre pour les graphiques. Le Runtime Console est essentiellement utilisé par les débutants qui font leurs premiers pas ou bien par les ingénieurs qui ne sʼintéressent quʼaux résultats de leurs calculs. À lʼoccasion, il est aussi utilisé par les autres programmeurs pour tester rapidement une fonction ou un algorithme individuellement. Ce Runtime nʼautorise pas lʼutilisation de tous les mots-clés du BASIC, seule une partie dʼentre eux est disponible. Cela ne diminue en rien la puissance du langage, mais, il n'est pas nécessaire d'avoir accès à des mots-clés qui gèrent des menus ou des boutons par exemple, si vous n'êtes pas autorisé à en créer.

Le Runtime BASIC Standard est le plus utilisé de tous les runtimes, car, dans ce contexte, vous avez accès à tous les mots-clés dont vous trouverez la définition dans le manuel de Référence. Il est alors à la charge du programmeur de gérer lʼinterface utilisateur de son application, comme installer des menus, ouvrir des fenêtres, créer des boutons et bien sûr, il se doit de répondre adéquatement aux clics et aux choix de lʼutilisateur final. Vous découvrirez vite quʼavec FutureBASIC, les choses ne sont pas terriblement compliquées à mettre en œuvre pour ce qui est des petits programmes, mais quʼelles auront cependant tendance à devenir de plus en plus lourdes à gérer à mesure que votre application évoluera. Cette complexité nʼest pas due à FutureBASIC, mais tout simplement à lʼévolution des systèmes et des technologies avec le temps. Mais rassurez-vous, il y a aussi des parades.

Le Runtime Toolbox est essentiellement utilisé par les bons développeurs Macintosh qui maîtrisent déjà la programmation sur cette plate-forme. Il nʼy a pratiquement plus de mots-clés BASIC disponibles dans ce contexte. Vous vous demandez alors « mais dans quelle langage programme-t-on ? »

Le Macintosh arrive avec des milliers de fonctions préprogrammées par les ingénieurs de chez Apple. Toutes ces routines composent les fondations sur lesquelles repose le Macintosh. Lʼensemble de ces milliers de routines sʼappelle la Toolbox (la boîte à outils). En réalité, ce sont les briques fondamentales qui constituent tous les autres programmes écrits pour le Mac. En faisant appel à ses routines intégrées, vous vous approchez très intimement du système Macintosh et de son fonctionnement interne.

Notez que FutureBASIC vous permet dʼappeler les routines de la Toolbox directement depuis votre code source comme sʼil sʼagissait de mots-clés intégrés au langage BASIC. Cette particularité est très appréciable, car vous allez apprendre à manipuler la Toolbox très progressivement, cʼest-à-dire que vous allez assimiler les « vraies » techniques de programmation utilisées sur le Macintosh, et surtout vous progresserez au rythme qui vous convient.

Vous avez sans doute deviné que le Runtime nʼest quʼune couche logicielle entre vous, en tant que programmeur, et la Toolbox. En effet, lorsque vous utilisez un mot-clé du BASIC, le Runtime se charge de convertir pour vous ce mot-clé en instructions destinées à la Toolbox. Finalement, les commandes et les fonctions du BASIC ne sont rien de plus quʼune façon simplifiée dʼaccéder à la caverne dʼAli Baba de la Toolbox du Mac.

En autorisant un accès quasi complet à la Toolbox, FutureBASIC permet aux programmeurs de réaliser des applications sans jamais faire appel aux instructions du langage BASIC. En principe, les applications résultantes sont plus compactes et elles sʼexécutent aussi un peu plus rapidement.

Le Runtime Appearance est un environnement relativement récent de FutureBASIC qui répond à un besoin important. Comme vous le savez les systèmes d'exploitation qui animent nos machines sont sujets à de constantes évolutions. De nouvelles technologies sont introduites au gré des moutures qui fleurissent à un rythme parfois très tendu, concurrence oblige. Il y a quelques années Apple a introduit, l'Appearance Manager (le gestionnaire d'apparence) qui se voulait entre autre une unification et une amélioration des éléments d'interface que tout programmeur pouvait offrir à l'utilisateur final de son application. Des centaines de nouvelles procédures et fonctions ont rejoint en la circonstance la Toolbox du Macintosh.

FutureBASIC autorisait l'accès à ces nouvelles routines moyennant de sérieux efforts de programmation et aussi, il faut le dire, une lutte contre le runtime qui se mettait parfois en travers de la route du programmeur téméraire. Il manquait toutefois une reconnaissance officielle de toutes ces nouveautés par les instructions BASIC de l'environnement de programmation, si bien que les applications réalisées avec FutureBASIC prenaient, plus le temps passait, un air de plus en plus vieillot.

Le runtime Appearance est venu combler cette lacune. Non seulement, il reconnaît les mots-clés du BASIC standard, mais il en introduit de nouveaux dans le langage pour tenir compte de l'évolution sans retour du système d'exploitation du Macintosh. Ne serait-ce qu'à ce titre, le runtime Appearance est naturellement appelé à supplanter le runtime Standard dans de brefs délais.

Comment cela se traduit-il exactement ?

Ce n'est pas le propos ici de détailler les évolutions apportées par l'Appearance Manager, un livre entier n'y suffirait pas, mais nous pouvons prendre un exemple concernant ce que le BASIC a historiquement appelé des boutons et que la Toolbox appelle des contrôles. À l'origine, le programmeur n'avait affaire qu'à un ensemble très limité de contrôles qu'on peut d'ailleurs nommer tant cette liste est courte : boutons poussoirs, boutons radio, cases à cocher et barres de défilement (parfois appelées aussi ascenseurs). L'Appearance Manager a non seulement amélioré tous les contrôles existants avec de nouvelles variantes (par exemple les boutons poussoirs peuvent désormais accueillir des icônes), mais en a introduit une kyrielle de nouveaux (parmi lesquelles boutons biseautés, glissières, barres de progression, menus locaux, petites flèches, etc.). Chacun des contrôles disposant de nombreuses variantes, tant en ce qui concerne leur aspect que leur comportement, le nombre des possibilités offertes est devenu si important qu'il n'est pas question de les décrire ici.

Pour le programmeur FutureBASIC, la commande BUTTON permettant de créer des contrôles ne pouvait plus suffire. Le runtime Appearance a changé la règle du jeu puisque, tout en autorisant l'utilisation de cette commande pour des raisons de compatibilité avec le runtime Standard, il permet d'accéder à la pléthore des contrôles de l'Appearance Manager grâce à sa nouvelle commande BASIC APPEARANCE BUTTON.

Bien entendu d'autres changements ont été opérés pour mettre au point ce runtime moderne. Certains comportements entre le runtime Standard et le runtime Appearance peuvent différer ici ou là, mais dans l'ensemble l'adaptation d'anciens programmes vers ce nouveau runtime devrait pouvoir se faire relativement facilement.

Pour ce qui nous concerne, nous éviterons dans nos premières leçons d'entrer dans des considérations sur le runtime à utiliser, étant donné que notre but est de présenter des concepts de programmation valables quel que soit l'environnement d'exécution choisi, et même quel que soit le langage de programmation utilisé.

Le Runtime BASIC-88 est une curiosité qui permet de programmer comme avec de très anciens BASIC et nous nʼen parlerons plus ici.

À mesure de lʼévolution de FutureBASIC, dʼautres runtimes pourront voir le jour.

Pour les leçons qui vont suivre nous ferons plus particulièrement appel au Runtime BASIC Standard ou au Runtime Appearance, car ce sont les runtimes en principe utilisés par la majorité des programmeurs FutureBASIC pour écrire des applications répondant aux règles de programmation du Macintosh.

Je ne peux terminer ce bref condensé sans mentionner un des atouts majeurs de FutureBASIC par rapport à d'autres environnements de développement. Le runtime qui permet d'exécuter des instructions du langage BASIC est en réalité du code exécutable. D'ordinaire, votre code source une fois compilé fait appel à des fonctions du langage préprogrammées et précompilées. Par exemple, la commande PRINT du langage BASIC invoquera des routines écrites par les concepteurs de l'environnement de programmation. En règle générale, on se soucie assez peu de savoir comment cette routine a été programmée, et on assume simplement qu'elle fonctionnera exactement comme la documentation le stipule. Avec FutureBASIC, les runtimes ne sont pas précompilés. Ils ne deviendront du code exécutable qu'au moment où vous déciderez de compiler votre application, ils sont donc compilés en même temps que votre propre code source. Le programmeur, s'il le souhaite, peut avoir accès au code source des runtimes qui sont eux même écrits avec FutureBASIC. Il peut les modifier à loisir pour éventuellement les adapter à ses besoins particuliers ou en améliorer des routines ou créer un nouveau runtime personnalisé et même si cela s'avère nécessaire corriger de possibles dysfonctionnements sans qu'il ait besoin d'attendre avec impatience que les concepteurs délivrent une nouvelle version de leur logiciel de programmation. Cet exercice un peu périlleux est à laisser aux programmeurs aguerris; d'ailleurs vous ne trouverez aucune documentation pour vous aider à retrouver votre chemin dans les méandres du code source. Les fichiers des runtimes sont situés dans le dossier Headers du dossier Compilateur. Le nom d'un fichier de code source runtime débute par Rntm.



[Precédent] [Table des Matières] [Suivant]

Code exécutable
Est aussi appelé code objet.

Algorithme
Un algorithme est une suite logique dʼinstructions destinée à résoudre un problème donné.

© 2000 Pix&Mix
Tous droits réservés

FutureBASIC est une marque déposée appartenant à Staz Software, Inc et utilisée avec permission.