Ada (programazio-lengoaia)

Ada helburu orokorreko programazio-lengoaia bat da, Pascal eta beste programazio-lengoaia batzuen hedapen moduan sortu zena. Ameriketako Estatu Batuetako Defentsa Sailaren segurtasun beharrak asetzeko sortua izan zen 1977 eta 1983 artean. Jean Ichbiah informatikari frantsesak gidatutako lantaldeak garatu zuen.

Ada objektuei orientatutako programazio-lengoaia da, goi-mailakoa, konkurrentea, Pascalen erraztasuna eta C++en moldagarritasuna dituena. Zehaztasun metodologiko handiko lengoaia da; helburua erroreak ekiditea izanik, zorroztasun handia eskatzen du, eta ona da errorea gertatzeak ondorio latzak ekar ditzakeen denbora errealeko sistemak inplementatzeko, trenen eta hegazkinen trafikoa kontrolatzekoak, adibidez. Adan idatzitako programak idazkera algoritmikotik gertu daudenez, ulerterrazak gertatzen dira. Ada nazioarteko estandar bihurtu zen (ANSI estandar 1983an eta ISO estandar 1987an).

Lengoaiari Ada izena jarri zioten Ada Lovelace (1815–1852) emakumea omentzeko. Izan ere, historiako lehen programatzailea izan zela esan ohi da.

 Historia 
Ameriketako Estatu Batuetako Defentsa Sailak 70eko hamarkadan martxan zituen proiektu informatikoen garapenean programazio-lengoaia ezberdin gehiegi erabiltzen zituela ikusi zuen. Hori saihesteko eta defentsa sailaren beharrak beteko zituen lengoaia aurkitzeko helburuarekin, 1975ean "High Order Language Working Group" edo "Goi-mailako lengoaietarako Lantaldea" sortu zuen. Lantalde horrek Steelman dokumentua idatzi zuen, eta bertan zehaztu zituen bilatzen ari zen helburu orokorreko eta goi-mailako lengoaiak bete beharko zituen eskakizunak. Ondoren, programazio-lengoaia asko aztertu zituen, baina ez zuen arrakastarik izan, ez baitzuen Steelman dokumentuan zehaztutako eskakizunak betetzen zituen programazio-lengoaia bat bera ere aurkitu.

Hori dela eta, programazio-lengoaia berri bat garatu behar zela erabaki zuen lantaldeak. Lengoaia berri baten diseinurako proposamenak jaso ahal izateko, lehiaketa publiko bat antolatu zuen. Lehiaketara aurkeztu ziren proposamenak koloreen bidez izendatuak izan ziren: Gorria (Intermetrics), Berdea (CII Honeywell Bull), Urdina (SofTEch) eta Horia (SRI International). Lehiaketaren bigarren fasera Gorria eta Berdea pasa ziren 1978an, eta azkenean, Berdea izan zen hautatua 1979an, CII Honeywell Bull (Compagnie Internationale pour l'informatique Honeywell-Bull) enpresako Jean Ichbiah-ek eta bere lantaldeak diseinatutakoa. Ada izena jarri zioten programazio-lengoaia berriari. Lantalde berberak aurretik garatutako LIS programazio-lengoaiaren eragin handia jaso zuen Adak. Lengoaia berriari buruzko lehenengo behin behineko eskuliburua 1979an argitaratu zen, eta 1980ko abenduaren 10ean onartu zen, Ada Lovelace-ren urtebetetze-egunean, hain zuzen ere.thumb|287x287px|Ada Lovelace (1815-1852)|alt=|ezkerreraLehen urteetan, Ada lengoaiak programatzaileen komunitatearen arreta bereganatu zuen. Lengoaiaren sortzaileek bakarrik ez, askok pentsatu zuten defentsa sailaren segurtasun beharretarako erabiltzeaz gain, helburu orokorreko programazio-lengoaia moduan ere hedakuntza handikoa bihurtuko zela. Ichbiah-ek berak publikoki esan zuen hamar urteren buruan bi programazio-lengoaia soilik geratuko zirela: Ada eta Lisp.

Hasierako Ada konpilatzaileak erdipurdi moldatzen ziren, konpilazio- eta exekuzio-fasean motelak ziren eta eskaintzen ziren tresnak artean primitiboak. Adaren lehenengo inplementazioa NYU Ada/Ed itzultzailea izan zen, 1983an. Konpainia komertzial asko Ada konpilatzaileak eta garapenerako tresnak eskaintzen hasi ziren, Alsys, Telesoft, DDC-I, Advanced Computer Techniques, Tartan Laboratories, TLD Systems, Verdix, esaterako. 80ko hamarkadaren bukaeran eta 90ekoaren hasieran, Ada konpilatzaileen errendimendua asko hobetu zen, baina lengoaiaren gaitasun guztien ustiapena zaila egiten zuten arazoak baziren oraindik. Denbora errealeko sistemetan lanean aritzen ziren programatzaileak, esaterako, ohituta zeuden atazen kudeaketarako eredu jakin batera, baina Adak eskaintzen zuena desberdina zen.

1991. urtean, Ameriketako Estatu Batuetako Defentsa Sailak bere software-proiektu guztietan Ada lengoaia erabiltzera behartu zuen (Ada mandatu edo agindua), nahiz eta maiz ematen ziren salbuespenak. 1997. urtean mandatu hori baliogabetua izan zen. Prozesua antzekoa izan zen NATO/OTAN-eko hainbat herrialdeetan, hala nola, Alemanian, Suedian eta Kanadan; aplikazio motaren arabera, Ada derrigorrez erabili beharreko edo gomendatutako programazio-lengoaia bihurtu zen (kontrol eta defentsa sistemetan, batez ere).

Gaur egun, aplikazio militarretan erabiltzeaz gain, segurtasun-maila altua eskatzen duten bestelako proiektuetan ere erabiltzen da. Software-akats batek ondorio latzak izan ditzakeen egoerak anitzak dira: aire-trafikoaren kontrola, Ariane 4 eta 5 moduko suziri komertzialak, sateliteak, trenbideak, banku-zerbitzuak, etab. Garraioan, adibidez, Frantziako abiadura handiko trenetan eta Paris, Londres, Hong Kong eta New York hirietako metroetan erabiltzen da.

 Ezaugarriak 
Hasiera batean, denbora errealeko konputazio-sistemetan erabiltzeko pentsatua izan zen Ada programazio-lengoaia. Gerora ordea, Intermetrics enpresako S.Tucker Taft-ek objektuei orientatutako programaziorako, finantza-sistemetarako eta zenbakizko-sistemetarako aproposak ziren hobekuntzak gehitu eta Ada 95 bertsioa argitaratu zen 1995ean.
Software-sistema handiak garatzeko diseinatuta dago Ada. Ada-paketeak eta espezifikazio-paketeak beren aldetik konpila daitezke, inplementaziorik gabe, bateragarritasuna egiaztatzeko. Horrela, diseinu-fasean bertan erroreak aurki daitezke, inplementazioarekin hasi baino lehen.

Konpilazio-faseko egiaztapen asko egiten ditu Adak, beste programazio-lengoaia batzuetan exekuzio-fasera arte aurkituko ez liratekeen erroreak hautematen laguntzeko. Gainera, exekuzio-fasean ere egiaztapenak egiten ditu, esleitu gabeko memoriarako atzipena ekiditeko, adibidez, buffer-gainezkatzeak identifikatzeko, etab. Egiaztatze horiek guztiak desaktiba daitezke exekuzio garaian eraginkortasuna irabazteko eta azkartzeko, baina normalean gehiegi irauten ez duen prozesu bat da.

Estandarizaziorako Nazioarteko Erakundearen (ISO) estandar gehienak ez bezala, Ada programazio-lengoaia definitzen duen eskuliburua ("Ada Reference Manual" edo "The Language Reference Manual" izenez ezagutzen dena) eduki askekoa da. Horregatik, ohiko erreferentzia da Ada konpilatzaileak inplementatzen dihardutenentzat eta, oro har, Ada programatzaileentzat. Eskuliburuaz gain, lengoaiaren diseinua eta lengoaiaren hainbat egitura azaltzen dituen oinarrizko dokumentu zabal bat existitzen da. Azken dokumentu hori ere oso erabilia da programatzaileen artean. Hori dela eta, lengoaia berrikusi zenean oinarrizko dokumentua ere eguneratua izan zen.

 Sintaxia 
Adaren sintaxiak, operazio sinpleak egiterako orduan, aukerak murrizten ditu, baina gomendagarriagoa izaten da ingelesezko giltza hitzak erabiltzea (adibidez, “or else” edo “and then”) sinboloak (adibidez, “||” edo “&&”) baino. Batuketa “+”, kenketa “-”, biderketa “*” edo zatiketa “/” bezalako eragile matematiko sinpleak erabiltzen ditu. Kode-blokeak “begin”, “declare” edota “end” bezalako hitzen artean ematen dira, hau da, If baldintzapeko bat ipini nahi badugu, komandoa idatzi ondoren “end if” idatzi beharko dugu agindua bukatutzat emateko.

Programan bertan iruzkin bat egin nahi badugu, bi gidoiren (--) atzetik idatzi beharko dugu, iruzkin hori lerroaren amaieran bukatuko da. Beraz, iruzkin bat idatzi nahi dugun lerro bakoitzaren hasieran jarri beharko ditugu bi gidoiak. Puntu eta koma (";") esaldiak amaitzeko da eta balio nulua edo eragiketarik gabeko ekintza null; da. Ezin da ; bakarra erabili aurretik ekintzarik ez badugu.

Bestalde, literal, identifikadore, hitz erreserbatu eta banatzaile bakoitzak lerro berean idatzita egon behar du, hau da, ezin da bi lerrotan banatu. Karaktere eta kate motako literalek izan ezik beste guztiek ezin dute zuriunerik izan. Gainera, lerro berean elkarren ondoan dauden identifikadore, hitz erreserbatu eta zenbakizko literalek zuriunez bananduta egon behar dute. Honela sinplifikatu genezake Ada-ren sintaxia modu soil batean, bai programen eratzea eta baita aldagaien erazagupena ere:
erdian|thumb|617x617px|ADA programen sintaxia (sinplifikatua)

 Programa adibideak 
PHau da programa sinple bat, lehenengo programa izaten den Kaixo mundua adibidea:-- "Kaixo mundua" esaldia idatziko dugu

with Ada.Text_IO;
procedure Kaixo is
begin
    Ada.Text_IO.Put_Line("Kaixo, mundua!"); 
end Kaixo;Formula bat kalkulatzea izaten da programen erabilera erraz bat, kasu oso adierazpide matematiko sinple, a kalkulatzen du programa honek, zenbaki baten karratua kalkulatzen du:-- 'Kalkulatu karratua' programa
-- Irakurri teklatutik zenbaki oso bat
-- Eta idatzi zenbaki horren karratua

-- Karaketere-kateak eta zenbaki osoak irakurri eta idazteko paketeak erabiliko direla abisatu:
with Ada.Text_IO;
with Ada.Integer_Text_IO;

procedure Kalkulatu_Karratua is
   N, Karratua: Integer;
begin
   -- Irakurri zenbakia
   Ada.Text_IO.Put ("Idatzi zenbaki oso bat eta sakatu <RETURN>:");
   Ada.Integer_Text_IO.Get  (N);-- Teklatuan idazten den zenbaki bat eta <Return> tekla
                                -- Aurrerantzean N aldagaiaren balioa zenbaki hori izango da
   -- Kalkulatu karratua
   Karratua := N ** 2;
   -- Idatzi emaitza
   Ada.Text_IO.Put  ("Irakurritako zenbakiaren karratua hau da: ");
   Ada.Integer_Text_IO.Put (Karratua);
 end Kalkulatu_Karratua;

--Exekuzioa:
-- Idatzi zenbaki oso bat eta sakatu <RETURN>:
-- 13
-- Irakurritako zenbakiaren karratua hau da: 169Beste programa bat, konplikatuxeagoa oraingoan, zenbaki oso baten zatitzaile guztiak idazten dituen programa bat:-- 'Idatzi zatitzaileak' programa
-- Irakurri teklatutik zenbaki oso bat
-- Eta idatzi zenbaki horren zatitzaile guztiak

-- Karaketere-kateak eta zenbaki osoak iraukrri eta idazteko paketeak erabiliko direla:
with Ada.Text_IO, Ada.Integer_Text_IO;
procedure Idatzi_Zatitzaileak is
   N, I, Hondarra : Integer; -- Hiru aldagai horietan zenbaki osoak gordeko dira
begin
   -- irakurri zenbakia
   Ada.Text_IO.Put ("Idatzi zenbaki oso bat eta sakatu <RETURN>:");
   Ada.Integer_Text_IO.Get (N);  -- Teklatuan idazten den zenbaki bat eta <Return> tekla
                                 -- Aurrerantzean N aldagaiaren balioa zenbaki hori izango da
   -- Kalkulatu eta idatzi zatitzaileak
   Ada.Text_IO.Put ("Hauek dira bere zatitzaileak: ");
   I:= 1;
   while I <= N loop       -- Honako aginduak egin behin eta berriro baldintza bete bitartean
      Hondarra := N mod I;
      if Hondarra = 0 then
 Ada.Integer_Text_IO.Put (I); -- I aldagaiak daukan balioa idatzi
      end if;
      I := I + 1 ;
   end loop;
end Idatzi_Zatitzaileak ;

-- Programaren exekuzio bat:
-- Idatzi zenbaki oso bat eta sakatu <RETURN>:27
-- Hauek dira bere zatitzaileak: 1 3 9 27

 Programatzeko garapen-plataformak eta liburutegiak 
Programazio-lengoaia guztiek dituzte programak idazten laguntzeko sortuak izan diren programazio-inguruneak, Adaz idaztean, laguntzeko ohikoena den softwaretako bat GNAT Programming Studio (GPS) da. Baina AdaGIDE bezalako beste hainbat programazio-ingurune ere erabiltzen dira. GNAT, software libreko konpilatzailea da. New York-eko unibertsitatean sortu zen, baina gaur egun, AdaCore da konpilatzaile hori mantentzen duena.

 Datu-motak 
Nahiz eta Ada ez dagoen pentsatuta aurrez definitutako aldagai mota batzuekin soilik funtzionatzeko, baditu horrelako mota batzuk, oinarrizkoak direnak. Hala ere, erabiltzaileak badu bere datu mota batzuk definitzeko aukera.

 Datu-mota eskalarrak edo bakunak 

 Aldagai boolearrak (Boolean): Bi balio baino ez ditu onartzen True (egiazkoa) eta False (faltsua).
 Zenbaki errealak (Float): Adibidez, 3.14159 edo -9.3.
 Zenbaki osoak (Integer): Adibidez, 15 edo -3.
 Zenbaki naturalak (Natural): Zenbaki oso positiboak eta zeroa. Adibidez, 0 edo 78.
 Karaktereak (Character): Adibidez, 'R' edo 'd'.
 Kateak (String): Karaktere-kateak. Adibidez, "Kaixo" edo "24 urte".

 Datu-mota konposatuak edo egituratuak 

 Taulak edo bektoreak (Array): Adibidez, B1=(1,2,3,4,5,6,7,8,9,10) edo B2=(a,b,c,d,e,f,g,h,i,j).
 Erregistroak (Record): Aldagai-mota ezberdinak gordetzen dituen fitxa bat bezala imajinatu dezakegu. Adibidez, izen bat (kate bat) eta zenbaki bat (erreal bat) dituen erregistro bat definitu genezake.

Bestalde, norberak aldagai-mota bat definitzeko type idazten hasi beharko du. Esaterako, hamar osagai dituzten bektoreak definitzeko Bektore izeneko mota bat sortzen da hemen, gelaxka bakoitzean boolear bat eta zenbaki erreal bat dituen erregistro bat daukana:type Gelaxka is record
   Badago: Boolean;
   Zenbakia: Float;
end record;

type Bektore is array (1 .. 10) of Gelaxka;

 Kalkulatzeko adierazpenak 

Adierazpen bat, balio bat kalkulatzeko arau edo formula bat da. Ada-ko adierazpenek eragigaiak, eragileak eta parentesiak edukitzen dituzte. Eragigaiak datuak beraiek dira eta horien arteko eragiketak eragileek egiten dituzte. Eragileen artean lehentasun ezberdinak dira, batzuek beste batzuk baino handiagoa dute. Esaterako, I+J/K adierazpena I+(J/K) adierazpenaren baliokidea da, zatiketak gehiketak baino lehentasun handiagoa duelako. Eragiketen lehentasuna gure modura moldatzeko, parentesiak erabiltzen dira, hau da, I/(K+J). Hauek dira Ada-ren eragileak lehentasunaren arabera mailakaturik, lehentasun handieneko eragileak goikoak direla:
Eragile didaktikoakEragile monadikoakLehentasuna**
*  /  mod  rem  +  -  &

  /=  <  <=  >   >

and   or   xorabs     not
+        -handiena

txikiena

 Agindu motak 
Oinarrizko aginduak esleipena (aldagai_izena := adierazpena), datu-irakurketak eta datu-idazketak (print) dira.

 Datu baten irakurketa 
Datuen irakurketa Get prozedurak erabiliz egiten da. Irakurri nahi den balioaren motaren arabera Get prozedura desberdinak erabili behar dira: Ada.Text_IO paketekoa karaktere bat edo karaktere-kate bat irakurtzeko (Ada,Text_IO.Get), Ada.Integer_Text_IO paketekoa zenbaki oso bat irakurtzeko (Ada.Integer_Text_IO.Get), edo Ada.Float_Text_IO paketekoa zenbaki erreal bat irakurtzeko (Ada.Float_Text_IO.Get).

 Datu baten idazketa 
Datuen idazketa Put prozedurak erabiliz egiten da. Irakurri nahi den balioaren motaren arabera Put prozedura desberdinak erabili behar dira: Ada.Text_IO paketekoa kkaraktere bat edo karaktere-kate bat idazteko (Ada,Text_IO.Put), Ada.Integer_Text_IO paketekoa karaktere bat edo karaktere-kate bat idazteko (Ada.Integer_Text_IO.Put), edo Ada.Float_Text_IO paketekoa zenbaki erreal bat idazteko (Ada.Float_Text_IO.Put).

 Espeipena 

Aldagai bati balio berri bat ezartzeko ":=" ikurra erabiltzen da (aldagai_izena := adierazpena). Asignazioa izenarekin ere ezaguna da. Horrekin, eskuinaldeko adierazpenaren balioa kalkulatzen da eta emaitza ikurraren ezkerreko aldagaiari esleituko diogu. Esaterako, Adina1 eta Adina2 aldagaien batura egingo dugu horiei balio bat esleitu ostean eta, ondoren batez bestekoa kalkulatuko dugu, zati 2 eginez: function Adinen_Batezbestekoa (Adina1, Adina2: in Natural) return Float is
   Emaitza: Float;
begin
   Adina1:=18;
   Adina2:=24;
   Emaitza:=(Adina1 + Adina2)/2;
   return Emaitza;
end Adinen_Batura;

 Kontrol-egiturak 
Ada programazio-lengoaia egituratua da, hau da, kontrol-aginduak egitura estandarren baitan ordenatzen dira. Programazioan kontrol­‑egitura oinarrizkoenak hautaketa eta errepikapena (edo iterazioa) dira.

 if egitura. baldintzapeko exekuzioa 

Hautaketa gauzatzeko, "if" agindua erabiliko dugu. Lehenengo, baldintza bat jarri beharko dugu eta baldintza betetzen bada, programak agindu bat gauzatuko du, betetzen ez bada beste bat. if <Baldintza> then
   <baldintza betetzen den kasuetan burutuko den agindua>;
else
   <baldintza betetzen ez den kasuetan burutuko den agindua>;
end if;

Hona hemen, if baldintzapekoarekin sortutako programa baten adibidea, pertsona bat jubilatua den ala ez esango digu programak. Pertsona baten adina 65 zenbakiarekin konparatuko du; pertsona hori jubilatua bada, emaitzak "True" balioa hartuko du, bestela "False". "Bestela" hori adierazteko, hau da, hasierako agindu hori betetzen ez denerako "else" komandoa erabili dezakegu, bertan agindu ezberdin bat betetzeko eskatuz.procedure Jubilatua (Adina: in Natural; Emaitza: out Boolean) is
begin
   if Adina > 65 then
      Emaitza := True;
   else 
      Emaitza := False;
   end if;
end Jubilatua;

 while egitura. exekuzio errepikatua 

Iterazioari dagokionez, bi agindu ditugu hau gauzatzeko: "while" eta "for". Lehenengoan, baldintza bat betetzen den bitartean, programa begizta batean sarturik egongo da, harik eta baldintza ez bete arte. Horregatik, begiztaren barruan halako batean baldintza ez betetzea eragingo duen aldaketaren bat egon behar da. Bigarrenean, aldiz, aurrez determinatutako tarte batean mantenduko da begizta. while <Baldintza> loop
   <Baldintza betetzen den bitartean burutuko den ekintza(k)>;
end loop;
--Baldintza betetzen ez denean, iteraziotik atera eta hona etorriko da programa>;

Adibidez, beheko programak N zenbakia baino handiagoa den 3 zenbakiaren lehenengo multiploa emango digu, "while" agindua erabiliz. procedure N_Baino_Txikiago_den_3ren_Multiplo_Handiena (N: in Integer; Z: out Integer ) is
   X, Y: Natural;
begin
   X := 1;
   Y := 3;
   while X * Y < N loop
      X := X + 1;
   end loop;
   Z := X * Y;
end Hiruren_Lehen_Multiploa;

 for egitura. exekuzio errepikatua 
Iterazio-prozesu batean hasieratik ezaguna bada aginduak zenbat aldiz errepikatu behar diren, egokiago izan daiteke for iterazio-egitura erabiltzea. Adibidez, idatzi lehen N zenbaki naturalen karratua: procedure Lehen_karratuak (N: in Integer) is
begin
    for I in 1..10 loop
      Ada.Integer_Text_IO.Put(I)
   end loop;Lehen_karratuak
end Lehen_karratuak;
Bigarren adibide honek "for" kontrol-egitura bat erabiliko du bektore bateko 10 osagai guztiak batzeko, non B'First bektoreko lehenengo osagaiaren indizea den (1 zenbakia), eta B'Last azkenarena (10):type Oso_Bektore is array (1 .. 10) of Integer;

function Batura (B: in Oso_Bektore) return Integer is
   Batura: Integer;
begin
   Batura := 0;
   for I in B'First .. B'Last loop
      Batura := Batura + B(I);
   end loop;
   return Batura;
end Batura;

 Azpiprogramak 
Azpiprogramak idazterako orduan, bi atal nagusi bereizi ditzakegu, funtzioak (function) eta prozedurak (procedure). Hauek, gure programa nagusia ordenatuagoa eta ulergarriagoa egiten laguntzen digute, programan zehar funtzio zehatz bat kalkulatu behar dugun bakoitzean aparte definitu den funtzioari egiten zaion dei sinple bat eginda amaitu baitezakegu.

 Funtzioak (function) 
Funtzioen ezaugarri nagusia honakoa da, erantzun bakarra itzuli dezaketela, hau da, funtzio baten barruan nahi beste eragiketa egiteko baimena eduki arren, emaitza gisa balio bakarra aterako dugu azpiprogramatik. Horrek, abantaila bat du, funtzioari erreferentzia zuzena egin diezaiokegu aldagai baten balio baten erantzun moduan jarri dezakegu.function Adina_2019an (Jaio_Urtea: in Natural) return Natural is
   Urteak: Natural;
begin
   Urteak := 2019 - Jaio_Urtea;
   return Urteak;
end Adina_2019an;
Pertsona baten jaiotze-urtearen baitan 2019an zuen adina kalkulatzen duen azpiprograma hori dugunez, ez daukagu zertan azpiprograman egindako eragiketak behin eta berriz idatzi beharrik, Adina_2019 funtzioari dei sinple bat egitea nahikoa da. type Oso_Bektore is array (1 .. 10) of Integer;

procedure Adinak_Kalkulatu (B1_Urteak, B2_Urteak: in Oso_Bektore; B1_Adinak, B2_Adinak: out Oso_Bektore) is
begin
   for I in 1..10 loop
      B1_Adinak(I) := Adina_2019an(B1_Urteak(I));
      B2_Adinak(I) := Adina_2019an(B2_Urteak(I));
   end loop;
end Adinak_Kalkulatu;

 Prozedurak (procedure) 
Prozeduren kasuan, ez dugu emaitza kopuru mugatu bat edukiko. Baina prozedura bati deitzeko modua ere ezberdina izango litzateke.  Adibidez, bi sarrera eta bi irteerako prozedura bat badaukagu, prozedura horri deitzeko orduan, parentesi artean, lehenengo bi datuentzako balioak jarri beharko ditugu eta gero bi irteera-parametroak jasotzeko bi aldagaien izenak.procedure Jaiourtetik_Adinera is
    Lesakakoak, Berakoak, Ad_Lesa; Ad_Bera: Oso_Bektore;
begin
   -- Irakurri bi bektoreen 10na balioak
   Irakurri_Balioak(Lesakakoak); -- prozedura honek 10 zenbaki oso irakurri eta bektorean jarriko ditu
   Irakurri_Balioak(Berakoak);

   -- Horien adinak kalkulatu Ad_Lesa eta Ad_Bera bektoreetan
   Adinak Kalkulatu (Lesakakoak, Berakoak, Ad_Lesa, Ad_Bera);

   -- Lortutako adinak inprimatu
   Idatzi (Ad_Lesa); -- prozedura honek bektoreko 10 zenbaki osoak idatziko ditu
   Idatzi (Ad_Bera);
end Jaiourtetik_Adinera;

 Erreferentziak 

 Ikus, gainera 
 Programazio-lengoaien arteko konparazioa
 Python (programazio-lengoaia)
 Pascal (programazio-lengoaia)
 ALGOL (programazio-lengoaia)
 C (programazio-lengoaia)
 Programazio
 Programazio-lengoaia
 Programazio-paradigma
 Programazio-lengoaien teoria
 Programazio-lengoaia konpilatua

 Kanpo estekak 
  Ada-Europe Erakundea
  Ada Programming tutorialak Wikibooks-en.
  http://d.feneuille.free.fr/enseignerada.htm (Hainbat material frantzesez)
  Adan programatzen ikasteko testuliburu elektronikoak
  Adan estilo ulergarriarekin programatzeko liburua (Ada Style Guide)
  ICPC Adan programatzeko ikasleentzako lehiaketa
  Programazio-lengoaien bilakaera historikoa grafikoki, , Levenez
 «Ikastaroa: Konputagailuen programazioa [2012/05 [eus]»] ocw.ehu.eus

Kategoria:Informatika
Kategoria:Programazio lengoaiak