**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.

Ada Lovelace (1815-1852)Lehen 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.

Programazio-lengoaia batzuen bilakaera
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:

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: 169

```
Beste 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 didaktikoak | Eragile monadikoak | Lehentasuna |
| --- | --- | --- |
| \*\*
\* / mod rem + - &
= /= < <= >= >
and or xor | abs 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
--------------

1. ↑   **(Ingelesez)** Levenez. (PDF) *Programazio-lengoaien bilakaera grafikoki.*  (Noiz kontsultatua: 2019-10-11).
2. ↑    Watt, David Anthony..  (1996). *ADA lengoaia eta metodologia.*  Servicio Editorial de la Universidad del País Vasco = Euskal Herriko Unibertsitateko Argitalpen Zerbitzua ISBN 8475858651. PMC 434213410. (Noiz kontsultatua: 2019-10-11).
3. ↑    Díaz de Ilarraza Sánchez,, Arantza; Sarasola, Kepa.  (1999). *Oinarrizko programazioa : ariketa bilduma.*  Udako Euskal Unibertsitatea ISBN 8484380025. PMC 52408737. (Noiz kontsultatua: 2019-10-11).
4. ↑    Diaz de Ilarraza, Arantza; Sarasola, Kepa.  (2012). «Ikastaroa: Konputagailuen programazioa» *ocw.ehu.eus* (UPV-EHU) (Noiz kontsultatua: 2019-12-17).
5. ↑    Iturralde, Asier.  (2016-03-07). «Emakumeok ere kodea ulertzen dugu» *Iametza Interaktiboa* (Noiz kontsultatua: 2019-12-17).
6. ↑   Irazustabarrena, Nagore.  (2013-09-22). *Ada Lovelace, lehen programatzailea.* .

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
-------------

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

|  |  |
| --- | --- |
| Autoritate kontrola | 
* **Wikimedia proiektuak**
* Wd Datuak: Q154755
* Commonscat Multimedia: Ada (programming language)

---

* **Identifikadoreak**
* BNE: XX531014
* GND: 4000430-2
* LCCN: sh85000774
* NKC: ph923516
* **Hiztegiak eta entziklopediak**
* Lur: 00046/eu\_a\_0468/a0468
* Britannica: url

 |

* Wd Datuak: Q154755
* Commonscat Multimedia: Ada (programming language)