Pourquoi Ada est le langage avec lequel vous souhaitez programmer vos systèmes

EnregistrerEnregistréSupprimé 0
Score du Deal0
Score du Deal0

Le langage de programmation Ada est né au milieu des années 1970, lorsque le département américain de la Défense (DoD) et le ministère britannique de la Défense ont cherché à remplacer les centaines de langages de programmation spécialisés utilisés pour les systèmes informatiques embarqués qui constituaient de plus en plus des éléments essentiels de l'armée. projets. Au lieu de cela, Ada a été conçu pour être un langage unique, capable de s'exécuter sur tous ces systèmes embarqués, qui offraient le même niveau de performances et de fiabilité.

Avec la révision de 1995, le langage ciblait également les systèmes à usage général et ajoutait la prise en charge de la programmation orientée objet (POO) sans perdre de vue les valeurs fondamentales de fiabilité, de maintenabilité et d'efficacité. Aujourd'hui, les logiciels écrits en Ada constituent l'épine dorsale non seulement du matériel militaire, mais aussi des projets commerciaux comme l'avionique et les systèmes de contrôle du trafic aérien. Le code Ada contrôle des fusées comme les Ariane 4 et 5, de nombreux satellites et d'innombrables autres systèmes où les petits défauts peuvent avoir des conséquences majeures.

Ada pourrait également être le bon choix pour votre prochain projet intégré.

Planification de niveau militaire

Pour choisir le nouveau langage de programmation, le DoD a affrété le High Order Language Working Group (HOLWG), un groupe d'experts militaires et universitaires, pour établir une liste d'exigences et choisir les langues candidates. Il en est résulté les soi-disant «exigences Steelman».

Ariane 5ES: Ada Inside (photo DLR_de CC-BY-SA 2.0)

Les exigences essentielles de Steelman étaient les suivantes:

  • Un général, flexible une conception qui s'adapte pour répondre aux besoins des applications informatiques embarquées.
  • Fiabilité. Le langage devrait aider à la conception et au développement de programmes fiables.
  • Facilité de maintenabilité. Le code doit être lisible et les décisions de programmation explicites.
  • Facile à produire efficace code avec. Les constructions inefficaces doivent être facilement identifiables.
  • Non inutile complexité. La structure sémantique doit être cohérente et minimiser le nombre de concepts.
  • Facile à mettre en œuvre la spécification de la langue. Toutes les fonctionnalités doivent être faciles à comprendre.
  • Indépendance de la machine. La langue ne sera liée à aucun détail matériel ou système d'exploitation.
  • Définition complète. Toutes les parties du langage doivent être définies de manière complète et sans ambiguïté.

Les exigences ont conclu qu'empêcher les programmeurs de faire des erreurs est la première et la plus essentielle ligne de défense. En supprimant les possibilités de faire des erreurs subtiles telles que celles commises par la conversion de type implicite et d'autres constructions dangereuses, le code devient automatiquement plus sûr et plus facile à maintenir.

Le résultat de ce processus de sélection était que même si aucun langage de programmation existant n'était adapté pour être le seul langage pour les projets DoD, il était certainement possible de créer un nouveau langage qui pourrait répondre à toutes ces exigences. Ainsi, quatre constructeurs ont été payés pour faire exactement cela. Un processus de sélection intermédiaire a choisi les deux approches les plus prometteuses, avec finalement une langue émergeant comme vainqueur et nommée «Ada».

Défense en profondeur par défaut

Le système de type d'Ada n'est pas simplement fortement typé, mais souvent appelé «super-fortement typé», car il ne permet aucun niveau de conversions implicites. Prenons par exemple ce morceau de code C:




typedef uint32_t myInt;
myInt foo = 42;
uint32_t bar = foo;

Il s'agit d'un code valide qui compilera, exécutera et produira le résultat attendu avec bar imprimer la réponse à la vie, l'univers et tout. Ce n'est pas le cas pour Ada:




tapez MyInt est Integer;
foo: MyInt;
bar: Entier;
foo: = 42;
bar: = foo;

Cela ferait que le compilateur Ada lance une erreur désagréable, car ‘Integer’ et ‘MyInt’ ne sont évidemment pas les mêmes. Le principal avantage de ceci est que si l'on devait changer la définition de type plus tard, cela ne ferait pas soudainement exploser mille conversions implicites dans la base de code. Au lieu de cela, il faut convertir explicitement entre les types, ce qui favorise une bonne conception en empêchant le mélange des types car «ils sont de toute façon les mêmes».

Quiconque a lutté contre le bourbier de mélanger les définitions de types C, Linux et Win32 standard peut probablement apprécier de ne pas avoir à fouiller dans d'innombrables pages de documentation et de code source mal formaté pour déterminer quel typedef ou macro contient la définition de type réelle de quelque chose qui vient d'exploser à mi-chemin d'une compilation ou lors d'une session de débogage.

Ada ajoute des couches de défense supplémentaires grâce à des vérifications à la compilation et à l'exécution. Dans Ada, le programmeur doit nommer explicitement les instructions de fermeture des blocs et indiquer la plage qu'une variable peut prendre. Ada ne définit pas de types standard comme int ou flotte, mais exige à la place que l'on crée des types avec une plage spécifique depuis le début. C'est également le cas pour les chaînes, où à part les chaînes non bornées, toutes les chaînes ont une longueur fixe.

Au moment de l'exécution, des erreurs telles que les accès illégaux à la mémoire, les dépassements de mémoire tampon, les violations de plage, les erreurs hors ligne et l'accès aux baies peuvent être testées. Ces erreurs peuvent ensuite être traitées en toute sécurité au lieu de conduire à un plantage de l'application ou pire.

Ada implémente un modèle de types d'accès plutôt que de fournir des pointeurs génériques de bas niveau. Chaque type d'accès est géré par un pool de stockage, par défaut ou personnalisé pour permettre des implémentations de mémoire système plus exotiques comme NUMA. Un programmeur Ada n'accède jamais directement à la mémoire de tas, mais doit utiliser ce gestionnaire de pool de stockage.

Enfin, le compilateur ou le runtime décide de la façon dont les données sont transmises dans ou hors d'un appel de fonction ou de procédure. S'il faut spécifier la direction de chaque paramètre (avec ‘dans","en dehors', ou 'in out’), La décision finale de savoir si les données transmises via un registre, via le tas ou comme référence seront prises par le compilateur ou le runtime, jamais par le programmeur. Cela évite les problèmes de dépassement lorsque l'espace de pile n'est pas suffisant.

Le profil Ravenscar et le dialecte SPARK sont des sous-ensembles d'Ada, ce dernier se concentrant fortement sur les contrats. Au fil du temps, les caractéristiques de ces sous-ensembles ont été absorbées dans la spécification du langage principal.

Programmation avec Ada aujourd'hui

L'ANSI a certifié la spécification Ada 83 en 1983; Le 80286 d'Intel venait de sortir et le 68000 de Motorola n'avait que quatre ans. C'était l'aube des ordinateurs personnels, mais c'était aussi la transition maladroite des années 1970 dans les années 1980, lorsque les microcontrôleurs devenaient plus populaires. Pensez à l'Intel 8051 et à son incroyable EPROM 4 Ko et 128 octets de RAM.

Logo du projet Dragon EggLes microcontrôleurs populaires d'aujourd'hui sont beaucoup plus puissants que ceux qui étaient disponibles en 1983. Vous pouvez saisir n'importe quel MCU ARM, AVR, RISC-V, etc. (ou kit Lego Mindstorms NXT) et commencer à le développer comme vous le feriez pour n'importe quel autre C- chaîne d'outils basée. Sans surprise, le compilateur GNAT Ada populaire est construit sur GCC. Une chaîne d'outils basée sur LLVM est également en préparation, utilisant actuellement le projet DragonEgg.

Il existe deux versions de la chaîne d'outils Ada basée sur GCC. La version AdaCore bénéficie d'un support commercial, mais est livrée avec certaines chaînes attachées. La version de la Free Software Foundation est naturellement gratuite et présente plus ou moins de parité avec AdaCore.

Pour commencer rapidement, vous pouvez soit utiliser l'IDE GNAT Programming Studio (GPS) fourni avec la version AdaCore de la chaîne d'outils GNAT (et sur Github), soit l'utiliser avec un éditeur de texte de votre choix et compiler à la main, ou tricher en écrivant des Makefiles. La chaîne d'outils ici est légèrement plus compliquée qu'avec C ou C ++, mais rendue très facile en utilisant le gnatmake utilitaire qui enveloppe les outils individuels et fonctionne essentiellement comme GCC, de sorte qu'il peut être facilement intégré dans un système de construction.

L'interface principale de GNAT Programming Studio.

Un exemple d'un petit projet Ada, non trivial, écrit par le vôtre vraiment sous la forme d'un analyseur d'arguments en ligne de commande peut être trouvé sur sa page de projet. Vous pouvez trouver un Makefile qui construit le projet dans le ada / dossier, qui définit les dossiers dans lesquels les spécifications du package Ada (.les publicités) et les corps de colis (.adb), des fichiers peuvent être trouvés.

Ces fichiers correspondent grosso modo aux fichiers d'en-tête et source en C et C ++, mais avec quelques différences importantes. Contrairement à C, Ada n'a pas de préprocesseur et ne fusionne pas les fichiers source et d'en-tête pour créer des unités de compilation. Au lieu de cela, le nom du package spécifié dans la spécification est référencé, ainsi que son interface. Ici le nom du .les publicités Le fichier n'a pas non plus besoin de correspondre au nom du package. Cela offre beaucoup de flexibilité et empêche les problèmes trop courants en C où l'on peut obtenir des dépendances circulaires ou avoir besoin d'inclure des fichiers d'en-tête dans un ordre particulier.

Où aller en partant d'ici

Après avoir saisi la chaîne d'outils GNAT, déclenché le GPS ou le Vim / Emacs, et avoir regardé le curseur clignotant sur une page vide pendant un certain temps, vous vous demandez peut-être comment commencer. Heureusement, nous avons récemment couvert ce projet qui avait un projet basé sur Ada fonctionnant sur un noyau PicoRV32 RISC-V. Cela utilise le CPLD ICE40LP8K commun qui est pris en charge par les chaînes d'outils FPGA open source, y compris Yosys.

Ada fonctionnant sur un noyau RISC-V, pilotant des LED.

Les introductions et les références pour le langage lui-même se trouvent comme une introduction simple pour les développeurs Java et C ++ (PDF), la référence de base AdaCore, une référence sur WikiBooks, et bien sûr 'Programming in Ada 2012' au format d'arbre mort pour ceux qui comme ce petit supplément de poids. C'est probablement la référence la plus complète au-delà de la plongée dans le Manuel de référence du langage Ada (LRM) 2012 et ses glorieuses 945 pages.

Bien qu'il soit encore assez rare dans les milieux amateurs, Ada est un langage entièrement ouvert avec des chaînes d'outils solides et commercialement utilisées qui sont utilisées pour écrire des logiciels pour tout, de l'ICBM et de l'avionique F-15 au firmware pour les appareils médicaux. Bien qu'un langage assez étendu au-delà des fonctionnalités de base, il devrait certainement figurer sur la liste des langues que vous avez utilisées dans un projet, ne serait-ce qu'en raison de la fraîcheur de votre CV.

Nous serions ravis de connaître votre avis

Laisser un commentaire

Inscription / Connexion fermée temporairement
Comparer articles
  • Total (0)
Comparer