Blackknight a écrit 1234 commentaires

mahikeulbody met la barre vachement haut en disant qu'on pourrait résumer en quelques mots :)
Les grands concepts d'Ada sont:
- Le typage fort
- La concurrence
- la programmation bas niveau en restant haut niveau

Voilà pour les gros points. Ceux-ci se déclinent ensuite en différentes techniques.

Le typage fort

Ada permet la définition de type très contraint.
On peut par exemple définir des types comme

type degre_celsius is range -273..Integer'Last;
type degre_kelvin is range 0..Integer'Last;

Qui définit donc deux types entiers avec des bornes différentes.
Les deux types, même s'ils sont des entiers ayant des plages de recouvrement, sont incompatibles et on ne peut pas, par exemple, assigner à une variable du type degres_kelvin une variable de type degres_celsius sans faire une conversion

degre_c : degre_celsius := 14; -- Température de circonstance
degre_k : degre_kelvin := degre_c; -- Impossible même si la valeur est acceptable
degre_k2 : degre_kelvn := -12; -- le compilateur envoie juste un warning disant que cela va lancer une exception à l'exécution

Ceci n'est qu'un petit exemple du système de type. Pour beaucoup plus d'infos (il est trop tard :)), voir le wikibook.

La concurrence

Les tâches, threads en Java ou C (via les pthread Linux), font partie intégrante du langage depuis 1983.
Le langage définit donc la notion de multiprocessus depuis le début ainsi que les communications inter-process.
Ces dernières se font au travers des points de rendez-vous avec ou sans condition et des objets protégés.
C'est une partie complexe du langage mais qui, comme elle est normalisée, permet de faire de la programmation concurrente sans se soucier de la plateforme.

Soyons clair, là encore, j'abrège à mort :D

la programmation bas niveau en restant haut niveau

Là, il s'agit d'un des domaines où Ada excelle. En effet, on utilise surtout Ada dans l'embarqué… Normal, on ne peut pas y changer le code tous les quatre matins alors on veut un truc qui tienne la route.
Ada permet d'exprimer ce que l'on appelle les clauses de représentation.
Celles-ci définissent comment une structure doit être représentée en mémoire.
Par exemple:

type Medium is range 0 .. 65_000;
for Medium'Size use 2*Byte;
for Medium'Alignment use 2;
Device_Register : Medium;
for Device_Register'Size use Medium'Size;
for Device_Register'Address use System.Storage_Elements.To_Address(16#FFFF_0020#);

Là, j'avoue, je ne me suis pas foulé, c'est dans la norme ;)
L'idée est de dire ce que l'on veut représenter, ici un medium mais aussi la taille allouée en mémoire (et le compilateur dira si cela peut se faire) et l'alignement en mémoire.
Ensuite, on peut même définir l'emplacement en mémoire.
Au passage, on se rend compte qu'il n'est pas besoin de faire appel aux pointeurs pour ce genre d'exercice.
Ceux-ci sont réservés à ce pour quoi ils ont été conçus, à savoir l'allocation dynamique.
Il se trouve que dans l'embarqué, on n'aime pas trop les allocations dynamiques de mémoire puisque le temps d'allocation n'est pas déterministe et le risque d'allocation par manque de RAM qui échoue existe (ce qui pourrait planter le programme).

Conclusion

C'est un résumé beaucoup trop rapide à mon goût mais :
1. il est beaucoup trop tard
2. le langage est très complet avec des concepts réellement orthogonaux (il n'y a que peu d’ambiguïtés voire pas du tout) et il est difficile de tout aborder dans un seul commentaire
3. le langage est complexe (mais comme dirait certains auteurs sur le sujet : c'est un langage complexe pour un monde complexe)

Ce qu'il faut vraiment savoir, c'est que faire compiler un programme Ada est, au début, une vraie gageure tellement le compilateur peut apparaître fasciste mais rien n'est implicite.
Contrairement au C, on estime que le programmeur fait des erreurs et que le compilateur n'en fait pas (au moins dans ce qu'il sait faire).
Au début, on se dit que c'est vraiment trop compliqué, trop verbeux et qu'on se bat contre le compilateur. Après un peu de temps, on utilise le compilateur pour ce qu'il est, un outil permettant de vérifier notre code et générer un binaire qui marche (ok, ça, c'est l'utopie) et la verbosité, c'est finalement un atout quand on doit relire son code six mois plus tard.

Voilà, je pourrais en écrire des tonnes mais je ne peux que te conseille d'essayer, en t'appuyant sur le wikibook, le manuel de référence que tout compilateur doit suivre et les deux newsgroup, le français et l'anglais où l'on ne trouve que des gens sympathiques :)

Je reste dans les parages pour les questions :D

Je n'ai pas pensé lors de la création de la dépêche à mettre un lien vers la vidéo montrant la réalisation du gagnant.
C'est chose faite.

Au passage, j'en profite pour mettre les logs des projets gagnants qui vous donneront accès au code, entre autres :
- Etherscope
- Framework to develop control software for the NXP cup race car
- Bluetooth Beacons

Et pour les prix spéciaux:
- IoT Networking Stack for the NXP FRDM-K64F board
- LVC-EMR-1, an explorer and mapper robot

Ouf, voilà

Finalement, ce serait peut-être bien de les mettre dans la dépêche, histoire que ce soit plus "vendeur" :D

Alors je peux pas te dire pour PowerPC mais pour ARM, ça, je peux.

Le programme suivant compilé pour une carte NUCLEO-F411RE équipée d'un microprocesseur STM32 à partir du site de développement MBED

#include "mbed.h"

Serial pc(USBTX, USBRX);

// main() runs in its own thread in the OS
int main() {
    int a = 1;
    pc.printf("%d\n", a >> 64);
}

retourne… 0 mais envoie un avertissement

Warning: Shift count is too large in "main.cpp", Line: 8, Col: 29
Donc pour ARM, pas de "problème" :)

en ADA le type natural est-il lui aussi cyclique ou, sinon, que se passe-t-il lorsque l'on arrive aux bornes ?

En Ada, il n'y a que les types définis comme modulaires qui le sont. Natural n'en fait pas partie.

subtype Natural  is Integer range 0 .. Integer'Last;

Il s'agit d'un sous-type du type entier et comme lui, un dépassement de capacité provoque une exception.
Le programme suivant est accepté par le compilateur moyennant un avertissement.

with Ada.Text_Io; use Ada.Text_Io;

procedure Nat is
   Nat : Natural := Natural'Last;
begin
   Put_Line("Nat=" & Natural'Image(Nat));
   Nat := Nat + 1;
   Put_Line("Nat=" & Natural'Image(Nat));
end Nat;

gnatmake nat.adb
gcc-4.9 -c nat.adb
nat.adb:7:15: warning: value not in range of type "Standard.Integer"
nat.adb:7:15: warning: "Constraint_Error" will be raised at run time
gnatbind -x nat.ali
gnatlink nat.ali

A l'exécution, il arrive ce que le compilateur avait dit

./nat
Nat= 2147483647
raised CONSTRAINT_ERROR : nat.adb:7 overflow check failed

Voilà, le principe du moindre étonnement dans toute sa splendeur :)

L'élève ingénieur pourra réutiliser cette competence pour automatiser ces taches d'ingénieurs, et ne pas se reposer seulement sur ces collègues programmeurs.

Heu, dans mon ancien boulot, les ingénieurs non informaticiens, c'était plutôt macros Excel mais pas franchement Python.
Et puis franchement, de mon côté, c'est pas mes cours de chimie de première année de prépa qui me permettrait de faire quoique ce soit. En clair, c'est juste pour la culture, un peu comme apprendre l'algorithmie avec Pascal.

sinon, dans cette exemple, tu as écrit un décalage à gauche au lieu d'un décalage à droite (j'imagine que tu t'es laissé embarquer par l'opérateur du cout)

Whaa ! L'andouille !! J'avais pas vu ça :)
Tu as raison, j'ai dû me laisser embarquer par << ce qui ne serait pas arrivé si j'avais fait du C ;)

Autrement dit, spécifier un nombre supérieur à 63 ne comportant pas d'autres bits à un que les deux derniers revient à préciser un décalage de zéro, ce qui correspond bien à ce que l'on obtient pour 64, mais aussi 128 et 192. ;)

Je suis bien d'accord avec le fait qu'en assembleur, il est normal d'avoir un type modulaire pour cela mais bon, là, on parle de langage de haut niveau :D
C'est bien pour cela que je parle de "problème" entre guillemets ;)

rust se démarque un peu : il n'en veut pas.

Je me doutais un peu de ça quand j'ai regardé les specs de shr

Et si on lui passe un nombre non constant qu'il peut pas prévoir, on a un crash.

Voilà qui est sauvage !!

Effectivement, tout s'explique.
Je suppose que les fonctions asr et lsr sont du même acabit puisque

# 1 asr 64;;
- : int = 1
#

Merci bien pour l'explication, je me doutais que je te verrai dans les parages avec mon exemple Ocaml :)

J'ai oublié un mot !!

qui nous a amené à nous poser la question du "comment ksa fait sur les autres langages" :)

Pfff, on a beau se relire trois fois quand le cerveau veut pas voir, y a rien à faire :D

Et si on écrit

var u : QWord; // u entier sur 64 bits
begin
  u := 1;
  write (u >> 32);
end.

alors le résultat est bien 0.

Certes mais on retombe sur le même problème en décalant de 64 bits :)

En tout cas, merci pour les précisions sur les types

En revanche la courbe d'apprentissage est plutôt rude … dommage

Il faut y aller petit à petit et ne pas chercher à manipuler le langage dans son ensemble d'un seul coup.
Personnellement, il y a encore un tétra chiée de trucs dans la norme que je n'ai pas encore utilisés ;)

Ce que je voulais dire c'est que comme rien n'est implicite, il faut écrire la fonction pour l'autre addition et ainsi assurer la commutativité de l'addition, ce qui n'a rien d'obligatoire…

La version exhaustive serait, du coup, celle-là

with Ada.Text_IO;
with Ada.Strings; use Ada.Strings;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;

procedure bad_add is

   function "+" (Left : Integer;
                 Right : String ) return String is
     (Integer'Image (Left) & Right);       

   function "+" (Left : String;
                 Right : Integer) return String is
     (Left & Trim (Integer'Image(Right), Both));

begin
   Ada.Text_IO.Put_Line( 1 + "3a" );
   Ada.Text_IO.Put_Line("3a" + 1);
end bad_add;

C'est sûr que si tu écris une fonction permettant explicitement et seulement d'additionner des Int et des String, le programme va pouvoir additionner des Int et des String, encore heureux.

Certes mais je préfère dire ce que je veux faire que d'avoir un comportement inféré qui n'est pas forcément vrai… Bien qu'à partir du moment où on écrit '+', il semble, par convention, obligatoire que l'opération soit commutative.

Est ce vrai ou je me trompe lourdement ?

Globalement, c'est vrai mais ça ne corrige pas les erreurs d'algo qui déclenchent des exceptions ;)

Ceci dit, il y a aussi des cas où ça peut se planter alors que ça compilait très bien.
Typiquement, je pense à l'utilisation des bindings.
La majeure partie du temps, ce sont des bibliothèques C/C++ qui sont liées et du coup, elles introduisent l'utilisation de pointeurs venant directement du code C et là, c'est le drame ;)

Ada n'est pas la panacée mais c'est vrai qu'une fois que j'ai corrigé toutes les erreurs de compilation, je suis déjà plus sûr de mon coup :D

Enfin, cela ne représente que mon avis…

En même temps, tu fais pas d'effort ;)

with Ada.Text_IO; 
procedure bad_add is

   function "+" (Left : Integer;
                 Right : String ) return String is
     (Integer'Image (Left) & Right);       

begin
   Ada.Text_IO.Put_Line( 1 + "3a" );
end bad_add;

Il faut juste lui dire comment faire :)
Par contre, c'est pas commutatif, il faudrait aussi écrire ce que l'on fait dans l'autre sens.

De plus, le compilateur peut aussi vérifier que le style est correct (cf. les options de compilation).

D'ailleurs, c'est expliqué et justifié là

Ouais, ça balançait dur à l'époque :D

Ça nous rajeunit pas… Même si j'étais pas encore sur DLFP :)
Quelques mois plus tard, je me fendais d'une news de 7 lignes !!!!

Je trouve dommage de voir gitlab quitter Ceph pour NFS … NFS quoi ……..

Ils auraient au moins pu mettre du CodaFS, histoire de pouvoir répartir un peu la charge.

J'étais intéressé par docbook aussi mais les 3/4 des documentations sur lequelles je tombe au moins 10 ans :/

Certes mais elles sont toujours d'actualité puisque le fonctionnement global n'a pas changé.
On utilise toujours les mêmes technologies qui fonctionnent bien depuis plus de dix ans.
Ce n'est donc pas vraiment un problème.

Du coup, je me suis amusé à chercher rapidement un système pour stocker les fichiers DocBook et finalement avec Lux qui est sur une base SolR/Lucene, il y a moyen de faire des requêtes XQuery sur un corpus documentaire.

Intéressant tout ça ;)

même s'il n'a pas été écrit à la main, mais généré à partir d'un langage plus haut niveau

De mémoire, il s'agit de la Méthode B et l'outil qui était utilisé était l'Atelier B.
A l'époque, c'était Matra Transport International qui avait effectué une partie du boulot et du coup chez Matra Systèmes & Information où je bossais, des collègues l'avaient aussi utilisé pour un autre projet.
Je me souviens que cela ne semblait pas évident du tout :D

Ce type de technique se retrouve dans les solveurs SMT (Satisfiability modulo theories), comme par exemple l'outil alt-ergo (écrit en OCaml) utilisé, entre autre, par Spark dont a parlé Blackknight.

Spark utilise aussi les SMT Z3 et CVC4 écrits tout deux en C++.
Par contre, j'avoue que je n'y connais rien et que je ne fais qu'utiliser, mon niveau de math étant bien en-deça du pré-requis ;)

mais c'est vieux et plus personne n'a envie de faire de XML.

C'est moins vieux que le C++ ;)

Mais comme il a été dit plus haut, ces formats s'intéressent autant à la forme qu'au fond (voire plus ?).

Enfin, n'allez pas croire que je sois un fan du XML, loin s'en faut mais il s'agit là pour moi d'un des usages les plus intéressants.