Blackknight a écrit 1237 commentaires

D'après ça et ça, pour Rosetta, c'est même plus court que ça :)

D'ailleurs, l'évolution que l'on peut voir dans ce vieux doc de 2010 est assez intéressante et à des lieux de ce que l'on pouvait utiliser au sol même en 2005.
8Mo de RAM, qui est capable de coder là-dessus aujourd'hui :)

Voilà, j'ai reçu la grille tarifaire de participation à la normalisation pour 2015…
Bon, il vaut mieux avoir une boîte que ça impacte quand on voit le prix :)
Ceci dit, ça coûte pas beaucoup plus cher qu'une participation à certaines conférences.

En dehors des prix et de l'équilibre financier, le principal argument pour redémarrer la commission serait d'avoir des experts représentatifs :

• un intégrateur/éditeur utilisant Ada ou une SSII développant des applications en Ada ou un compilateur Ada
• un utilisateur majeur de telles applications
• quelques SSII éditrices de code Ada
• des chercheurs et universitaires (qui sont exonérés de cotisation)

Voilà, si vous connaissez du monde que cela peut intéresser…

Nan, on parle de vrais développeurs, pas d'admin sys qui se mettent à coder (voir ça) :D

Ada n'a pas le typage incluant la durée de vie comme Rust (enfin je crois).

Peut-être parce qu'au final, on utilise assez peu les pointeurs et que même dans ce cas, de toutes façons, c'est très contrôlé (cf. à partir de la page 36 dans ce document).
Après, pour une variable "standard", on applique les règles standard de portée (cf. page 11 du même document).

Ceci dit, je n'ai certainement pas bien compris le concept de durée de vie dans Rust :D

Pas beaucoup de tutos sur internet pour ceux qui veulent approfondir.

Que cherches-tu comme tutos pour approfondir ?
On sait jamais, j'ai peut-être des liens pour toi :)

Il me semble que Ada ne possède ni GC ni borrow checker

Certes mais vu qu'on n'utilise pas forcément beaucoup les pointeurs et que quand on les utilise, c'est très contrôlé par le compilateur, c'est pas aussi grave que ça.
Après, on peut faire deux ou trois trucs si vraiment on veut se faciliter la vie.
Perso, j'en ai pas encore eu besoin :D

Les seuls exemples connu sont dans le ferroviaire.

J'en connais un autre dans le nucléaire mais on ne trouve rien dessus.

Surtout que qualifier du C++ est super complexe si on utilise des objets

Et surtout, ce n'est normalement pas qualifiable suivant la DO-178B, ce qui a conduit il y a quelques années à l'écriture des documents OOTiA et à l'écriture de la DO-178C.
Mais bon, comme là, c'est du militaire, c'était pas grave :D

il aurait mieux fait d'utiliser SCADE

ou la méthode B :)

Tout à fait d'accord, surtout quand on voit dans les slides les différentes classes de bugs qui sont censés être évités.
Je vais pas tous les passer en revue mais franchement :
- page 9 : réécrire une bibliothèque pour faire des allocateurs sur pool de mémoire, ça me semble pas être un gain de temps… Surtout avec l'apparition des storage pools dans le norme suivante du précédent langage
- page 21 : Ils savaient que leur chaîne de compilation précédente faisait directement ces vérifications ?

Tout ça, pour au final, pour finir avec des retards colossaux et un budget largement explosé (cf. Wikipedia)

Perso, je te conseillerais d'abord de te familiariser avec le langage.
Ensuite, pour la programmation système, j'ai retrouvé deux trucs qui pourront t'intéresser :
- La page sur la programmation Posix
- des exemples Posix

Pour la première page, il y a quelques liens morts mais le but était de te montrer l'existence de Florist qui devrait normalement être inclus dans ta distribution ou qui, au pire, est téléchargeable facilement chez Adacore.

Le problème c'est qu'on trouve trop peu de docs sur ce langage

Rhoooo ! Allez, je fais comme d'habitude, je vais donner des liens :
- Ada distilled qui ne traite pas de l'Ada 2012 bien qu'il y en ai un peu dedans
- Le wikibook
- Adacore University
- Les normes qui, une fois que l'on a compris la syntaxe, permettent de répondre aux questions que l'on peut être amenés à se poser au fil de l'eau
- Un tuto en Ada95 à l'ENST qui est toujours d'actualité puisque le langage n'a pas subi de grands changements syntaxiques
- Les cours de Daniel Feneuille donnés à l'IUT d'Aix

Enfin, en source d'information, rien ne vaut les newsgroups français fr.comp.lang.ada et anglais comp.lang.ada où les responsables de la norme et les pros prendront toujours le temps de te répondre.

Ouais, et je peux te dire que le jour où on fera de la fusion, les Bretons et nous, on sera les rois !!!
Surtout quand je vois ce qu'on s'est pris sur la tronche ce week-end :D

Toutes ces histoires de layout mémoire, ça m'a rappelé une présentation que j'avais trouvée il y a quelques temps sur le Net.
Et chance !! Je l'ai retrouvée ici.
Attention, c'est technique mais comme c'est toi qui as commencé… :D

Et pour définir le succès, c'est juste le fait que le navire ne l'a pas abattu ?

Ben disons que l'accrocher au radar, ça suffit généralement à montrer que l'on est en position de faire feu et que le pilote ferait mieux d'aller voir plus loin.
Bien sûr, ça ne l'empêche pas de recommencer mais c'est un poil osé.
Alors oui, 12 passages consécutifs, c'est pas mal.

Tu peux donc affirmer avec certitude que 100% des gens qui combattent du coté "pro-russe" sont russes ? Il n'existe AUCUN ukrainien pro-russe ?

Tout autant qu'il n'y avait pas 100% d'Allemands dans les Sudètes. Il n'y a pas besoin de ça pour que ça dérive.

Et puis, il se vend tellement bien que le groupe Airbus compte "réduire" le nombre de postes qui lui sont dédiés (cf. là et là aussi)… Entre autres.

Sur la Wii, la manette est un pointeur infrarouge donc ça reste un dispositif de pointage. Mais bon, c'est pas forcément facile quand même :)

ADA m'intéresse, mais la dernière fois que j'ai essayé de m'y mettre, je n'ai pas réussi à trouver de doc satisfaisante pour mettre le pied dedans.

Rhoo, y a plein de trucs !!
- le wikibook
- un document pour programmeurs C++/Java
- un cours en français que je viens de trouver mais qui fait entièrement sous Windows
- Ada distilled
- Les cours de Daniel Feneuille en français mais qui ne couvrent pas les dernières versions
- l'université Adacore

Nan, franchement, tu fais pas d'efforts ;)

• écriture de drivers et donc dans des registres mémoires

Certes mais pour l'instant, il n'y a pas énormément d'OS en Ada :)

• parseur de fichier binaire

Exact et dans ce cas, il y aura l'endianness à gérer aussi mais il y a déjà une solution

• parseur de message réseau.

Exact aussi mais là, ce ne sont pas les solutions existantes qui manquent entre PolyORB, YAMI4 ou de simples sockets comme dans l'exemple de Wikibooks.
Sachant qu'en plus, la norme définit dans l'annexe E comment doivent être faits les systèmes distribués, il faut vraiment un besoin spécifique pour ré-écrire un protocole réseau.

Attention, c'est quand même très particulier comme cas, la plupart du temps, ça ne sert pas à grand chose et il vaut mieux laisser faire le compilateur.
Mais en même temps, tu as certains cas où tu ne peux pas l'éviter.
Typiquement, le code que j'ai fourni en lien permet d'écrire dans la GDT dont la représentation en mémoire est spécifiée par Intel. Du coup, tu es coincé.
Pour ce qui est de mélanger un peu tout, je préfère avoir les clauses de représentation sous les yeux dans le même langage que celui de programmation et me dire que dans ce cas, cela a une importance plutôt que d'avoir un n-ième fichier pour décrire tout ça.

Bon, j'ai refait un test mais bon, c'est pas facile, le compilo laisse rien passer :D

procedure Representation is
   type Color is range 0 .. 255;
   type CoordX is range 0 .. 800;
   type CoordY is range 0 .. 600;

   type Pixel is record
      X : CoordX := 0;
      Y : CoordY := 0;
      R : Color := 0;
      G : Color := 0;
      B : Color := 0;
   end record;

   for Pixel use
      record
--   R at 0 range 0 .. 1;
--   G at 0 range 0 .. 1;
     B at 0 range 1 .. 9;
     X at 1 range 0 .. 16;
     Y at 2 range 0 .. 16;
      end record;

   for Pixel'Size use 32;

begin
   null;
end Representation;

Si on compile tel quel, on obtient :

representation.adb:18:10: component "B" overlaps "X" at line 19
representation.adb:20:10: component "Y" overlaps "X" at line 19
representation.adb:20:28: bit number out of range of specified size

Si on décommente les clauses de représentation pour R et G, on obtient le message d'erreur :

representation.adb:19:10: size for "CoordX" too small, minimum allowed is 10
representation.adb:20:10: size for "CoordY" too small, minimum allowed is 10

Donc c'est pas facile de faire n'importe quoi :D

On dirait que non car dans l'exemple que tu as mis en lien, il y a des sortes d'alias sur certains champs :

En fait, si mais dans mon exemple, il s'agit d'une sorte de structure paramétrée et donc les deux champs ne peuvent exister en même temps. Du coup, ils ne se chevauchent jamais.

• avec les opérateurs, on sait exactement ce qu'on fait ;

En assembleur aussi ;)

• avec les champs de bits C, incertitude sur le padding ?
• avec les champs de bits C, incertitude sur l'ordre des champs, des bits, des octets, des mots ?
• avec les champs de bits C, incertitude sur la taille du type crée ?

Là, j'avoue que je ne sais pas non plus.

Je ne sais pas si en Ada (c'est bien de l'Ada, tes exemples ?) on a plus de certitudes.

Ben non, justement. Je n'avais pas mis la fin de l'exemple mais on a ça

for Program_Status_Word'Size use 8*System.Storage_Unit;
for Program_Status_Word'Alignment use 8;

Avec ça, tu en connais encore plus.
Mais pour l'ordre des champs, c'est déjà précisé dans l'exemple précédent qui spécifie les tailles ET les emplacements. Par contre, quand tu as besoin d'un champ inutilisé, tu es obligé de le spécifier aussi.
Pour la taille du type, ça peut être précisé dans le type utilisé avec l'attribut Size.
Du coup, ça permet des trucs comme ça. Bon, c'est lourd mais au moins, tout est précisé ;)
D'ailleurs, tu trouveras à peu près tous les exemples de clauses de représentation.

Après pour les opérations sur ensemble de bits, je préfère aussi ça :

type Day_Of_Month is range 1 .. 31;            
type Month_Array is array (Day_Of_Month) of Boolean;

X : Month_Array := Function_1;
Y : Month_Array := Function_2;
Z : Month_Array := X and Y;

qui s'utilisent aussi avec or et xor

Exact mais personnellement, j'en ai pas vu des masses dans le code C qui m'est passé sous les yeux.
L'habitude est plus dans la manipulation des opérateurs de décalage me semble-t-il.