Introduction

De réels avantages métier

Modèle Magic et productivité

Adapter le modèle à l’entreprise

Neutralité architecturale et indépendance de bases de données

5. Le moteur d’application Magic

6 – Conclusion : la preuve par l’exemple

Magic est un environnement développement conçu pour optimiser le cycle de développement. Magic est construit autour d’un concept ingénieux : un moteur d’application exécute la logique complète de l’application, stockée dans un référentiel. Ce dernier contient toutes les fonctions de l’application : structures de données, règles de travail, logique programmatique et présentation.

Magic travaille à un haut niveau d’abstraction : le développement se résume donc à un processus unique, d’où sont supprimées les étapes liées à la compilation et au linking. Magic est fondé sur le concept suivant : le code saisi par le développeur est celui-là même qui est exécuté par le moteur d’application Magic. Il en résulte des gains considérables de productivité. Grâce au prototypage rapide et itératif, impliquant l’utilisateur final au cours du développement, l’application terminée remporte l’adhésion de tous.

Magic a porté les concepts du RADD (Rapid Application Development & Deployment) au niveau de l’entreprise et lui apporte, dans un environnement professionnel en constante mutation, des avantages concurrentiels concrets. Magic fournit aux développeurs les outils nécessaires pour mettre en place une infrastructure informatique performante. Lorsque les objectifs professionnels de l’entreprise dépendent de l’implémentation de systèmes stratégiques dans des contraintes fortes de temps et de budgets, Magic est l’outil pour gagner la compétition.

A partir d’un modèle de développement uniforme, Magic permet le développement d’applications d’entreprises portables sur de nombreux ordinateurs, systèmes d’exploitation, bases de données, en environnement client/serveur traditionnel et Web. L’environnement de développement de Magic réunit les avantages d’un RADD extrêmement portable et les capacités d’évolution d’un système transactionnel. Les développeurs sont capables de fournir à toute l’entreprise ses applications métier, en temps et en heure, et sans dépassement budgétaire.

Grâce à ce modèle unique, les applications évoluent facilement et en toute efficacité, du groupe de travail à l’entreprise, du client/serveur à l’Internet. Les développeurs utilisent, pour créer des interfaces Java et HTML, le modèle de développement visuel de leurs clients graphiques.

Les solutions Magic sont évolutives et ouvertes. Magic est le meilleur outil d’intégration de l’information de l’entreprise. Grâce à son architecture multi-niveaux, cette information est toujours accessible, même lorsqu’elle réside sur des environnements plates-formes et bases de données hétérogènes. Lorsqu’elles effectuent leur migration vers le client/serveur et l’internet, les entreprises préservent l’intégralité de leurs investissements : matériels, logiciels, données résidant sur des bases ISAM ou SQL.

Magic s’est libéré des contraintes propriétaires, monnaie courante dans les outils de développement diffusés par les éditeurs de bases de données. Magic est un outil de développement indépendant, qui a su s’adapter à la dynamique professionnelle d’aujourd’hui, tout en conservant l’acquis du passé. Son moteur d’application a été développé pour les principales plates-formes. Ses passerelles permettent d’accéder de manière transparente et native à tous les grands SGBD. L’intégralité de l’application étant stockée dans le référentiel, le travail à effectuer pour porter une application est réduite.

Ces concepts se sont avérés extrêmement efficaces dans les cas concrets, où Magic a prouvé sa supériorité à l’occasion de nombreux comparatifs objectifs. Magic est référencé par les plus grandes entreprises.

Partout dans le monde, les développeurs Magic créent des applications stratégiques plus vite et mieux qu’avec tout autre outil du marché.

Dans un environnement en constante mutation, la réduction des coûts est un des objectifs majeurs des entreprises. Lorsqu’il s’agit de rester dans les contraintes budgétaires imposées, elles font face aux exigences suivantes :

- l’évolution des applications au rythme de l’entreprise qui doit investir dans ce qui est nécessaire pour le présent, tout en étant capable de répondre à l’imprévu.

- la recherche d’un outil unique, un seul outil à apprendre et à maintenir, assez productif, puissant, solide et fiable pour répondre à tous leurs besoins, du groupe de travail au niveau global.

En général, on exige de développeurs qu’ils conçoivent des applications capables d’utiliser les investissements existants, matériel, logiciel, données centralisées. Si, aujourd’hui, l’industrie pousse à s’équiper en PC, NC, stations, de travail, interfaces graphiques, réseaux locaux et étendus, bases SQL, architectures client/serveur distribuées hétérogènes et applications Internet/Intranet, il subsiste toujours des centaines de milliers – voire des millions – de terminaux dédiés fonctionnant à la satisfaction de tous.

Dans le climat économique actuel, les directions d’entreprises hésitent à se débarrasser de tels investissements. Elles cherchent le meilleur des deux mondes, c’est-à-dire un processus de migration incrémentale vers les nouvelles technologies tout en respectant les investissements existants.

Une entreprise exige des applications une parfaite adéquation avec les différentes caractéristiques de son métier. Si une stratégie d’entreprise et la tactique qui en découle peuvent se formuler en quelques jours, voire quelques heures, leur mise en place prend généralement des semaines ou des mois. Le goulot d’étranglement réside habituellement dans l’implémentation de l’infrastructure informatique qui mettra en œuvre ces stratégies.

Le lecteur peut donc légitimement se poser la question suivante : "Quels sont les avantages économiques que m’apporte Magic et que ne possèdent pas ses concurrents ?"

Les avantages métiers qui justifient le choix de Magic sont extrêmement simples :

• Réduction spectaculaire des délais de livraison de l’application
• Coûts de développements moindres
• Apprentissage d’un modèle de développement unique pour le client/serveur et le Web
• Adéquation de l’application aux besoins du métier
• Prise en compte des demandes de l’utilisateur final dans l’application
• Respect des investissements matériels et logiciels antérieurs
• Protection de l’investissement applicatif lors de la migration de l’application vers le Web
• Elimination des phases de compilation et de linking du cycle de développement
• Maintenance et modifications rapides
• Evolution des applicatifs clientes avec Magic Serveur

L’implication financière brute de chacun de ces points garantit un retour sur investissement significatif.

Pris ensemble, ils font de Magic un outil exceptionnel.

Magic repose sur le concept d’une technologie innovante, associée à une méthode de développement visuel. Cette méthode de programmation par table utilise le moteur d’application Magic pour construire des applications stratégiques d’entreprise plus vite qu’aucun autre outil sur le marché.

Les analystes de l’industrie ont récemment utilisé le concept de Machine Virtuelle pour décrire le moteur d’application Magic. Cette métaphore est souvent utilisée pour utilisée pour souligner l’indépendance de plate-forme et la neutralité architecturale du moteur d’application Magic.

Le moteur d’application est une excellente illustration de la technologie Magic. Il contient la plupart des fonctions utilisateur final, qui peuvent être activées ou désactivées par le développeur en fonction des besoins d’une application particulière. Ce moteur d’application contient plusieurs moteurs optimisés et spécialisés, pour apporter un taux de performance maximale. Le moteur de recalcul en est un excellent exemple : il permet la mise à jour " à la Excel " des contrôles visuels et des objets de la base de données.

La méthode de développement visuel Magic évite de descendre au niveau du code ou de scripts propriétaires. Les tables ne servent pas uniquement à définir les données. Elles sont également utilisées pour mettre en place la logique de l’application. Magic fonctionne selon une approche de développement essentiellement déclarative. Le développeur met en œuvre des tâches prédéfinis pour manipuler la base de données, et des dialogues de propriétés pour régler les attributs. Il s’évite l’écriture de longues et fastidieuses lignes de code. Les applications Magic sont faciles et rapides à maintenir : grâce à la programmation par table, les modifications essentielles peuvent être faites à la volée.

Un référentiel extrêmement bien conçu stocke toutes les fonctions de l’application : la structure des données, les règles métier, la logique du programme et la présentation de l’information dans un format non compilé et indépendant de plate-forme.

La simplification de la programmation est née avec le code : le programmeur utilisait le langage machine (code) pour passer ses instructions. Le code contrôlait tous les détails liés aux caractéristiques physiques de l’ordinateur. Le langage symbolique a été le premier concept à alléger de manière spectaculaire la charge de travail du développeur. Les assembleurs traduisaient de manière mécanique les symboles lisibles par l’homme en instructions binaires compréhensibles par la machine. Les compilateurs facilitaient le travail du programmeur grâce à des langages de développement d’un plus haut niveau d’abstraction. Cependant le résultat de ces traductions devait être linké, chargé et exécuté manuellement.

Les outils ont gagné en productivité lorsque leur niveau d’abstraction s’est élevé. Ils ont permis aux développeurs de se concentrer sur la logique de l’application, sans tenir compte de l’environnement physique et en réduisant les efforts répétitifs et stériles.

Les systèmes d’exploitation sont des moteurs logiciels d’intérêt général exécutant le programme "d’application" qui se présente sous la forme de modules exécutables au chargement. Au fur et à mesure de l’évolution de l’industrie, les SGBD/R (systèmes de gestion de bases de données relationnelles) ont atteint un niveau d’abstraction supérieur en décrivant les besoins de la base de données au niveau logique. Conceptuellement, le SGBD/R est un module d’exécution, un moteur logiciel dédié à la gestion des fonctions de bases de données. Les langages de 4^ème génération ont été l’étape suivante sur le chemin de la productivité. Ils ont introduit un nouveau niveau d’abstraction où les fonctions écran et les interactions avec l’utilisateur, qui s’opèrent à un haut niveau, réduisent les efforts de programmation. Conceptuellement, le module de déploiement d’un L4G est un moteur dédié, conçu pour gérer les fonction écran et les interactions avec l’utilisateur final.

Nous avons vu la manière dont les solutions à ces trois problèmes logiciels : OS, SGBD/R et L4G, s’expriment dans un concept unique : le moteur.

La question qui se pose alors est simple : peut-on imaginer un moteur soulageant le développeur à un point tel qu’il crée un nouveau modèle dont les avantages sont si spectaculaires qu’ils en paraissent magiques ?

Peut-on concevoir un moteur d’application apportant les avantages de l’indépendance de plate-forme associés à la machine virtuelle, et augmentant la productivité dans des ratios considérables ?

Depuis les outils de traduction de première génération, le format exécutable du code d’une application est différent du format saisi par le développeur. Avec Magic, vous oubliez les notions de code source, compilé, objet, semi-compilé, pseudo-code, méta-langage et modules exécutables au chargement. Le format du code de l’application Magic défini par le développeur et celui dans lequel il se présentera au moteur d’application Magic sont conceptuellement identiques. Il s’agit d’un processus unique dans lequel le "code" saisi par le développeur est immédiatement exécutable sans traitement intermédiaire.

Magic a réduit la syntaxe du langage, tout en conservant la sémantique. Il a donc supprimé les surcharges inhérentes à l’utilisation des langages interprétés. Dans Magic, le temps de traitement est principalement consacré à l’exécution des fonctions spécifiques de l’application. Ces fonctions sont intégrées dans le moteur d’application et implémentées sous forme de code natif compilé et optimisé. Simultanément, les fonctions sont paramètrées pour que les développeurs puissent décrire une grande variété d’applications.

La réputation de l’outil RAD Magic est justifiée par le fait que toute la description de l’application, y compris la logique, les règles métier, les écrans et les données sont stockées dans le référentiel (le fichier de contrôle) et sont exécutées par le moteur d’application.

En voici les résultats :

• Pas d’outils de compilation et de linking
• Pas d’investissement matériel nécessaire au fonctionnement de ces outils
• Les développeurs se concentrent sur les fonctions et les besoins métier plutôt que sur le code et les instructions de bas niveau
• Chaque composant de l’application est testé dès qu’il est décrit, sans passer par les itérations " édition-compilation-linking "
• Les utilisateurs finaux participent de manière active au prototypage.

La méthode traditionnelle "en cascade" de l’approche conception/développement/livraison des applications aux utilisateurs finaux est désormais obsolète. Cette méthode classique qui contraignait l’utilisateur final à déterminer ses besoins à un stade précoce du développement était trop rigide pour les entreprises jeunes et dynamiques.

Le développement et déploiement rapides d’applications (RADD) avaient pour but de mettre à leur disposition une alternative aux méthodes traditionnelles, en impliquant l’utilisateur final à tous les stages du développement grâce à des techniques itératives de prototypage. L’efficacité d’une telle méthode est reconnue par le fait que tous les outils modernes l’ont adoptée.

Dans Magic, l’approche RADD a été portée au plus haut niveau, pour tirer le meilleur parti de la contribution de l’utilisateur final et de son implication dans l’application. Cette approche a révolutionné les relations entre développeur et utilisateur.

Pour tirer le meilleur profit d’un projet RADD, les développeurs doivent travailler avec le bon outil. Magic a été conçu dès le départ pour intégrer les méthodes de développement et de déploiement rapides d’applications. Son système de développement par table permet de travailler selon une approche itérative et dynamique de développement, qui implique les utilisateurs finaux. Ces derniers peuvent surveiller les évolutions de l’application qu’ils utiliseront.

Bien que Magic ne soit pas lié à une méthodologie particulière, les paragraphes suivants décrivent une méthode RADD qui a, depuis plusieurs années, largement fait ses preuves.

DSDM est une approche du RADD très efficace. Magic est membre fondateur du consortium indépendant DSDM et travaille de manière étroite avec cette association, pour que les chefs de projets qui la mettent en œuvre puissent bénéficier des connaissances et des expériences des meilleurs experts RADD.

La mise en œuvre de Magic et DSDM supprime une fois pour toute les arbitrages soi-disant inévitables entre :

• Puissance et productivité
• Livraison rapide et facilité de maintenance
• Facilité d’utilisation et richesse fonctionnelle
• Adaptation aux règles métier et livraison à temps pour le déploiement

DSDM contient les règles d’analyse et la méthodologie d’un projet RADD : projets importants, techniques de gestion des configurations, directives pour l’estimation des risques et de ressources, ainsi que tout problème lié à la qualité et la pertinence du développement. La méthode DSDM implique l’utilisateur final à un stade précoce du développement. Son adhésion à l’application finale est totale et l’implémentation de passe en douceur. Cette méthode garantit également que le système, une fois livré, correspond aux besoins réels de l’entreprise, tout en réduisant considérablement les risques de développer une application sans doute parfaite, mais qui risque d’être "hors sujet".

Cette expression englobe les approches de programmation où le développeur se concentre plus sur la description de la logique de l’application (le quoi) plutôt que sur l’implémentation des détails (le comment). De nombreux laboratoires mènent des recherches intensives, avec l’objectif déclaré d’améliorer de manière notable la productivité du développement d’applications. L’efficacité et la rapidité des développeurs Magic sont la preuve de l’efficacité de l’approche déclarative.

Magic utilise la programmation déclarative, et particulièrement dans les phases de manipulation de données, propriétés des formulaires et gestion des événements.

Etudions la manière dont Magic met en œuvre le concept de programmation déclarative dans un exemple de manipulation de base de données.

Dans une approche non déclarative, le développeur spécifie explicitement à un endroit précis de son code les actions de base de données à accomplir. Ces actions sont de quatre types : chercher un enregistrement, ajouter un nouvel enregistrement, effacer ou modifier un enregistrement existant.

Magic ne possède pas de commandes explicites pour spécifier ces actions de base de données. Comment faire alors, pour contrôler et spécifier les manipulations sur la base de données ?

Dans Magic, la plus petite unité de travail est la tâche. Lorsque l’on associe un mode à une tâche, le moteur d’application connaît l’action de base de données à exécuter. Pendant le développement, le développeur déclare le mode (Modifier, Créer, Effacer ou Recherche) d’une tâche. De son point de vue, l’endroit dans Magic où ce mode est déclaré n’a aucune relation physique avec le lieu où la logique réelle est spécifiée : la table d’exécution des tâches.

L’éditeur de formulaires Magic est une autre illustration de la programmation déclarative dans Magic. La conception et le réglage d’un formulaire ne demandent aucun code procédural. Le Dialogue de Propriétés contient toutes les options nécessaires pour travailler sans écrire de code. Les propriétés se règlent pour l’ensemble du formulaire et les contrôles qu’il contient. Le moteur de recalcul de Magic permet de faire des modifications à la volée, et garantit la cohérence interne, sans intervention du développeur.

L’exemple ci-dessous montre que la propriété "visibilité" d’un bouton poussoir peut être facilement contrôlée par une règle, dans la table des expressions.

La palette des variables, qui s’active à partir de l’éditeur de formulaires, permet de créer directement des contrôles à partir des structures de données. Une connexion logique immédiate est créée entre le modèle de données et l’interface graphique.

La gestion des événements est un autre exemple du développement déclaratif dans Magic. La puissance du code non procédural permet aux programmes ou aux sous-tâches de s’exécuter lorsqu’ils sont activés par une action clavier, un laps de temps donné ou par le passage d’une condition à Vrai. Par exemple, l’utilisateur active un raccourci clavier (une action prédéfini) et exécute un événement pendant qu’il modifie un champ. A la fin de l’événement ou de la sous-tâche, l’utilisateur peut continuer à modifier le champ, et son curseur pointera sur le caractère où il se trouvait lorsque l’événement a été déclenché.

L’information présentée dans un format structuré est plus facile à apprendre et à comprendre que l’information non structurée. L’information peut être présentée de plusieurs manières : texte, graphiques ou icônes. La table en est une autre représentation. Le fait que l’on puisse présenter autant d’informations différentes dans un format table prouve leur efficacité, tant pour celui qui met en forme cette information que pour l’utilisateur. Les tables sont un mécanisme équilibré de présentation visuelle d’informations textuelles et numériques dans un format structuré.

Magic utilise cette méthode dans un environnement de développement visuel et structuré. Plutôt que de passer du temps à écrire un code verbeux, le développeur Magic saisit l’information dans une série de tables liées. Cette information est stockée dans des tables relationnelles, pour éviter les redondances et profiter au maximum de la saisie des relations, référencées par les pointeurs.

Le modèle Magic exploite ces concepts relationnels ainsi que les avantages qui en découlent. Le développeur gagne en productivité tout au long du cycle de développement de l’application. Contrairement aux approches de programmation par langage ou par script, dans lesquelles toute référence à une entité nommée est explicite, Magic utilise les concepts relationnels pour réduire à une seule les références explicites à toute entité nommée : l’entrée table, où cette référence est définie au départ. Toutes les autres références sont implicites et réalisées par des liens entre les tables de saisie. Magic est, dans ce domaine, particulièrement astucieux car ces opérations se font de manière simple et transparente. Le développeur n’est jamais confronté à la notion de pointeurs. Il utilise toujours les entités nommées telles qu’elles ont été définies au départ.

Cette démarche s’applique également lorsqu’il s’agit de développer les fonctions (la logique) de l’application. L développeur possède la liste des opérations (commandes) et des fonctions disponibles, dans un format totalement explicite. En interne, elles sont représentées sous forme de code et de liens, très compacts.

Les ramifications d’un développement visuel par table sont considérables :

• les interfaces graphiques actuelles permettent de travailler vite et bien sur les structures de tables
• la programmation devient visuelle, passant d’une table à l’autre
• les modifications dans l’application sont immédiatement propagées, quel que soit le lieu où elles sont référencées. Ce résultat est la conséquence directe de la structure relationnelle de Magic
• la vue des données de l’application est encapsulée dans l’arbre de tâches
• les erreurs de syntaxe sont virtuellement impossible car programmer en Magic consiste à créer des nouvelles entrées de tables à partir d’entrées prédéfinis, elles-mêmes créées à partir de tables systèmes prédéfinis
• le code saisi de manière explicite par le développeur pour réaliser son application est minime par rapport à ce qui est requis dans un outil de programmation avec langage.

Pour réduire la tâche des développeurs, le moteur d’application Magic contient un maximum de fonctions utilisateur final, disponibles par défaut pour toutes les applications et tous les utilisateurs. Les développeurs disposent également d’un mécanisme pour activer de manière dynamique ou conditionnelle des fonctions précises.

La plupart des fonctions prédéterminées ont été intégrées dans le moteur d’application pour diminuer de manière significative la tâche du développeur. Toute la souplesse est dans le "langage" Magic, et gère la plupart des applications.

La réutilisation est un des concepts sous-jacents du modèle Magic. Ses avantages se manifestent de trois manières.

La première fait partie intégrante du moteur d’application : C'est un jeu complet de fonctions utilisables dans une large gamme d’applications de base de données. Le développeur utilisera ces fonctions sans écrire ni code ni script. A la place, il détermine une séquence de fonctions intégrées et leurs paramètres. Dans Magic, cette action se fait en renseignant des tables prédéfinis. Cette technique de programmation par tables rend le modèle Magic encore plus facile et productif.

La deuxième est la réutilisation d’entités définies par le développeur dans une ou plusieurs applications Magic.

Enfin, il y a les maquettes formulaires Magic. Les maquettes formulaires suppriment le travail long et fastidieux de préparation des formulaires d’affichage d’écrans interactifs. En donnant aux développeurs ce type de mécanismes pour définir et sauvegarder les entités, Magic s’avère un outil impressionnant par ses capacités de réutilisation.

Plus les développeurs peuvent réutiliser, plus ils gagnent en productivité.

Avant l’arrivée de SQL, qui permet de spécifier les manipulations sur la base de données, il fallait écrire une quantité de code impressionnante pour réaliser une simple opération.

La possibilité de spécifier une requête SQL de type

A représenté un progrès important pour la productivité du développeur.

Cette requête SQL peut être considérée comme un haut niveau d’abstraction à l’intérieur d’une séquence de requêtes multiples dans un langage de bas niveau. Autrement dit, de nombreux signifiants (sémantique) ont été condensés en quelques mots (syntaxe). Il n’en demeure pas moins qu’il reste toujours une surcharge associée aux langages de programmation (scripts).

Serait-il possible d’atteindre un niveau d’abstraction tel que la surcharge résiduelle sera si faible qu’elle n’aura pratiquement aucun impact sur l’exécution de l’application finale ? Si tel est le cas, l’impact sur l’intégralité du développement est considérable : le développement se réduit alors à une étape unique.

Il est important de noter que, si ce but est en théorie possible à atteindre, il n’aura aucune valeur pratique s’il ne peut être présenté au développeur de manière simple à comprendre et à mettre en œuvre.

Le modèle Magic atteint le niveau d’abstraction souhaité, et le fait d’une manière si visuelle qu’il est l’outil idéal pour réaliser les interfaces graphiques modernes. Grâce à l’association de techniques éprouvées dans d’autres contextes, Magic permet de faire un bond considérable en matière de productivité.

Le modèle Magic a été si bien conçu qu’il passe le test de la durée, dès lors qu’il est confronté aux concepts d’aujourd’hui et aux technologies de demain. Son ouverture et sa capacité à évoluer supportent la seconde génération des architectures client/serveur ainsi que l’explosion de l’Internet dans l’entreprise ; Magic est un outil client ET serveur architecturé de manière à garantir une distribution fluide des traitements, un aspect stratégique pour les environnements complexes.

La robustesse et la flexibilité du concept de base permettent d’effectuer une migration descendante du gros système au client/serveur, ascendante du client/serveur aux réseaux locaux, et d’intégrer les transactions Internet dans les applications existantes. Les entreprises protègent leurs investissements et leurs applications hôtes tout en tirant parti d’un environnement de développement graphique moderne. Magic apporte à l’entreprise, au fil de sa croissance et de l’augmentation de ses besoins en complexité et en puissance, des capacités d’évolution et de flexibilité qui vont jusqu’à l’intégration d’applications Internet dans les systèmes centraux.

Tout au long de son histoire, Magic Software Entreprises a démontré à quel point elle s’engageait dans la protection des investissements applicatifs de ses clients. Les évolutions vers les nouvelles technologies, de DOS à Windows, aux plates-formes 32 bits et à l’Internet ont été transparentes. Magic a conçu ces évolutions en encapsulant la complexité de la technologie pour garder son avantage d’outil RADD.

Magic permet à l’entreprise toute entière de bénéficier de ses techniques de développement et déploiement rapides d’applications (RADD). La technologie Magic est une combinaison unique de productivité RADD élevée et de transactionnel Internet. Magic permet aux entreprises de tirer le meilleur parti de leurs systèmes hôtes et de diffuser des applications ouvertes, fonctionnant aussi bien sur les clients, les serveurs et l’Internet.

Enfin, lorsque l’entreprise décide de mettre en place de nouveaux outils de communication interne, Magic permet de développer très rapidement des applications Intranet.

Les applications transactionnelles sur l’Internet reposent sur les concepts reconnus qui ont fait de Magic l’outil le plus productif du marché.

Magic est le seul outil RADD d’entreprise qui repose sur un modèle unique et un environnement de développement intégré pour l’hôte, le client/serveur et l'Internet, avec une architecture multi-niveaux et des capacités de partionnement d’applications. Magic permet aux développeurs de concevoir des applications à grande échelle tirant parti des avantages du client/serveur et de l’Internet.

Magic a sa place à tous les niveaux de l’entreprise, avec des applications allant du groupe de travail au département et à l’entreprise tout entière. Son niveau de productivité répond à de nombreux types d’applications, sans qu’il soit besoin de recourir à des outils spécifiques pour répondre aux besoins de tâches spécifiques.

Prenons par exemple l’éditeur de formulaires. Dans l’environnement Windows, en utilisant les techniques du glisser/déposer et pointer/cliquer, Magic permet aux développeurs de créer des clients en mode caractères ou graphique, des interfaces Java et HTML pour l'Internet, sans utiliser les outils Java et HTML.

Aujourd’hui, pour être compétitif sur le marché, il faut être capable de concevoir et développer des systèmes évolutifs. Le temps et l’expérience ont montré que le modèle client/serveur traditionnel à deux niveaux rencontre des problèmes dès lors qu’il ne repose que sur la puissance de traitement du client. Le volume important de données transitant sur le réseau provoque de sérieuses baisses de performances, inacceptables dans le cas d’applications stratégiques.

L’architecture de Magic est neutre et indépendante des plates-formes et des bases de données. C’est l’outil de déploiement d’applications dans l’entreprise. Les capacités d’évolution de Magic sont uniques dans l’industrie, et profitent autant au client qu’au serveur. Le moteur d’application Magic est optimisé pour s’exécuter le plus efficacement possible sur le client et le serveur.

Une application Magic tactique peut devenir une application stratégique. Elle se déploie indifféremment sur plusieurs plates-formes, SGBD/R, serveurs, se partitionne et croît en volumétrie et en complexité, dans des environnements hétérogènes, pour devenir simultanément un environnement client/serveur et Web.

Les développeurs construisent une application logique indépendante de l’environnement physique sous-jacent, sans se poser la question de savoir la manière dont la logique de cette application sera distribuée sur les clients et les serveurs. Lorsque l’application est partitionnée pour être exécutée sans modifier les définitions de la logique de l’application. Ce système permet un développement et un réglage plus efficaces de l’application dans un environnement distribué.

En répartissant la puissance de calcul entre les serveurs d’applications, les développeurs augmentent les performances, exploitent au maximum la puissance de calcul et sont capables de s’adapter à des structures informatiques décentralisées.

Magic possède une solution de Middleware orienté message (MOM) prête à l’emploi qui permet d’être immédiatement opérationnel lors de la mise en place d’applications distribuées. L’implémentation de l’architecture multi-niveaux de Magic permet d'effectuer des accès et des traitements simultanés de clients graphiques et Web, en y ajoutant des fonctions essentielles de gestion et de partitionnement d’applications. Ces avantages sont primordiaux lorsqu’il s’agit de répondre aux besoins de performances, d’administration, de gestion et de sécurité requis par les applications stratégiques d’entreprises.

L’évolution des applications dans l’entreprise est assurée par le Broker Magic, qui gère les files d’attente côté CLT ou serveur et l’exécution des transactions en mode synchrone ou asynchrone. Cette architecture permet aux développeurs de maintenir un groupe de process d’applications serveur utilisé lorsqu’une transaction, pour que celles qui sont prioritaires soient traitées immédiatement. Ils identifient et suivent les process spécifiques d’une application ainsi que les serveurs sur lesquels ils sont exécutés. En cas de panne, ils sont capables d’identifier les process affecté par cette panne.

Magic permet de re-router le process pour garantir la continuité de l’activité de l’application. Avec Magic, les développeurs peuvent répliquer les services d’applications stratégiques et rediriger automatiquement les requêtes de services vers la copie de sauvegarde, chaque fois que la copie principale est disponible. Ces modifications peuvent être faites à la volée pour déterminer l’emplacement d’un serveur où une application sera exécutée, où pour augmenter les niveaux de tolérance de panne en ajoutant de nouvelles répliques. Aucune de ces opérations n’exige de modifier la logique de l’application Magic.

Magic permet aux développeurs d’équilibrer les traitements entre plusieurs serveurs. Au fur et à mesure de la montée en puissance de l’activité et de l’augmentation du trafic réseau entre le serveur de données et le serveur d’applications, ainsi que la complexification des interfaces clients, les applications tireront parti des capacités de Magic à gérer les performances et à ajuster de manière dynamique l’équilibrage des traitements. Le trafic sur le réseau étant réduit, les applications Magic sont plus rapides. Les coûts de support et de maintenance diminuent, les performances des transactions sont optimisées.

Magic vous laisse le choix du modèle de partitionnement d’applications qui convient le mieux à votre activité. Il peut aller du modèle traditionnel hôte/terminal, jusqu’au traitement coopératif complexe, avec partitionnement logique et serveurs multiples. Indépendamment du modèle choisi, les clients et les serveurs se concentrent sur des tâches précises et participent pleinement à la solution optimale. Les développeurs peuvent désigner des serveurs de sauvegarde et des paramètres de fin de tâche qui protègent contre les pannes de serveur en basculant automatiquement le traitement des applications vers un autre serveur.

Les besoins en partitionnement d’applications évoluent dans le temps pour s’adapter à l’activité de l’entreprise. Aussi est-il capital de pouvoir modifier rapidement une application. Le partitionnement dynamique de Magic permet au développeur ou à l’administrateur de modifier la combinaison des niveaux et des services distribués sur plusieurs configurations matérielles. Grâce au modèle de développement par table, les développeurs peuvent implémenter la répartition de la logique de l’application d’un serveur vers un autre en modifiant simplement les entrées dans une table de répartition. Ils peuvent également le réaliser simplement, par des liens "glisser/déposer".

Une application convenablement partitionnée gagne en performances et capacités d’évolution. Magic est un outil puissant de réglage des performances.

L’environnement multi-niveaux de Magic supporte le traitement de process importants et répétitifs dans des applications client/serveur et transactionnelles Internet (OLTP). Les clients graphiques Magic accèdent aux serveurs d’applications Magic via le réseau traditionnel client/serveur. Magic permet de gérer les serveurs et les applications, et d’allouer et de répartir les process d’applications entre les clients et tous les serveurs d’application Magic. Le serveur a les capacités d’évolution souhaitées pour être accessible par les nombreux utilisateurs d’un système Internet/Intranet.

Le Broker Magic permet de garder un niveau élevé de performances. Cette technologie permet de contrôler et d’exécuter plusieurs applications Magic sur le Web, qui seront robustes, performantes et rapides. Le Broker Magic gère la file d’attente des requêtes en provenance des serveurs Web et les distribue vers les moteurs de déploiement disponibles sur un ou plusieurs serveurs d’applications. Il suit et exécute le module de programme adéquat qui génère le formulaire HTML ou Java et le renvoie au serveur Web.

La technologie Magic supprime les goulots d’étranglement associés au traitement des requêtes Internet, et garde un niveau élevé de performances. Magic s’interface aux serveurs Web tels que Nescape Server API (NSAPI) de Netscape, et Internet Server API (ISAPI) de Microsoft, et utilise les fonctions spécifiques de ces serveurs.

L’Editeur de formulaires de Magic permet de construire graphiquement les balises HTML, avec fonctions de modification, navigation, manipulation des hyperliens, tables, frames et autres balises. Il possède un grand nombre de contrôles dont Texte, Texte enrichi, Bouton poussoir, Image, Combo box, Liste déroulante, Boîte à cocher, Bouton radio, Applets Java, ActiveX.

Magic est un environnement ouvert qui s’intègre de manière transparente aux principaux éditeurs HTML du marché. Il est possible de fusionner des formulaires créés avec Magic à d’autres formulaires, réalisés avec des outils externes. Les pages HTML existantes sont réutilisables.

Magic permet, lors de l’exécution, de générer des pages HTML qui contiennent les données sous forme exécutable. Les développeurs peuvent intégrer des données SQL dynamiques et des objets graphiques à du texte. A la récupération du résultat d’une requête vers une base SQL, les données documentent la page HTML soumise au serveur Web pour affichage. Ces pages HTML affichent les données en ligne ou en tableau, dans toutes sortes de formats. Avec Magic les développeurs peuvent également créer un site Web à la volée. En utilisant ses automatismes, les développeurs génèrent rapidement des formulaires HTML immédiatement déployés sur l'Internet. Ces pages HTML afficheront les données en ligne (tableaux), en masques (un enregistrement) ou de manière personnalisée.

Avec Magic les développeurs peuvent réaliser des clients Java légers, déployés sur le Web. Ils ont la possibilité de combiner les fonctions du client Java avec la logique du serveur d’application Magic, pour réaliser des applications Internet solides, équilibrés, évolutives.

Au déploiement, la définition du formulaire est chargée sur navigateur client pour y être exécutée par la machine virtuelle Java. L’applet de développement Java Magic construit le client léger à partir des paramètres reçus.

Le client Java supprime les limites inhérentes à HTML. L’éditeur de formulaires Java contient tous les contrôles qui manquent à HTML dont les onglets, les groupes et les rectangles. Le contrôle Onglet est particulièrement apprécié par les utilisateurs souhaitant naviguer dans des enregistrements multiples, en conservant la liste des enregistrements d’un côté de l’écran et en affichant la vue détaillée de l’enregistrement sélectionné dans l’autre partie de l’écran. Enfin, Java n’a pas le système contraignant de coordonnées d’HTML et permet de positionner les contrôles là où l’utilisateur le désire.

Le client Magic Java possède un autre avantage de taille qui se situe dans les mécanismes de modification/validation côté client. Chaque contrôle ainsi que le formulaire tout entier peuvent être validés sur le client. Cette technique réduit considérablement le trafic sur le réseau et augmente les performances de l’application. Java maintient l’attribut assigné à une variable, et n’accepte aucune saisie de données qui ne soit pas valide pour cette variable.

Lors de la conception de Magic, il a été évident que, quelle que soit la richesse du moteur, le modèle Magic devait être ouvert pour intégrer des programmes et des applications développées avec d’autres outils.

Magic supporte les standards et les systèmes ouverts. Le succès de Magic est largement dû à ses capacités d’ouverture et d’interfaçage avec d’autres systèmes ouverts. Cette capacité d’ouverture a convaincu à de multiples reprises les entreprises clientes d’adopter une technologie innovante et non conventionnelle. Le développeur qui choisit Magic est sûr qu’il aura accès à toutes les technologies conformes aux règles des systèmes ouverts.

L’ouverture de Magic de manifeste de plusieurs manières :

Les applications serveur de Magic peuvent être appelées à partir de différents types de clients, y compris Magic tous les L3G et L4G ainsi que Java. Avec Magic, les entreprises peuvent faire évoluer leurs applications client/serveur de première génération pour implémenter des fonctions serveur. Une application réputée non évolutive n’aura pas besoin d’être redéveloppée. En d’autres termes, des applications à clients lourds évolueront grâce au serveur Magic, sans remettre en cause les bases de données dans une architecture unique et cohérente sans avoir à redévelopper et déployer les applications, et former les utilisateurs finaux à d’autres technologies.

A l’heure des composants réutilisables, un logiciel se doit d’être ouvert, et intégrer des composants externes dans son environnement de développement. Magic est également une plate-forme capable d’intégrer les composants standard de l’industrie dans une application Internet. Les applets Java, les JavaBeans ou les contrôles Activex peuvent être intégrés dans un formulaire HTML à partir de la palette de contrôle.

Cette architecture permet la distribution sécurisée des fonctions et de l’interface client sur le Web. La logique de l’application est protégée. Cette ouverture de Magic permet au développeur d’utiliser tous les composants ActiveX disponibles.

Magic supporte les opérations OLE2I, Linking et Embedding. Linking permet de lier Magic à un objet existant dans le système d’exploitation. L’objet n’est pas stocké, mais référencé dans la base de données. Embedding crée également un lien entre Magic et un objet externe, mais dans ce cas, l’objet est encapsulé dans la base de données.

Magic Software Entreprises s’est depuis toujours attaché à fournir aux développeurs un environnement ouvert pour que les applications Magic puissent interagir avec d’autres produits. L’API Magic leur fournit un jeu de fonctions permettant aux développeurs de produits tiers d’accéder directement au référentiel Magic.

L’API accorde les droits de lecture/écriture sur tous les composants de référentiel Magic, et permet la modification, la création et la suppression d’opérations.

Cette API est un environnement de développement sécurisé. Lorsqu’une opération API est demandée, elle vérifie les droits de l’utilisateur dans un fichier pour s’assurer qu’il a le droit d’effectuer cette opération. L’API contient également des fonctions permettant d’accéder et de récupérer les données concernant les configurations et les règles de l’application, et des informations stockées dans les différents dictionnaires et menus Magic.

Magic Software Entreprises a développé une interface entre Magic et un outil de modélisation de bases de données. System Architect de Popkin. L’API Magic est la passerelle qui lie directement System Architect à l’environnement de développement Magic. Cette alliance se fonde sur une technologie qui permet aux utilisateurs de travailler de manière bi-directionnelle entre Magic et System Architect. Les développeurs peuvent ainsi concevoir, modéliser, développer, déployer et gérer des applications reposant sur les deux technologies. Une nouvelle interface permet aux développeurs Magic d’alimenter les tables et de générer des programmes à partir de modèles et de diagrammes System Architect, et également de générer des diagrammes SA à partir d’une application Magic.

Une interface a été également développée entre Magic et WinDesign de Cecima, outil de modélisation de données et traitements selon la méthode Merise 2.

Nous avons décrit plus haut dans ce chapitre le fonctionnement du Broker Magic. Mais Magic possède également une interface avec des outils middleware reconnus : Tuxedo de BEA Systems ainsi que CICS, MQ/Series d’IBM et DataQueue.

L’interface existant entre Magic et le moniteur transactionnel Tuxedo est une solution conçue pour les développeurs qui mettent en place des solutions traitant des milliers de transactions. Cette interface tire parti des fonctions de Tuxedo : Magic appelle les Services Tuxedo. Ces services peuvent être écrits dans l’application Magic, pour régler l’équilibre de charge et effectuer des transactions distribuées avec commit à deux phases (XA). Cette opération se déroule dans l’environnement Magic, et ne demande ni compilation ni liens.

Magic Software Entreprises a développé une interface entre Magic et WinRunner de Mercury Interactive, leader du marché des tests automatisés. WinRunner est l’outil développé par Mercury Interactive pour effectuer des tests de non-régression. Cet outil permet aux développeurs Magic d’enregistrer leurs tests et de les rejouer en utilisant des points de régression pour vérifier la logique et les réponses de l’utilisateur final. L’intégration de Magic et de WinRunner permet aux développeurs d’enregistrer les déplacements de la souris, les actions clavier, de sauvegarder les priorités des contrôles et des fenêtres pour les rejouer ensuite.

Lorsqu’un environnement doit supporter le développement d’applications d’entreprise importantes, impliquant le travail de plusieurs collaborateurs sur les différents modules d’un même projet, cet environnement doit pouvoir supporter le développement coopératif et le contrôle de version. Le contrôle de version de Magic utilise un système de répertoire qui garantit l’efficacité du développement en équipe. Un Développeur ne peut intervenir sur le travail des autres développeurs collaborant au projet, ni le modifier. Il met également à leur disposition un mécanisme qui leur permet de détecter et afficher les modifications qui ont été apportées aux composants d’un système Magic.

Le Système de Contrôle de Version Magic (MVCS) est un système de contrôle des éléments du référentiel Magic. MVCS répond de manière efficace aux exigences de contrôle de version auxquelles sont confrontés les développeurs et les chefs de projet Magic. Il est composé de plusieurs fonctions intégrées conçues pour que les développeurs puissent travailler le plus rapidement possible sans rencontrer les problèmes de contrôle courants dans tout développement de projets complexes. MVCS convient particulièrement aux intégrateurs d’applications importantes et aux SSII dont les équipes de développement travaillent ensemble sur un projet.

MVCS sauvegarde l’historique de la version. Cet historique peut être utilisé pour détecter rapidement les modifications intervenues au fil des révisions d’un projet de développement Magic. Il trace toutes les activités de développement et de maintenance en cours et permet de réaliser des développements en parallèle, avec fusion des fonctions de l’application. MVCS élimine les modifications conflictuelles induites par le travail de plusieurs développeurs, et crée une méthode contrôlée de réservation/libération des éléments du référentiel. Ses nombreuses fonctions et son interface intuitive en font un outil de travail de groupe très productif en environnement de développement distribué.

MVCS est intégré à Magic. Sa mise en œuvre est immédiate, et la productivité du développeur complète. Il est conçu de manière ouverte, et peut être utilisé par d’autres outils de gestion des configurations. Les données sont accessibles par programmation, puisqu’elles sont stockées dans le référentiel.

Magic est une solution particulièrement bien conçue et architecturée. Les investissements sont préservés, dans les environnements Windows, Windows NT, AS/400, Open VMS et la plupart des plates-formes Unix. Cette sécurité est due au fait qu'il existe un moteur d'application Magic pour tous ces environnements. En outre, les applications centrales cohabitent avec les applications Magic.

Magic préserve également les investissements en données grâce à ses passerelles accédant aux principaux SGBD/R SQL est sites centraux. Magic traite des données en provenance d'environnements hétérogènes. Une application Magic accède à plusieurs types de fichiers et bases de données via de nombreuses configurations de réseaux en utilisant plusieurs protocoles de communication.

Du moment qu'il existe une méthodologie de description d'application, une machine virtuelle puissante et un référentiel, la seule modification à faire pour chaque environnement de plate-forme est l'instance de la machine virtuelle : le moteur d'application Magic. Le développeur de l'application n'a pas besoin de faire migrer, recompiler et linker le code source de l'application. Magic Software Entreprises réalise une fois pour toutes et pour chaque plate-forme la migration, la recompilation et le linking du code source du moteur d'application. Le développeur n'a plus qu'à effectuer le portage d'un seul fichier, le référentiel. Magic possède des outils rapides et efficaces pour porter l'application tout entière ou des sous-systèmes précis (une ou plusieurs tables).

Les développeurs d'applications sont à l'affût des méthodes et des outils leur permettant d'écrire des applications génériques sans avoir à se soucier de la base de données sous-jacente avec laquelle l'application sera déployée. Ces méthodes et outils doivent également simplifier et accélérer le processus de déploiement de l'application dans un environnement de base de données précis.

Les bases de données SQL confèrent un haut niveau d'indépendance. En pratique, l'effort requis pour mettre en place une application fonctionnant avec plusieurs bases de données de fournisseurs différents peut être minime lorsque ces bases de données sont compatibles ODBC, où particulièrement complexes, lorsqu'il s'agit de modifier le code, le recompiler et procéder à un nouveau linking. L'effort demandé dépend de la méthode utilisée et des fonctions de l'outil de développement. En outre, compatibilité SQL ne signifie pas nécessairement compatibilité avec les bases hôtes et intégration transparente des nouvelles applications à ces bases.

Il est difficile d'imaginer une indépendance de base de données plus simple que celle de Magic : pour indiquer la base de données à sélectionner, il suffit de modifier une entrée dans une table unique.

L'indépendance de Magic vis à vis des bases de données valorise les investissements existants et garantit une migration progressive de l'application. Vous pouvez immédiatement démarrer le développement d'une application stratégique tout en conduisant l'étude qui vous permettra de choisir la base de données appropriée. Toutes les applications migreront facilement et de manière transparente.

Cette méthode est simple à comprendre, facile à mettre en œuvre et rapide. En effet, développer en Magic ne nécessite pas de code, il est fondé sur un système de programmation par tables, alors que de nombreux autres systèmes s'appuient sur un langage dépendant de SQL, des pré-compilateurs, des compilateurs et des linkers.

Magic est un système ouvert conçu pour se connecter aux principaux SGBD/R et systèmes de partage de fichiers. Ces connexions se font en utilisant des passerelles spécifiques à chaque SGBD et système hôte.

Les passerelles de bases de données Magic sont intégrées à l'environnement du produit. Le développeur déploie les passerelles nécessaires pour accéder aux bases de données de l'application. Des passerelles additionnelles permettent au développeur de passer d'une base de données à l'autre, en utilisant les méthodes Magic de développement graphique.

C'est dans le domaine de l'interopérabilité client/serveur et Web que la simplicité, la puissance et l'élégance de l'architecture, des concepts et des outils Magic sont le plus évidents. Lorsque les passerelles souhaitées sont installées sur le système client et que dans les entrées de tables le nom et l'emplacement du serveur où est placé le référentiel, tout client Magic peut se connecter à l'application.

Les utilisateurs finaux utilisent les applications déployées sur toute plate-forme serveur à laquelle le client est connecté si, bien sûr, les passerelles nécessaires pour accéder à l'application sont accessibles à partir de la plate-forme client.

Magic est un outil de développement d'applications conçu pour les développeurs professionnels d'applications de bases de données. Les applications développées avec Magic fonctionnent avec la plupart des SGBD/R compatibles SQL, dont Sybase, Oracle, Microsoft SQL, Server, DB2 et Informix. Il est également possible d'accéder à des SGBD compatibles OBDC.

L'approche de programmation par tables de Magic est utilisée pour adresser à la fois les aspects DML et DDL de SQL sans qu'il soit besoin de recourir à du code SQL.

Les tables DML de Magic possèdent une caractéristique majeure, l'héritage (propagation). Toute modification dans une entrée d'une table Magic est automatiquement et instantanément propagée à travers toutes les autres tables Magic qui font référence à la table modifiée. Comme les programmes Magic sont eux-mêmes définis dans les tables qui référencent les tables DML Magic, il n'est pas exagéré de dire que sans réécriture de code, recompilation, relinking ; une application modifiée est prête à être testée sur-le-champ. Pour les développeurs, et particulièrement pour ceux qui doivent maintenir des applications client/serveur interopérables, les ramifications d'une propriété unique sont d'une importance considérable.

Un des aspects les plus surprenants de Magic réside dans le fait que les aspects déclaratifs statiques d'une application ne sont pas les seuls à être définis dans les tables : il en est de même pour ses aspects dynamiques, fonctionnels et procéduraux. Par exemple, spécifier les actions de base de données qui seront réalisées par un programme d'application (l'équivalent logique de DML) ne nécessite aucun code.

Magic réalise l'équivalence fonctionnelle d'une DML avec plusieurs mécanismes :

• retrouver un enregistrement dans Magic (SELECT) se fait dans une table, de manière directe et explicite. Le moteur d'application Magic traduit la saisie en son équivalent DML.
• manipuler des enregistrements dans Magic (INSERT, DELETE, UPDATE) se fait de manière déclarative et implicite, sous forme de tâche, qui peut être une création, une modification ou une suppression. Le moteur d'application Magic détecte ce mode, modifiable dynamiquement, en fonction de l'action de l'utilisateur ou de tout critère spécifique à l'application, et qui sera traduit en son équivalent DML.

La traduction d'une action de base de données demandée implicitement dans un programme Magic en une requête explicite qui sera reconnue par un SGBD/R particulier, est réalisée par les différentes couches de Magic. L'association du moteur d'application, du Broker, du gestionnaire de fichier et des passerelles Magic gère la conversion d'une requête implicite en un appel explicite aux fonctions du SGBD.

Outre la génération automatique de requêtes SQL, le développeur peut écrire des requêtes explicites et les inclure dans un programme Magic. Les fonctions spécifiques de l'éditeur seront utilisées en écrivant la requête selon la syntaxe du produit. La passerelle Magic l'accepte et passe la requête au serveur de bases de données.

Magic remplace le code procédural par un système dans lequel le développeur entre les règles logiques de conception dans différentes "Tables d'opération", dont chacune fait référence à une étape précise dans le cycle d'exécution du moteur d'application. Ce moteur est intégré à tous les systèmes Magic. Il exécute les applications en suivant les règles de conception établies par le développeur. 13 opérations suffisent, qui remplacent intégralement la myriade de commandes et états des outils de développement L3G et L4G conventionnels, sans sacrifier aux exigences de souplesse, de fonctionnalités ou de complexité de la logique.

Pour comprendre le moteur d'application Magic, il est nécessaire de considérer que l'unité de base de traitement de l'application est un objet exécuté par le moteur. Cet objet est la Tâche. Pour conserver la cohérence avec le modèle base de données relationnelle du référentiel Magic, l'information concernant chaque tâche est stockée dans un ensemble de tables liées. Ces tables sont activées par la boucle d'exécution Magic. L'information stockée dans ces tables est l'illustration de l'approche déclarative de Magic.

Magic a été conçu pour adresser des applications dont l'activité base de données est intense. Ces applications sont généralement interactives en lignes, mais Magic convient également aux traitements en tâche de fond et à la génération de rapports. En raison de la conception du moteur d'application Magic, et particulièrement le cycle dans la boucle implicite que chaque Tâche exécute dans l'application, le développeur n'aura à spécifier que les besoins de traitements uniques à chaque application.

Chaque tâche Magic possède une structure en bloc fixe, qui est le reflet du cycle du moteur d'application décrit ci-dessus. Chaque table est associée à ses tables d'opération et il existe une table pour chaque bloc de la structure d'exécution de la table. Ces tables sont la représentation concrète des opérations qui spécifient la logique et les actions qui seront effectuées sur les vues de données pendant l'exécution de la tâche.

Les opérations au niveau de la tâche sont effectuées une fois par tâche, soit au moment de son initialisation (préfixe de tâche) ou en fin de tâche (suffixe de tâche). Ce niveau comprend des opérations de style en-tête de rapports (préfixe de tâche) ou totaux (suffixe de tâche).

Les opérations au niveau de l'enregistrement sont effectuées une fois par enregistrement, lors de son initialisation (préfixe d'enregistrement), pendant l'interaction avec l'utilisateur final (corps d'enregistrement) ou lors de la validation de l'enregistrement (suffixe d'enregistrement). Dans le corps d'enregistrement, les boucles sur champs sont réalisées sur les tâches en lignes.

Toutes ces opérations sont spécifiées de manière explicite par le développeur, contrairement à de nombreuses opérations exécutées automatiquement par le moteur d'application. Parmi les exemples illustrant les opérations implicites, on trouve notamment les opérations de base de données d'initialisation et de manipulation de fichiers et d'enregistrements.

Il suffit à Magic de 13 opérations prédéfinis pour atteindre le même niveau de fonctionnalités et de complexité dans la logique que les outils L3G et L4G. En effet, la plupart des opérations font partie intégrante du moteur d'application Magic. Une étude des L4G montre que les opérations de base de données ou de gestion d'écran représentent entre un tiers et la moitié des déclarations dans le langage. Dans les L3G, ces opérations ne font pas exactement partie du langage en lui-même mais sont généralement gérées par des appels à des librairies de routines ou par une approche hybride, à base de SQL. En général, les L3G nécessitent beaucoup plus de code que les L4G.

A l'exécution, Magic exécute automatiquement un certain nombre de tâches "ménagères" au cours d'une phase d'initialisation, au démarrage de la tâche, et pendant une phase de fin, lorsqu'on quitte la tâche.

• Ouvrir et fermer les fichiers de base de données (bases non SQL)
• Ouvrir et fermer des fichiers autres que les bases de données (fichiers I/O)
• Initialiser les variables
• Lire les enregistrements dans la base de données
• Tâches d'affichage

Le développeur n'aura pas besoin, pour exécuter ces opérations, d'écrire du code explicite. Elles sont intégrées au moteur d'application Magic.

Dans Magic, la plupart des opérations qui généralement exigent l'écriture de code sont gérées automatiquement. Les seuls aspects d'une tâche qui doivent être spécifiés de manière explicite sont ceux qui gèrent la logique réelle d'une tâche et les calculs qu'elle doit effectuer, ainsi que l'interfaçage de la tâche avec des composants externes, comme des fichiers I/O, périphériques et programmes non Magic.

Les tables d'exécution des tâches sont des tables d'opérations qui décrivent la logique de la tâche. Chaque table fait référence à une étape précise du cycle d'exécution. Chaque entrée de table possède un identifieur d'opération et un jeu de pointeurs vers d'autres tables. En fait, les tables d'exécution dans un programme Magic remplacent le code source et les scripts traditionnels de L3G et L4G conventionnels.

Bien que le nom complet d'une commande soit visible partout où elle est utilisée, il est stocké sous forme de caractère unique dans le référentiel Magic. De la même manière, les noms complets des champs sélectionnés sont visibles alors que seules leurs références sont stockées dans le référentiel.

1. Champs Définit la vue des données
2. Verif Valide la saisie des données
3. Lien Etablit une relation 1 vers 1
4. Fin Lien
5. Bloc Identifie le début et la fin d'un groupe logique d'opérations
6. Fin Bloc
7. Exec. Transfère le contrôle vers une autre entité, serveur local ou distant
8. Evaluer Exécute une fonction spéciale Magic
9. Modif. Calcul par Magic
10. Ecrire I/O Ecriture de données sur un fichier I/O
11. Lire I/O Initialisation de données à partir d'un fichier I/O
12. Edit I/O Permet à l'utilisateur de parcourir un fichier texte (lecture/écriture)
13. Système Lance n'importe quelle commande OS en synchrone ou asychrone.

Le moteur d'application Magic gère les traitements répartis via une opération "Exec.". L'appel distant permet aux développeurs de définir les informations nécessaires à la réalisation du partitionnement de l'application. Il peut spécifier le service souhaité à partir d'une liste de serveurs et du nom du programme à exécuter. Il indique alors si le programme doit s'exécuter en mode synchrone ou asychrone.

Cette fonction particulièrement puissante est implémentée au sein même du modèle Magic. Les concepts qui sous-tendent la méthode de programmation par tables de Magic, modèle unique et sans code, contribuent à la productivité du développeur. Il n'a pas besoin d'avoir une connaissance particulière des réseaux, partitionner une application est plus facile que l'on peut penser.

La simplicité des concepts Magic peut surprendre. Mais c'est grâce à cette simplicité que les applications les plus stratégiques ont été développées plus rapidement qu'avec aucun autre outil du marché. Un nombre sans cesse croissant d'entreprises importantes, qui ont fait le choix de Magic pour mettre en place leurs applications métier, témoignent de l'efficacité de la théorie décrite dans ce document.

Depuis plus de 10 ans, Magic a mis en œuvre les grands concepts de productivité, d'ouverture, de méthodologie RADD, de portabilité, d'indépendance de plate-forme et, plus récemment, l'Internet/Intranet.

Les gains immédiats de productivité obtenus grâce à Magic sont fondés sur le fait qu'il existe un lien direct entre la quantité de code qui doit être spécifié et la vitesse à laquelle l'application est développée. Moins de code égale plus de productivité. En substituant au processus traditionnel d'écriture du code par une technologie de programmation par tables complètement automatisée, Magic permet d'obtenir des gains de productivité spectaculaires, auxquels s'ajoutent ceux associés au moteur d'application, c'est-à-dire la suppression définitive du travail de compilation et de linkage pendant le développement.

La décennie écoulée a vécu des changements considérables dans l'industrie informatique. On a vu naître et disparaître nombre de mots, concepts, langages, méthodes à la mode. Qu'il s'agisse de L4G, outils de prototypage, langage de base de données, outils de génie logiciel de haut ou bas niveau, outils client/serveur, générateurs d'application, Internet/Intranet, le défi était le même :

Des dizaines de milliers de développeurs Magic ont mis le moteur d'application de Magic à l'épreuve. Ils ont vu que la réponse était dans le modèle Magic. Les développeurs qui ont découvert ce qu'était un gain de productivité avec les applications client/serveur Magic utilisent aujourd'hui l'outil pour masquer la complexité des technologies contemporaines. Les développeurs Magic conçoivent des applications d'entreprise client/serveur et Internet/Intranet qui répondent à tous les critères d'indépendance de base de données, portabilité et interopérabilité, et qui protègent les investissements existant à l'intérieur de l'entreprise.

Le modèle unique de Magic ne se contente pas de passer l'épreuve du temps. Il va beaucoup plus loin.