UNIVERSITATEA “DANUBIUS” din GALAȚI

FACULTATEA DE ŞTIINŢE ECONOMICE

SPECIALIZAREA: CONTABILITATE ȘI INFORMATICĂ DE GESTIUNE

Programarea calculatoarelor
Note de curs

PARTEA I

Lect.univ.dr. Laura Danilescu

Galaţi

2017
 CUPRINS
CUPRINS ................................................................................................................ 1
CAP 1. INTRODUCERE IN STUDIUL LIMBAJELOR DE PROGRAMARE .... 2
1.1. Noţiuni generale privind limbajele de programare ......................................................... 2
1.2. Clasificarea limbajelor de programare ............................................................................ 5
1.3. Structurarea şi organizarea datelor. Tipuri de date utilizate în limbajele de programare
........................................................................................................................................................... 13
1.4. Caracterizarea principalelor limbaje de programare .................................................... 18
1.5. Criterii de selecţie a limbajelor de programare ............................................................. 21

CAP 2. METODE ŞI TEHNICI DE PROGRAMARE ......................................... 23

2.1. Evoluţia metodelor de programare ............................................................................... 23
2.2. Metode şi tehnici de programare .................................................................................. 23
2.2.1. Metoda programării clasice .................................................................................... 23
2.2.2. Metoda programării modulare ............................................................................... 23
2.2.3. Metoda programării structurate ............................................................................ 24
2.2.4. Metoda programării pe obiecte ............................................................................. 25
2.2.5. Metoda programării vizuale ................................................................................... 26
2.3. Elaborarea produselor-program. Activităţi specifice elaborării produselor- program . 26
2.3.1. Modelul în cascadă ................................................................................................. 26
2.3.2. Modelul în V ........................................................................................................... 28
2.3.2. Activităţi specifice elaborării produselor-program ................................................ 29
2.3.3. Modelul evolutiv ..................................................................................................... 33
2.3.4. Modelul în spirală ................................................................................................... 33
2.3.5. Modelul liniar.......................................................................................................... 34
2.3.6. Modelul RAD (Rapid Application Development) .................................................... 35

-1-
 CAP 1. INTRODUCERE IN STUDIUL
LIMBAJELOR DE PROGRAMARE
1.1 Noţiuni generale privind limbajele de programare
1.2 Clasificarea limbajelor de programare
1.3. Structurarea şi organizarea datelor. Tipuri de date utilizate în limbajele de
programare
1.4. Caracterizarea principalelor limbaje de programare
1.5. Criterii de selecţie a limbajelor de programare.

1.1. Noţiuni generale privind limbajele de

programare
Programarea este procesul de definire a instrucţiunilor pe care calculatorul le va
executa în scopul rezolvării unei probleme. Aceasta se realizează prin organizarea şi
comunicarea ideilor într-o formă inteligibilă pentru calculator, iar rezultatul este programul.
Programarea reprezintǎ totalitatea activităţilor de concepere, dezvoltare şi întreţinere
a programelor.

În sens clasic, un program este un ansamblu de instrucţiuni şi/sau comenzi scrise cu

ajutorul unui limbaj de programare, care descriu prelucrările de date pe care trebuie să le
execute calculatorul în scopul rezolvării unei probleme.
Instrucţiunile şi/sau comenzile reprezintă informaţii codificate prin care se transmite
calculatorului acţiunea ce urmează a fi executată. La rândul lor acestea pot fi structurate în două
mari grupe:

• instrucțiuni de prelucrare prin care se realizează introducerea/extragerea datelor

în/din sistem, efectuarea operaţiunilor de calcul, efectuarea transferului de date între diferite
zone de memorie etc.;

•instrucțiuni de organizare (de structurare internă a programului) ce asigură

codificarea structurilor de control şi de apelare sau de salt la alte programe.
În programarea obiectuală, un program este un ansamblu de entităţi informatice,
numite obiecte, care interacţionează şi comunică prin mesaje.

-2-
 Programul scris de om, se numeşte program-sursă. Pentru a putea fi înţeles de
calculator, el trebuie adus în format executabil. Obţinerea formatului executabil se realizează
prin traducere, cu ajutorul unor programe speciale, care pot fi interpretoare sau compilatoare.
Industrializarea activităţii de programare a determinat apariţia conceptului de ingineria
programării (software engineering), un domeniu care se ocupă cu identificarea celor mai
adecvate soluţii, metode, procedee şi instrumente care să conducă, în condiţii optime de
productivitate şi eficienţă, la elaborarea de produse-program performante. În anii ’80 s-a făcut
trecerea la ingineria programării asistate de calculator (CASE- Computer Aided Software
Engineering) Primele produse CASE tratau faze de elaborare a produselor-program (faza de
analiză - cum este Visual Analyst sau faza de generare a programelor). După 1985 au apărut
produse CASE integrate, ca EXCELERATOR sau MANTIS.
Principalele componente ale unui produs CASE sunt: modele pentru structurarea datelor
şi crearea dicţionarului de date; module specifice de proiectare a diagramelor şi fluxurilor,
interfeţe cu utilizatorul, interfeţe de reţea.
Produsele CASE sunt de 2 tipuri:

 FRONT-END destinate automatizării activităţii de analiză şi proiectare, conducând

la obţinerea de diagrame, biblioteci de date, formulare de ecran etc.
 BACK-END destinate generării automate a programelor într-un limbaj foarte înalt,
COBOL, ADA, limbajele din generaţia a-4-a.
CASE-ul integrat reprezintă o combinaţie a primelor două care are ca mecanism de
integrare, un dicţionar de date extins, numit bibliotecă centrală cu rolul de păstrare, administrare
şi utilizare partajată a informaţiilor.
Produsele CASE asigură o gamă variată de activităţi:
• întocmirea şi listarea diagramelor folosind Generatoarele de machete şi diagrame;
• proiectarea machetelor de ecran şi a rapoartelor folosind Generatoarele de formate,
de ecran şi de rapoarte;
• schimbul de informaţii între depozitul central şi celelalte instrumente de dezvoltare
prin intermediul componentelor de import/export;
• verificarea şi analiza specificaţiilor aplicaţiilor prin Programe de analiză;
• scrierea automată a programelor pe baza specificaţiilor prin Generatoare de cod;
• redocumentarea, restructurarea, redezvoltarea sistemelor deja implementate prin
Programe de întreţinere şi dezvoltare.
Pe baza standardelor existente, compania ORACLE şi-a definit propria metodologie
CASE. Aceasta acoperă toate fazele din dezvoltarea programelor (analiză, proiectare,
implementare, testare şi distribuţie).

-3-
 Clasic, un limbaj de programare este definit ca un limbaj artificial creat de om care
serveşte la exprimarea, sub formă de instrucţiuni executabile de către calculator, a algoritmului
de rezolvare a unei probleme.
Algoritmul indică modul de prelucrare a datelor iniţiale şi modificarea lor pas cu pas
până la obţinerea rezultatelor finale. Natura datelor, organizarea lor şi relaţiile dintre ele trebuie
precizate prin program. Limbajele de programare oferă facilităţi corespunzătoare de descriere.
Din punct de vedere funcţional, un limbaj de programare reprezintă o notaţie formală
pentru descrierea proceselor de calcul, într-un mod apropiat gândirii umane şi cu un grad mare
de independenţă faţă de calculator.

Definiţia modernă consideră limbajul de programare un instrument de dialog om-

calculator, care este înţeles de ambii participanţi la dialog.
Un limbaj de programare se bazează pe un set de simboluri elementare (de obicei, toate
literele, operatorii aritmetici + - * /, alte caractere speciale), numit alfabetul limbajului.
Aceste simboluri sunt asamblate în cuvinte-cheie sau expresii care formează
vocabularul limbajului (instrucţiuni, comenzi, funcţii, variabile, constante). Ansamblul
regulilor prin care se construiesc instrucţiunile constituie gramatica limbajului. Exprimarea
regulilor gramaticale din limbajul de programare se realizează cu ajutorul unui metalimbaj (un
limbaj ce foloseşte semne convenţionale pentru descrierea regulilor gramaticii limbajului de
programare). Elementele de metalimbaj apar în documentaţiile care însoţesc produsele
program.
Exemple:
 cuvinte rezervate – sunt scrise cu majuscule, sunt specifice unui limbaj şi trebuie
folosite exact în aceeaşi formă. Ex.: comenzi, clauze şi funcţii în FoxPro - LIST,
CREATE, FOR, IIF() etc.;
 cuvinte utilizator - sunt scrise cu minuscule şi reprezintă construcţii utilizator. Ex.:
codmat, matricol, fismat etc.;
 < > - încadrează construcţiile utilizator. Ex. <nume_tabelă>, <nume_câmp>;
 [ ] - încadrează construcţiile opţionale (programatorul decide dacă acestea vor fi sau
nu folosite) Ex.LIST [FIELDS <lista_câmpuri>] etc.;
 { } sau | - sau exclusiv din elementele prezente se va alege unul singur. Ex. TO
PRINT| TO FILE, ON|OFF, {>=|<+} etc.;
 … - construcţia precedentă se poate repeta de un număr arbitrar de ori. Ex.
<nume_câmp1>…
În practică există şi încercări de standardizare a metalimbajelor, cele mai cunoscute fiind
BNF (Backus Naur Form) şi extensia acestuia EBNF(Extended BNF).

-4-
 Mediile de programare permit automatizarea procesului de construire şi testare a
programelor. În componenţa lor intră un editor de texte, un compilator, un editor de legături,
un depanator.

1.2. Clasificarea limbajelor de programare

J.E. Sammet a realizat într-o lucrare, o clasificare care include următoarele clase de
limbaje: procedurale, neprocedurale, orientate pe problemă şi speciale. Încadrarea unui limbaj
de programare anume într-o clasă este uneori dificil de realizat.
Limbajele procedurale (numite şi limbaje de nivel înalt) sunt utilizate pentru a descrie
un algoritm de rezolvare a unei probleme. Se descriu complet operaţiunile care se execută şi
ordinea de execuţie a acestora. Ele răspund la întrebarea CUM?. Exemple: COBOL,
FORTRAN, BASIC, ALGOL, PASCAL.
Limbajele neprocedurale (numite şi limbaje de nivel foarte înalt) oferă soluţia de
rezolvare a unei probleme, dar fără a da detalii asupra modului concret de rezolvare. Ele răspund
la întrebarea CE?. Exemplu: limbajele din SGBD, PROLOG, LISP.
Limbajele speciale descriu funcţii specifice ale produselor-program. De exemplu,
procesorul Word are inclus un limbaj de scriere a macrourilor.
Limbajele orientate pe problemă deservesc domenii restrânse de activitate. Astfel de
limbaje sunt limbajele de simulare, ca GPSS (General Purpose System Simulation) care este
conceput pentru descrierea şi rezolvarea problemelor de simulare.

Evoluţia limbajelor de programare a fost marcată de anumite tendințe:

 Prima este trecerea de la programele specializate pe un tip de probleme, elaborate de
programatori profesionişti la pachetele de software cu destinaţii diverse adaptate la
nivelul utilizatorilor finali neinformaticieni. Această tendinţă s-a amplificat odată cu
apariţia microcalculatoarelor.
 A doua tendinţă este îndepărtarea de (1) limbajele de programare tehnice, foarte dificil
de utilizat, specifice începuturilor programării (limbaje de generaţia I şi a II-a) şi de (2)
limbajele procedurale. Tendinţa este către limbajele neprocedurale şi limbajele naturale,
apropiate de limbajul uman, tendinţă care s-a accentuat odată cu apariţia celei de-a IV-
a generaţii de limbaje. Ea continuă prin îmbunătăţirea interfeţelor grafice şi dezvoltarea
inteligenţei artificiale, care produce aşteptatele limbaje naturale. Este vorba de cea de-a
V-a generaţie de limbaje de programare, reprezentată de pachete de programe asistate
de experţi. Şi în pachetele de programe actuale sunt incorporate unele module de ajutor
sau module de sprijin inteligente (wizard) care oferă utilizatorului asistenţă în rezolvarea
unor probleme (realizarea unui grafic sau tabel).

-5-
 Generaţiile de limbaje care pot fi identificate sunt:
Generaţia I - limbajele în cod maşină, în care toate instrucţiunile sunt numerice (şiruri
de 0 şi 1), fiind redactate plecând de la un cod binar propriu fiecărei maşini (calculator).
Utilizatorul trebuia să ţină minte toate codurile numerice, ceea ce la calculatoarele moderne ar
însemna mii de coduri şi adresele de memorie utilizate, astfel că productivitatea este foarte
redusă. Programele scrise în limbaj maşinǎ puteau fi executate numai pe calculatorul pentru
care au fost elaborate (nu erau portabile). Principalele deficienţe ale acestor limbaje sunt legate
de dificultăţile de corectare a programelor, aceste programe fiind mari, iar erorile greu de
identificat.
Generaţia a II-a - limbajele de asamblare, care înlocuiesc codurile numerice cu cele
mnemonice, adresele fiind alocate de sistem. Utilizarea acestor limbaje presupune existenţa
unor programe speciale numite asambloare care să traducă instrucţiunile în limbaj cod maşină.
Instrucţiunile se traduc 1 la 1, adică fiecărei instrucţiuni în limbaj de asamblare îi corespunde o
instrucţiune în cod maşină. Operaţia poartă numele de asamblare, iar rezultatul se numeşte
program obiect executabil. Pentru a reprezenta codurile de operaţii şi poziţiile din memorie se
folosesc simboluri, motiv pentru care aceste limbaje se mai numesc şi limbaje simbolice. Câteva
limbaje din această categorie sunt: ASSIRIS, ASSEMBLER, MAGIRIS, MASM (Microsoft
Asambler). Reamintim că orice microcalculator are un limbaj de asamblare specific, după tipul
microprocesorului (Intel 80486, PENTIUM PRO).
Execuția unui program sursă scris într-un limbaj de asmblare are loc pe parcursul a două
etape: asamblarea și execuția propriu-zisă. Schematic, se obține următoarea reprezentare:

Figura 1. Tratarea programelor în limbaje de asamblare

-6-
 Limbajele de asamblare permit să se utilizeze abrevieri alfabetice (mnemonice) care
sunt mai uşor de memorat decât adresele numerice de date (Ex. ADD - adunare, DIV –
împărţire). Ele simplifică enorm programarea, deoarece elimină memorarea poziţiilor din
memorie pentru date şi instrucţiuni. Totodată, limbajul de asamblare rămâne un limbaj orientat
maşină deoarece instrucţiunile în limbaj de asamblare corespund instrucţiunilor în limbaj
maşină conform modelului de calculator utilizat. O singură instrucţiune în limbaj de asamblare
corespunde unei singure instrucţiuni în limbaj maşină şi deci este nevoie de acelaşi număr de
instrucţiuni în ambele cazuri.
Aceste limbaje sunt încă utilizate pentru programarea unor părţi mici ale software-ului
de sistem, datorită vitezei de execuţie ridicate, chiar dacă limbajele evoluate solicită un efort de
programare mai mic.
Exemplu: Să se calculeze media aritmetică a trei numere M=(X+Y+Z)/3
LDA X încarcă X în registrul A
ADD Y adună Y la conţinutul registrului A
ADD Z adună Z la conţinutul registrului A
DIV 3 împarte rezultatul la 3
STA B stochează rezultatul final în B
Limbajele în cod maşină şi de asamblare sunt limbaje de nivel redus.
Generaţia a III-a - limbajele de nivel înalt sau evoluate, care au dominat peste 30 de
ani piaţa informaticii. Reprezentative sunt: FORTRAN pentru ingineri şi matematicieni şi
COBOL pentru mediul economic. Caracteristica lor principală este proceduralitatea (adică
urmăresc pas cu pas procedura de rezolvare a unei probleme). Au fost create mii de astfel de
limbaje, unele având destinaţii precise (FORTRAN şi ALGOL sunt destinate calculelor
ştiinţifice, COBOL este destinat aplicaţiilor economice, SIMULA fiind un limbaj de simulare,
etc.), iar altele având utilizare largă (BASIC, PASCAL, C). Şi instrucţiunile scrise în aceste
limbaje trebuie traduse în cod maşină; pentru aceasta se utilizează două categorii de
translatoare:
 compilatoare - sunt translatoare care citesc tot programul în limbajul în care este scris
(în cod sursă) şi apoi îl traduc în cod maşină (sunt utilizate pentru COBOL,
FORTRAN);
 interpretoare - sunt translatoare care citesc pe rând fiecare instrucţiune din programul
sursă, o traduc şi o execută (sunt utilizate pentru BASIC, PASCAL).
Prin urmare programele sursă redactate în limbaje evoluate sunt supuse unui proces de
“tratare” desfăşurat pe trei faze:
 compilarea /interpretarea;
 editarea de legături;

-7-
  execuţia propriu-zisă.
Schematic se obţine următoarea reprezentare:

Figura 2. Tratarea programelor în limbaje evoluate

Avantaje: sunt mai uşor de învăţat şi utilizat decât limbajele de asamblare; sunt portabile
(pot fi utilizate şi pe un alt calculator); pot fi oricând modificate şi actualizate.
Câştigul de productivitate este remarcabil: o linie de program scris cu un limbaj de
generaţia a III-a reprezintă mai mult de 100 de linii de instrucţiuni în cod-maşină. Dezavantaje:
au reguli şi sintaxe rigide şi deloc uşor de învăţat pentru un utilizator nespecialist; solicită mult
timp pentru translatare în cod maşină (descoperirea unei erori înseamnă nu numai corectarea ei,
ci şi traducerea din nou în cod maşină).

-8-
 Exemplu: Folosind limbaje din generaţia a 3-a să se codifice X = Y – Z
În BASIC LET X = Y - Z
ÎN PASCAL X : = Y-Z
Aceste limbaje se caracterizează prin proceduralitate, adică evenimentele se succed
secvenţial, unul după altul. Există în literatura de specialitate o împărţire a LG3 în generaţii. Cu
menţiunea că există şi excepţii, iată care sunt acestea:
Generaţia I se încadrează în intervalul 1954 – 1958. Comenzile erau bazate pe expresii
matematice. Reprezentanţi: FORTRAN I, ALGOL 58;
Generaţia a II-a acoperă intervalul 1959 – 1961 (FORTRAN II, ALGOL 60, COBOL).
Apar subrutinele programate, se definesc structurile de date şi lucrul cu fişierele de date;
Generaţia a III-a cuprinde intervalul 1962 - 1970 şi este reprezentată de limbaje de
programare structurate (ALGOL 68, PL/1, PASCAL, BASIC, COBOL strucutrat). Se impun
principiile programării structurate. Realizarea unui program începe cu definirea principalilor
paşi şi continuă în această manieră până când întregul program este dezvoltat. Ideea structurării
a apărut datorită problemelor ce apăreau la dezvoltarea de aplicaţii complexe, cea mai relevantă
fiind lipsa viziunii de ansamblu asupra programului. Deşi primele concepte ale programării
structurate au apărut încă de la începutul anilor ’60, implementarea lor s-a făcut în timp, în
sprijinul acesteia creându-se metodologiile care ofereau direcţiile de urmat în proiectarea de
aplicaţii, pas-cu-pas.
După anii ’70 au apărut tot mai multe tipuri de LP, astfel ca încadrarea lor în generaţii
a devenit tot mai dificilă. Programarea structurată s-a generalizat. În domeniul aplicaţiilor
economice, COBOL deţinea 80% din totalul acestora.
După impunerea metodologiilor standardizate, mulţi programatori au început să
utilizeze pentru documentarea aplicaţiilor lor diagramele. Mai apoi, apariţia PC-urilor şi a
interfeţelor grafice la începutul anilor ’80 a favorizat crearea de instrumente grafice la dispoziţia
analiştilor pentru crearea de diagrame structurate.
Pe de altă parte, au apărut şi instrumente prin care sunt generate automat programele, pe
baza diagramelor structurate definite. Fiecare simbol grafic al unei diagrame reprezintă “un
cuvânt” care poate fi tradus în una sau mai multe instrucţiuni într-un limbaj procedural (de
regulă, COBOL).
Fiecare din instrumentele definite mai sus se încadrează şi reprezintă un produs CASE
(Computer Aided Software Engineering), iar un pachet care cuprinde atât instrumente pentru
definirea diagramelor, cât şi pentru generarea programelor s-au numit I-CASE (Integrated
CASE). La mijlocul anilor ’80, furnizorii de CASE au crezut că produsele lor vor depăşi
generaţia limbajelor procedurale şi vor impune un nou standard în dezvoltarea de aplicaţii. Nu
a fost aşa pentru că specialiştii şi proiectanţii de soft au înţeles limitele limbajelor procedurale
şi au descoperit alt mod de a dezvolta software.
-9-
 Generaţia a IV-a (4GL) - limbajele de nivel foarte înalt, care au apărut în primul rând
pentru utilizatorii nespecialişti, numiţi şi utilizatori finali. Se caracterizează prin
neproceduralitate (utilizatorul trebuie să-i spună calculatorului CE SĂ FACĂ, şi nu CUM SĂ
FACĂ) şi este un limbaj conversaţional, interactiv. Se bazează în mare măsură pe utilizarea
meniurilor şi interfeţelor grafice, fiind uşor de învăţat (oferă facilităţi de tip HELP sau Wizard).
Evenimentul ce a perturbat evoluţia limbajelor procedurale a fost apariţia şi, mai ales,
răspândirea PC-urilor. La mijlocul anilor ’80 a început declinul mainframe-urilor si al
prelucrării centralizate a datelor. Managerii erau încântaţi de posibilităţile pe care le oferea PC-
ul în a-şi rezolva singuri multe din probleme, mai ales odată cu apariţia interfeţelor grafice.
Utilizatorii de PC-uri nu-şi propuneau să rezolve probleme complicate şi să dezvolte aplicaţii
complexe, astfel că nu aveau nevoie de limbaje declarative. Ei cereau limbaje grafice,
prietenoase, de aceea limbajele procedurale au evoluat altfel decât către declarativ. A IV-a
generaţie de limbaje de programare a fost orientată către utilizatori, fiind numită şi generaţia
utilizatorilor finali. Producătorii de software s-au orientat către crearea de instrumente şi medii
de lucru prietenoase, iar accentul s-a mutat pe interfaţa cu utilizatorul. O interfaţă grafică,
simplă, dar nu simplistă, care să ofere utilizatorului un mediu de lucru eficient şi prietenos în
acelaşi timp a devenit cheia unui soft de succes.
Ca urmare, caracteristicile limbajelor de generaţia a IV-a pot fi rezumate astfel:
neproceduralitate, interfaţă prietenoasă şi eficacitate.
Majoritatea specialiştilor grupează limbajele din generaţia a-4-a în următoarele clase de
produse:
 limbaje (instrumente) de interogare;
 generatoare de rapoarte;
 generatoare de aplicaţii şi /sau proiecte;
 generatoare de grafice;
 instrumente de sprijinire a deciziilor.
La ora actuală, constructorii de software oferă produse care integrează toate aceste
funcţiuni. De exemplu, programul de calcul tabelar EXCEL este un instrument de sprijinire a
procesului decizional, dar care oferă şi o vastă gamă de alte facilităţi: generarea graficelor,
obţinerea, actualizarea şi interogarea bazelor de date, generarea rapoartelor etc.
Limbajele de interogare la rândul lor pot fi de două tipuri:
 limbaje de interogare simplă care permit consultarea fişierelor şi bazelor de date pe
un singur tip de înregistrare logică utilizând un criteriu de selecţie mai puţin
complex;
 limbaje de interogare complexă care permit consultarea mai multor tipuri de
înregistrări logice din una sau mai multe baze de date devenind posibilă asocierea
unor structuri foarte diferite.

-10-
 În cea de a doua subgrupă intră SQL (Structure Query Language), QBE (Query By
Example), Hiper Talk, INTTELECT, Quel etc. Cea mai mare răspândire o cunoaşte SQL, un
nucleu SQL fiind prezent în orice sistem de gestiune a bazelor de date (dBASE, CLIPER,
FoxPro, Focus, RAMIS, Oracle).

Generatoarele de rapoarte (situaţii) îndeplinesc, în principal, trei funcţii esenţiale:

selecţia informaţiilor solicitate, ordonarea datelor după criterii prestabilite şi editarea
rapoartelor într-o structură formalizată folosind un număr minim de instrucţiuni de programare.
În general, toate sistemele de gestiune a bazelor de date precum şi programele de calcul
tabelar (spreadsheet-urile) au încorporate generatoare de rapoarte. Cele mai populare
instrumente din această categorie sunt: Easytrieve Plus, Datatrieve, Mark V4.
Există şi generatoare de rapoarte care sunt proiectate pentru a fi utilizate de către
specialişti – RPG III (Report Program Generator).
Generatoarele de aplicaţii şi/sau proiecte se adresează în special utilizatorilor
cunoscători ai tehnicilor de programare. Ele permit ca pe baza unor descrieri externe a datelor
şi a modului de organizare, prelucrare şi afişare a acestora să se accelereze generarea (codarea)
programelor, folosind un limbaj specific sau chiar un limbaj de generaţia a-3-a (COBOL). Intră
în această clasă de generatoare CSP (Cross System Product – IBM) FOCUS, Mantis, Natural,
NOMAD2, RAMIS 1, IDEAL MAPPER, modulele de tip RAD pentru dezvoltarea rapidă a
aplicaţiilor.
O categorie aparte o reprezintă pachetele-aplicaţii specializate pentru aplicaţii
economice generale (finanţe-contabilitate) sau chiar numai pentru procesări de texte,
tehnoredactări (DeskTop Publishing).
Generatoarele de grafice sunt instrumente ce permit reprezentarea sub formă grafică
(histograme, bare, linii, cercuri etc. bi sau tridimensionale, cu opţiuni deculoare, text, legendă),
a rezultatelor prelucrării datelor. Ele sunt independente (Tellal Graph, SAS, ADRS/B6) sau
încorporate în spreadsheet-uri (LOTUS, QUATTRO, EXCEL) sau SGBD-uri (FoxGraph).
Instrumentele de sprijinire a deciziilor se adresează experţilor din diferite domenii de
activitate (finanţe, management, contabilitate, marketing etc.) pentru elaborarea şi urmărirea
bugetelor, analiza investiţiilor, studiul pieţei etc. permiţând realizarea simulării şi modelării
matematice a fenomenelor economice. Intră în această clasă programele de calcul tabelar
(QUATTRO, LOTUS, EXCEL ş.a.), pachetele program statistice (SPSS, SAS etc.).
Generaţia a V-a de limbaje a fost anunţată de proiectul întocmit de japonezi încă din
1990, dar singurul limbaj recunoscut ca având caracteristicile generaţiei a V-a este PROLOG,
fiind utilizat în realizarea de sisteme expert. Ea cuprinde limbajele care sunt sau vor fi îndreptate
spre exploatarea bazelor de cunoştinţe, crearea sistemelor expert şi mai general spre rezolvarea
problemelor legate de inteligenţa artificială.

-11-
 După cum se observă limbajele au evoluat continuu, aşa cum rezultă din figura 3.

Figura 3. Evoluţia limbajelor de programare

Aşa cum rezultă şi din figura 3, două sunt tendinţele care au marcat evoluţia limbajelor
de programare. Prima este trecerea de la programele specializate pe un tip de probleme,
elaborate de programatori profesionişti la pachetele de software cu destinaţii diverse adaptate
la nivelul utilizatorilor finali neinformaticieni. Această tendinţă s-a amplificat odată cu apariţia
microcalculatoarelor. Tendinţa principală în prezent este către instrumente avansate de
dezvoltare a aplicaţiilor orientate pe obiect. A doua tendinţă este îndepărtarea de limbajele de
programare tehnice, foarte dificil de utilizat, specifice începuturilor programării (limbaje de
generaţia I şi a II-a) şi de limbajele procedurale. Tendinţa este către limbajele neprocedurale şi
limbajele naturale, apropiate de limbajul uman, tendinţă care s-a accentuat odată cu apariţia
celei de-a IV-a generaţii de limbaje. Ea continuă prin îmbunătăţirea interfeţelor grafice şi
dezvoltarea inteligenţei artificiale, care produce aşteptatele limbaje naturale. Este vorba de cea
de-a V-a generaţie de limbaje de programare, reprezentată de pachete de programe asistate de
experţi. Şi în pachetele de programe actuale sunt încorporate unele module de ajutor sau module
de sprijin inteligente (wizard) care oferă utilizatorului asistenţă în rezolvarea unor probleme
(realizarea unui grafic sau tabel).
Toate direcţiile de dezvoltare a software-ului enumerate converg către o direcţie
principală: instrumente avansate de dezvoltare a aplicaţiilor, orientate pe obiect.

-12-
 1.3. Structurarea şi organizarea datelor. Tipuri de
date utilizate în limbajele de programare
Dezvoltarea rapidă şi complexă a societăţii a dus în mod inevitabil la o sporire însemnată
a volumului de date, care tind să aglomereze şi să blocheze canalele informaţionale în aceeaşi
măsură în care creşte continuu nevoia de informaţie.
Rezultă că orice organism economic se confruntă cu un volum mare de date, supus unor
prelucrări relativ simple, dar cu un caracter repetitiv şi cu o frecvenţă mare. În acelaşi timp
datele se caracterizează printr-o structură uniformă rezultată din structura documentelor primare
specifice operaţiilor economice. Toate acestea reprezintă, de fapt, restricţii în activitatea de
structurare şi organizare a datelor economice în sistemele informatice.
Organizarea datelor reprezintă procesul de identificare, definire, structurare şi memorare
a datelor.
O bună organizare a datelor impune folosirea unor structuri care să permită o prelucrare
cu un cost cât mai redus.
O colecţie de date pe care s-a definit o structură, căreia îi este specific un anumit
mecanism de selecţie şi identificare a elementelor componente constituie o structură de date.
Toate structurile de date care au aceeaşi organizare şi sunt supuse aceloraşi operaţii
formează un anumit tip de structură de date. Pentru specificul activităţilor economice fiecare
nivel de abstractizare implică: date elementare şi date structurate.
Noţiunea de dată elementară se referă la mulţimea ordonată şi finită de valori, de un
anumit tip, asupra cărora se pot efectua operaţii.
O dată care apare ca entitate indisolubilă atât în raport de informaţia pe care o
reprezintă, cât şi în raport de procesorul care prelucrează se numeşte dată elementară.
Cel mai des întâlnite tipuri de date elementare în limbajele de programare sunt:

• tipul numeric – se includ numerele întregi, reale şi complexe şi asupra cărora se pot
realiza operaţii de adunare, scădere, etc.;

• tipul logic (boolean) – este utilizat pentru precizarea stărilor de adevăr (TRUE, YES)
sau neadevăr (FALSE, NO) ale unui enunţ. Asupra acestora se pot efectua operaţii logice: AND,
OR, NOT;

• tipul caracter - conţine o mulţime de caractere alfanumerice, în cadrul acestora

putându-se defini operaţii de concatenare, ordonare etc.;

• tipul pointer - conţine adrese către alte date elementare;

Aceste tipuri de date sunt elemente invizibile ale limbajelor de programare, iar structura
lor internă nu este accesibilă programatorului.
-13-
 Datele structurate sunt colecţii de date elementare care, într-un anumit sens, sunt în
relaţii unele cu altele. Natura relaţiei se stabileşte la crearea structurii şi poate diferi în funcţie
de nivelurile de abstractizare.
Cele mai utilizate date structurate sunt:

• articolul;

• fişierul;

• tabloul.

Articolul este o structură de tip arborescent ale cărui câmpuri (câmpul reprezentând o
mărime ce poate lua valori diferite dintr-o multitudine de valori posibile, face excepţie câmpul
boolean care poate lua doar două valori) sunt descendenţii rădăcinii (nivelul 1), subcâmpurile
sunt descendenţii câmpurilor (nivelul 2) ş.a.m.d. Câmpurile unui articol pot fi date elementare
sau grupuri de date de diverse tipuri. În principiu, fiecare câmp sau subcâmp se defineşte prin
următoarele atribute:
• nume - un cod unic de identificare;
• tip - natura datei;
• lungime - numărul total de caractere;
• partea zecimală – specificată numai pentru datele numerice.
De exemplu, articolul PRODUSE poate avea în structură următoarele câmpuri:

Nume Tip Lungime Partea zecimală

COD N 5 0
DENUMIRE C 10
PREŢ N 9 2
STOC N 8 3

Fişierul este o structură de date omogene din punct de vedere al semnificaţiilor şi al

cerinţelor de prelucrare, înregistrate pe un suport şi care pot fi exploatate individual.
Într-un fişier trebuie să distingem articolul tip (structura articolului) care este o
modalitate de a descrie dacă un obiect aparţine sau nu la o clasă de obiecte, de realizările
(articolele) care sunt elemente ale clasei de obiecte descrise.
Tabloul este o colecţie de date de acelaşi tip, aranjate într-o structură rectangulară, cu
una sau mai multe dimensiuni. Tablourile cu o dimensiune se numesc vectori, iar cele cu mai
multe dimensiuni se numesc matrici sau masive. Pentru fiecare dimensiune se asociază un
indice ale cărui valori sunt folosite pentru referirea elementelor tabloului.

-14-
 Ex. T (i1, i2...ik), unde k reprezintă numărul de dimensiuni, iar i1, i2....ik sunt
elementele tabloului T.
De exemplu, pentru introducerea notelor obţinute de studenţi în cele 2 sesiuni, fiecare
sesiune având câte 5 examene, definim variabila Nota(2,5). Vom obţine un tablou de variabile
astfel:
Nota(1,1), Nota(1,2), Nota(1,3), Nota(1,4), Nota(1,5), Nota(2,1), etc.
Prelucrarea datelor presupune parcurgerea unei succesiuni ordonate de operaţii care
acţionează asupra mărimilor. Ele se pot grupa în următoarele categorii:
 _ operaţiuni de atribuire;
 _ operaţiuni de calcul;
 _ operaţiuni de decizie;
 _ operaţiuni de intrare /ieşire;
 _ operaţiuni de transfer a controlului.
Operaţiuni de atribuire sunt acelea prin care unui câmp i se atribuie o anumită valoare
predefinită sau rezultatul evaluării unei expresii.
TOTVAL = 0
SF = SID + RD – RC
Operaţiuni de calcul se definesc pe mulţimea numerelor reale. Dintre acestea fac parte:
operaţia de adunare, scădere, înmulţire, împărţire, ridicare la putere, calculul unor expresii
numerice, etc.
Ca operatori se utilizează:
 + pentru adunare;
 - pentru scădere;
 * pentru înmulţire;
 / pentru împărţire;
 ** pentru ridicare la putere.
De asemenea, în cadrul expresiilor se pot utiliza şi parantezele, evaluarea acestora
făcându-se după regulile din algebră.
Exemplu: SALAR NET = ((NRORLUCR * TO) + SPORV) - IMPOZ
a = (b * c)**2 + 650

Operaţiunile de decizie sunt utilizate pentru a delimita valoarea logică a unei

propoziţii: adevărat sau fals. Ele condiţionează executarea unor operaţii sau grupuri de
operaţiuni. Operatorii utilizaţi pentru scrierea condiţiilor pot fi operatori relaţionali (=, >, <, ≠)
şi operatori logici (AND, OR şi NOT).
-15-
 Exemplu:
IF STOCSIGUR < 10000 THEN PRINT "ATENŢIE! E NECESARĂ
REAPROVIZIONAREA"
ENDIF
sau
FOR MEDIA > 9.50 .AND. DOMICILIU ='NON IAŞI' PRINT 'DREPT DE CAZARE'
Operaţiunile de intrare/ieşire vizează realizarea transferului de date între memoria
externă şi cea internă şi invers. Pentru optimizarea operaţiei de intrare/ieşire se interpun zone
tampon (buffere), atât pentru intrare, cât şi pentru ieşire conform schemei următoare (fig. 4):

Figura 4. Transferul de date între memoria internă şi cea externă

Cele mai utilizate operaţii de I/E sunt cele de deschidere şi închidere a fişierelor şi de
citire şi scriere date.

-16-
 Operaţiunile de transfer a controlului sunt operaţii de salt şi de apelare. Cele de salt
au rolul de a preda controlul unei alte operaţiuni decât cea imediat următoare, iar cele de apel
determină lansarea în execuţie a unor proceduri (grupuri de operaţiuni), evitându-se descrierea
lor, de mai multe ori, în cadrul algoritmului.
Schematic, derularea unei secvenţe de operaţiuni de apel se prezintă astfel (fig. 5):

Figura 5.
Derularea operaţiunilor de apel

-17-
 1.4. Caracterizarea principalelor limbaje de
programare
Din multitudinea limbajelor de programare practica a consacrat atât limbaje de tip
universal, cât şi limbaje specializate pe domenii de activitate. În continuare, fără pretenţia de a
fi exhaustivi, prezentăm limbajele care s-au impus în domeniul economic şi în cel
tehnicoştiinţific.
FORTRAN (FORmula TRANslation) este un limbaj cu orientare matematică, fiind
utilizat cu precădere în aplicaţii tehnice (ecuaţii, operaţii cu matrici, programare liniară,
simulare). Este primul limbaj de nivel înalt. Prima versiune a apărut în 1954, fiind realizată de
o echipă de la IBM şi urmată de alte versiuni perfecţionate. 1964 este anul în care FORTRAN
a fost standardizat în SUA. A fost foarte criticat în anii ’70, conferindui-se atributele greoi,
dezordonat, infantil şi fără speranţă de a deveni adecvat. Totuşi, ultimele versiuni FORTRAN
au fost aduse în concordanţă cu noile standarde ale programării structurate. Cu toate acestea,
este destul de puţin utilizat astăzi. Cele mai utilizate versiuni au fost: FORTRAN IV,
FORTRAN IV PLUS, FORTRAN 77 – pentru minicalculatoare, specializat pentru prelucrări
în timp real, FORTRAN 90 – variantă îmbunătăţită cu atributele programării orientate obiect.
COBOL (COmmon Business Oriented Language) a fost primul limbaj orientat exclusiv
către rezolvarea problemelor economice, cum reiese şi din numele său. Dintre limbajele din
generaţia a 3-a este cel mai rǎspândit, după FORTRAN. Se utilizează pentru exploatarea unui
volum mare de date cu structuri diverse (arbori, tablouri, fişiere etc.). COBOL a fost lansat în
1964, fiind dezvoltat de o echipă de specialişti, condusă de o femeie (cpt. Grace Hooper) de la
Departamentul Apărării SUA. A fost standardizat prima oară în 1968. Succesul lansării şi
utilizării în următorii ani (la sfârşitul anilor ’80, între 60 şi 75% din aplicaţiile economice erau
scrise în COBOL) a fost însoţit de mai multe controverse. Avantaje: posibilitatea manipulării
unor volume mari de date, descrierea completă a structurilor de date, rapiditate în execuţie
(datorită compilării).
Cea mai importantă producătoare de compilatoare COBOL (firma britanică Micro
FOCUS) a lansat în 1994 COBOL orientat pe obiecte pentru microcalculatoare. La ora actuală,
pentru microcalculatoare, firma Micro Focus oferă compilatoare COBOL care permit:
- dezvoltarea de aplicaţii (inclusiv cu facilităţi grafice) pentru lucrul în reţelele de
calculatoare;
- dezvoltarea de aplicaţii cross-platform destinate unei game largi de echipamente şi
sisteme de operare;
- asigurarea portabilităţii la nivel de programe sursă.
COBOL reprezintă un software complex cu un înalt grad de generalizare şi care asigură
independenţa programelor faţă de componentele hardware.

-18-
 BASIC (Begginner’s All Purpose Instruction Code) este unul din cele mai utilizate
limbaje de generaţia a III-a, poate şi pentru faptul că a fost livrat odată cu sistemul de operare
MS-DOS, fiind inclus între aplicaţiile acestuia (universalitatea şi simplitatea limbajului a
determinat includerea sa în sistemele de operare). Totul a început în 1963, când profesorii Kurtz
şi Kemeny de la colegiul Darmouth, SUA încep lucrul la un nou limbaj, care să înlocuiască
Fortran şi lucrul cu cartele perforate. În 1964 este lansată prima versiune, sub numele BASIC
care avea 12 instrucţiuni. Prima versiune pentru microcalculatoare a fost lansată în 1972. În
1975, Bill Gates şi Paul Allen au scris primul interpreter BASIC pentru microcalculatoare care
ocupa doar 7 KB de memorie, compania Microsoft care a apărut apoi susţinând BASIC-ul prin
includerea lui în pachetul sistemului de operare MS-DOS (începând de la versiunea 5.0). Au
apărut apoi zeci de versiuni de BASIC, cu diferiţi autori, multe dintre ele incompatibile,
ajungând să fie denumit de unii “limbajul programatorilor neprofesionişti”. De aceea, în 1983
ANSI hotărăşte elaborarea unui standard pentru limbajul BASIC. Acest limbaj a cunoscut
diverse variante, cele mai răspândite fiind BASICA, GWBASIC, QBASIC, Turbo Basic şi, nu
în ultimul rând Visual Basic.
PASCAL este un limbaj popular în mediul universitar (mai ales în facultăţile de
informatică şi matematică). A apărut în 1968 şi a fost denumit după matematicianul francez
Blaise Pascal. Este un limbaj universal, caracterizat prin simplitate, eficienţă, accesibilitate
(chiar şi pentru începători) şi care prezintă (încă de la prima versiune) toate elementele specifice
programării structurate. Sunt păreri care apreciază că învăţarea limbajului PASCAL este
indispensabilă pentru formarea unor informaticieni. Dezavantaje: slaba gestionare a datelor
organizate în fişiere şi incapacitatea de a manipula volume mari de date. Limbajul a cunoscut
mai multe versiuni adaptate diverselor metode de prelucrare (Pascal secvenţial, Pascal
concurent, Pascal obiectual). Pascal a stat la baza elaborării de noi limbaje precum MODULA-
1, MODULA-2, ADA. Ultimele versiuni, produse de firma Borland, au apărut sub numele
Turbo PASCAL, cu un succes remarcabil pe piaţă.
ADA, (Automatic Data Acquisition şi totodată numele contesei de Lovelace Augusta
Ada Byron, considerată a fi primul programator din lume), elaborat la Departamentul Apărării
SUA pentru aplicaţii tehnico-ştiinţifice în 1979. Are multe din elementele limbajului PASCAL,
dar este mult mai complex, fiind considerat unul din cele mai dificile limbaje.
Folosit iniţial în domeniul militar, la ora actuală, datorită facilităţilor oferite, este larg
utilizat şi în aplicaţiile economice.
C a fost produs de Bell Laboratories la începutul anilor ’70 (dezvoltă limbajul B elaborat
de laboratoarele Bell). Este un limbaj orientat spre asigurarea fluxurilor de instrucţiuni,
conducând la elaborarea de programe compacte, bine structurate. Destinat initial
programatorilor de sistem, şi-a lărgit aria de utilizatori odată cu extinderea sistemului de operare
UNIX. Este limbajul de programare cu cea mai impresionantă evoluţie şi extindere în anii ’90.
C-ul preia de la limbajele de tip PASCAL gradul ridicat de portabilitate, iar de la limbajele de
asamblare rapiditatea în execuţia şi gestionarea eficientă a memoriei. Rămâne totuşi un limbaj
-19-
pentru profesionişti, multe aplicaţii (procesoare de texte, spreadsheet-uri sau SGBD-uri) fiind
scrise cu ajutorul limbajului C. În plus, ultimele versiuni ale acestui limbaj au transformat C
într-un limbaj orientat pe obiect (C++). Principalii producători sunt Borland (C++), Microsoft
(Quick C, Visual C), Symantec.
RPG (Report Program Generator) este un limbaj dezvoltat de către firma IBM la
mijlocul anilor ’60 odată cu lansarea unei noi linii de minicalculatoare proiectate pentru
afacerile mici şi mijlocii. Limbajul permite ca pe baza unor specificaţii ale utilizatorului, să se
genereze codul unui program care lansat în execuţie va conduce la obţinerea rapidă şi cu un
cost relativ redus, a rapoartelor dorite.
PL/1 (Programming Language 1) este un limbaj lansat de către firma IBM la începutul
anilor ’60, îmbinând facilităţile din FORTRAN pentru aplicaţii ştiinţifice cu cele din COBOL
pentru aplicaţiile economice. La ora actuală acesta nu este foarte popular, utilizarea lui fiind
limitată datorită faptului că este complex şi greu de învăţat
LISP (LISt Processing) este un limbaj adecvat inteligenţei artificiale, utilizat mai ales
în cercetare şi în domeniul inteligenţei artificiale. A apărut în 1958 la Institutul Tehnologiei din
Massachussets, dar a fost considerat prea avansat pentru tehnologia vremii. Spre deosebire de
celelalte limbaje prezentate, care sunt imperative, LISP este un limbaj funcţional. LISP nu face
deosebirea între date şi prelucrări, acestea fiind considerate obiecte şi tratate la fel. Se pot
declara douǎ tipuri de obiecte: atomi şi liste.
PROLOG (PROgramming in LOGic) a fost fundamentat în 1972 la Universitatea din
Marsilia pentru aplicaţii de inteligenţă artificială şi face parte din familia limbajelor declarative
(nu algoritmice). A fost orientat spre demonstrarea de teoreme şi înţelegerea limbajului natural.
Permite reprezentarea şi utilizarea cunoştinţelor, fiind utilizat în crearea de sisteme expert.
PROLOG este considerat o răzvratire împotriva modului de programare impus de modelul Von
Neumann, iar în 1982 proiectul japonez de realizare a calculatoarelor de generaţia a V-a prevede
folosirea ca limbaj de bază a limbajului PROLOG.
Smalltalk a fost dezvoltat la mijlocul anilor ’70 de către firma Xerox Corporation şi a
fost primul limbaj specific programării orientată pe obiecte. Acest limbaj nu este greu de învăţat
şi utilizat dar reclamă schimbarea în întregime a modului de gândire a unui program. Se prevede
ca în viitor Smalltalk alături de celelalte limbaje orientate pe obiect să cunoască o dezvoltare şi
utilizare deosebită.
JAVA este un limbaj orientat pe obiecte dezvoltat de firma Sun Microsystems. Are ca
scop asigurarea comunicării între echipamente eterogene şi distribuirea formatului executabil
al programelor în reţea, fiind limbajul cel mai utilizat în reţeaua INTERNET. Acest limbaj
operează cu tipuri obişnuite de date, dispune de instrucţiuni speciale de protecţie şi oferă
facilităţi de programare de tip animaţie, orientare obiect, distribuţie. Codul Java este portabil,
acelaşi program putând fi rulat pe orice platformă care deţine acest mediu de execuţie.

-20-
 O parte din limbajele de programare, prin diversele lor versiuni, nu pot fi încadrate strict
într-o anume generaţie. Fiind supuse continuu perfecţionării, ele tind spre generaţia superioară
celei în care au fost proiectate iniţial.

1.5. Criterii de selecţie a limbajelor de programare

La alegerea unui limbaj de programare trebuie avute în vedere o serie de aspecte care să
asigure eficienţă, siguranţă şi flexibilitate în rezolvarea aplicaţiilor utilizator. Criteriile care stau
la baza opţiunii de selectare a limbajului privesc următorii factori:
1. tipul problemei ce urmează a fi rezolvată şi cunoştinţele utilizatorului (măsura
în care limbajul de programare este convenabil atât la clasa de probleme, cât şi
pentru utilizator)
2. tipul echipamentelor disponibile utilizatorului
3. gradul de dependenţă faţă de echipamentul folosit şi sistemul de operare
4. evaluarea rezultatelor obţinute prin folosirea anterioară de către alţi utilizatori
5. eficienţa scontată prin exploatare
6. caracteristicile tehnice şi funcţionale generale
7. cerinţe de ordin economic
1. Tipul problemei ce urmează a fi rezolvată şi cunoştinţele utilizatorului
Acest criteriu are în vedere selectarea acelui limbaj care să răspundă cel mai bine
tipului/tipurilor de aplicaţii utilizator, să asigure concomitent uşurinţă în utilizare, un timp
minim pentru prelucrarea datelor confidenţialitatea şi securitatea acestora.
2. Tipul echipamentelor hardware disponibile utilizatorului
Înaintea alegerii limbajului trebuie efectuată o analiză a resurselor fizice existente şi a
celor care urmează să fie achiziţionate. Această analiză trebuie să stabilească dacă sunt asigurate
resursele minime pentru dezvoltarea şi exploatarea aplicaţiilor. În felul acesta se urmăreşte
utilizarea eficientă a limbajului pe echipamentele din dotare.
3. Gradul de dependentă faţă de echipamentul folosit şi sistemul de operare
Conform acestui criteriu, trebuie ales un limbaj de programare care să poată fi folosit
fără probleme sub sistemul de operare sub care lucrează echipamentele din dotare. În plus,
trebuie asigurată portabilitatea programelor în cazul în care se vor achiziţiona noi resurse
informatice. Trebuie asigurată creşterea gradului de portabilitate cel puţin la nivel de program
sursă.
4. Evaluarea rezultatelor obţinute prin folosirea anterioară de către alţi utilizator
Acest criteriu cere realizarea unei documentări prealabile privind problemele cu care s-
au confruntat alţi utilizatori ai limbajului (existenţa /inexistenţa unei documentaţii de învăţare
şi utilizare, posibilităţile/facilităţile de rezolvare a problemelor practice etc.).

-21-
 5. Eficienţa scontată prin exploatare
Această eficienţă implică stabilirea parametrilor de exploatare pe fiecare etapă de
realizare a programelor /produselor-program(scriere, testare, implementare, utilizare). Se are în
vedere atât eficienţa execuţiei programului, mai ales la programele des utilizate cât şi eficienţa
globală care ia în considerare toate fazele de elaborare şi utilizare (scriere, testare, exploatare şi
întreţinere). În acest context performanţa limbajului poate deveni o problemă mai puţin
importantă.
6. Caracteristicile tehnice şi funcţionale generale
Alegerea unui limbaj trebuie sa ţină seama şi de gradul de standardizare a acestuia, ştiut
fiind că, în general, la standardizarea unui produs informatic se au în vedere parametrii ce
privesc simplitatea în exploatare, generalitatea în aplicare, naturaleţea, consistenţa şi
conciziunea în exprimare.
7. Cerinţe de ordin economic
Aceste cerinţe ţin seama de resursele financiare de care dispune utilizatorul , resurse
care trebuie să acopere atât achiziţionarea şi exploatarea propriu-zisă a limbajului, cât şi
organizarea şi pregătirea prealabilă a personalului.
Având în vedere cele de mai sus rezultă că alegerea unui limbaj este o decizie care
trebuie susţinută printr-o serie de analize de ordin tehnic, funcţional şi economic.

-22-
 CAP 2. METODE ŞI TEHNICI DE PROGRAMARE
2.1. Evoluţia metodelor de programare
Evoluţia metodelor de programare trebuie văzută în strânsă legătură cu evoluţiile
înregistrate pe mai multe planuri:
 evoluţia limbajelor de programare
 evoluţia utilizatorilor calculatoarelor
 evoluţia rapidă a componentelor hardware.

2.2. Metode şi tehnici de programare

2.2.1. Metoda programării clasice
Prin programarea clasică se face referire la primii ani de dezvoltare a programelor,
respectiv începutul anilor ’50, perioadă în care existau puţine reguli, majoritatea vizând scrierea
programelor. De aceea, programarea clasică este impropriu numită metodă, însă se face
delimitarea de evoluţiile ulterioare din domeniul programării calculatoarelor.
Programarea clasică presupune conceperea monolitică a programului prin parcurgerea
următoarelor etape:
 analiza problemei în vederea stabilirii exacte a cerinţelor informaţionale ale
utilizatorilor
 elaborarea schemei logice a programului
 scrierea programului sursă
 compilarea şi asamblarea programului
 testarea şi corectarea programului
 exploatarea programului.
Dezvoltarea programelor în această perioadă prezenta o serie de neajunsuri, dintre care
cele mai importante erau: elaborarea intuitivă sau artizanală a algoritmilor de rezolvare a
problemei, eaistenţa numeroaselor operaţii de salt, ce conduc la un timp mare de execuţie a
programului şi fac dificilă înţelegerea şi modificarea programului, imposibilitatea desfăşurării
activităţii de programare în echipă etc. Acestea sunt şi motivele care au determinat apariţia unor
noi metode de programare.

2.2.2. Metoda programării modulare

Programarea modulară poate fi considerată prima metodă de programare propriu-zisă.
Ea presupune decompunerea problemei de rezolvat în mai multe subprobleme mai simple.
Fecărei subprobleme îi va corespunde în principiu un modul de program, iar produsul program
va fi constituit prin integrarea modulelor componente, dezvoltate separat. Proiectarea
-23-
modulelor se face independent de limbajul de programare ales, doar la scrierea programelor
ţinându-se cont de specificul fiecărui limbaj. Fiecare modul are o funcţie bine precizată în
cadrul programului, în conformitate cu rezultatele descompunerii funcţionale a problemei de
rezolvat, realizată prin aplicarea strategiei descendente (de sus în jos).
Conceperea şi realizarea programelor conform acestei metode cuprinde următoarele
faze:
- analiza problemei;
- stabilirea modulelor componente şi organizarea acestora;
- întocmirea specificaţiilor pe module;
- analizarea posibilităţilor de utilizare a unor module standard;
- elaborarea logicii programelor pe fiecare modul;
- scrierea programelor şi testarea modulelor elaborate;
- testarea de ansamblu prin integrarea modulelor;
- întocmirea documentaţiei finale;
- utilizarea şi întreţinerea programelor.

2.2.3. Metoda programării structurate

Metoda programării structurate reprezintă o dezvoltare a metodei programării modulare.
Bazele sale au fost puse prin definirea structurilor de control fundamentale (secvenţa, selecţia,
iteraţia) şi a marcat trecerea de la programarea ca artă la programarea ca ştiinţă. Îşi propune
minimizarea costurilor şi eforturilor activităţii de programare (prin creşterea productivităţii
activităţii de programare) şi obţinerea unui produs de calitate. O structură de control are un
singur punct de intrare şi un singur punct de ieşire. Termenul a fost lansat în 1966 de doi
matematicieni: Boehm şi Jacopini care au propus o teoremă a programării structurate. Cel mai
important promotor este prof. Dijkstra (Univ. Eindhoven, Olanda) care, în 1968, a publicat un
studiu în care afirma că “instrucţiunea GOTO ar trebui exclusă din toate limbajele de nivel
înalt”. În următorii ani, el a publicat mai multe cărţi în care a fundamentat metodologia de
programare structurată. Programarea structurată a marcat o creştere a productivităţii de până la
800%.
Această metodă se bazează pe modularizarea ierarhică a programelor şi utilizarea
structurilor de control fundamentale.
Conceperea şi realizarea programelor conform acestei metode se realizează pe aceleaşi
faze ca şi în cazul metodei modulare.

-24-
 2.2.4. Metoda programării pe obiecte
Programarea orientată pe obiecte reprezintǎ tendinţa ultimilor ani ai programării.
Conceptul de obiect şi limbaj de programare care lucrează cu obiecte au fost lansate încă
din anii ’60, când XEROX a dezvoltat limbajul SmallTalk. Acesta a fost utilizat mulţi ani doar
de cercetători şi oameni de ştiinţă. Sfârşitul anilor ’80 a însemnat trecerea acestui limbaj în aria
aplicaţiilor economice, mari companii americane realizând sisteme eficiente, cu minim de
resurse.
Programarea orientată pe obiecte (POO) modelează un sistem văzut ca un set de obiecte
legate între ele. Obiectul este considerat o entitate care se poate distinge de alte entităţi şi care
are o semnificaţie în cadrul aplicaţiei modelate. Obiectul asociază datele şi prelucrările în cadrul
aceleiaşi entităţi, rămânând vizibilă doar interfaţa obiectului. Obiectele cu proprietăţi similare,
comportament similar şi relaţii similare faţă de alte obiecte constituie o clasă de obiecte.
Un obiect comportă un aspect static, reprezentat prin intermediul unor variabile de stare,
numite atribute şi un aspect dinamic, reprezentat de comportamentul obiectului şi implementat
prin intermediul metodelor asociate obiectului respectiv. Aspectul static este ascuns de aspectul
dinamic.
Spre exemplu, pentru clasa de obiecte CONT se pot defini următoarele atribute pentru
obiecte: Simbol_cont, Denumire_cont, Sold_initial_debitor, Sold_initial_creditor şi
următoarele metode: Creare_cont(), Actualizare_cont(), Ştergere_cont(), Selectare_cont();
metode specifice: Sold_final_debitor, Sold_final_creditor.
Conform acestei metode, un program este privit de o manieră globală, ca un ansamblu
de obiecte care interacţionează prin intermediul mesajelor, fiecare obiect având asociat propriul
set de operaţii.
Obiectul are următoarele caracteristici:
1. Identitate – obiectul este o entitate discretă care poate fi distinsă de alte entităţi
2. Clasificare – obiectele cu aceleaşi atribute şi operaţii sunt grupate în clase, un
obiect este considerat o instanţă a clasei din care face parte
3. Polimorfism – aceeaşi operaţie poate avea comportament diferit în funcţie de
obiectul la care este ataşată, implementarea concretă a unei operaţii într-o
anumită clasă numindu-se metodă
4. Moştenire – atributele şi operaţiile se transmit de la o clasă de-a lungul unei
relaţii ierarhice.

-25-
 2.2.5. Metoda programării vizuale
Programarea vizuală (limbajele Visual Basic, Visual Fox) este considerată o fază
intermediară între programarea structurată şi cea orientată pe obiecte, care s-a dezvoltat datorită
şi cu ajutorul mediului Windows. Programatorul nu are nevoie de experienţă şi nu trebuie să
cunoască vocabularul limbajului de programare sau sintaxa instrucţiunilor.
Lucrează cu obiecte şi este dirijată de evenimente: ordinea de execuţie a instrucţiunilor
sau procedurilor nu este determinată de locul pe care îl ocupă în program, ci de apariţia unui
eveniment. Cu ajutorul mouse-ului, utilizatorul alege elementul pe care doreşte să îl definească
(fişier de date, format de ecran, format de raport) - fiecare fiind considerat un obiect, cu diferite
proprietăţi pe care el trebuie să le descrie. Descrierea fiecărui obiect se concretizează într-un
cod de program generat automat, pe care utilizatorul nu trebuie să-l vadă sau să îl înţeleagă.
Programarea vizuală nu este foarte eficientă, dar este un instrument foarte rapid şi uşor de folosit
pentru utilizatorii nespecialişti.

2.3. Elaborarea produselor-program. Activităţi

specifice elaborării produselor- program
Elaborarea unui produs-program constituie o activitate deosebit de complexă care
necesită utilizarea unei metodologii clare şi unitare. De regulă, o asemenea activitate se
desfăşoară în echipe de lucru complexe în care sunt incluşi analişti, specialişti ai domeniului
pentru care se dezvoltă produsul-program, programatori, specialişti în testarea şi implementarea
produselor-program, utilizatori etc.
Literatura de specialitate pune în discuţie o multitudine de probleme legate de
metodologia elaborării produselor-program şi subliniază în mod deosebit necesitatea existenţei
unei metodologii unitare. Totuşi, se poate afirma că în forma sa finală orice produs-program
poate fi privit ca un sistem cu funcţii şi componente proprii, cu intrări, ieşiri, prelucrări şi bucle
de autoreglare şi cu un scop bine stabilit.
Din punct de vedere practic, elaborarea unui produs-program presupune parcurgerea
unui anumit număr de activităţi specifice obţinerii acestuia. Există un număr însemnat de
modele pentru elaborarea unui produs-program dintre care cele mai importante sunt: modelul
în cascadă, modelul în V, modelul evolutiv, modelul spirală, modelul liniar, modelul
incremental, modelul RAD.

2.3.1. Modelul în cascadă

Dintre toate modelele enumerate, modelul în cascadă este cel mai des utilizat în practică.
Activităţile avute în vedere la elaborarea produselor-program în cazul modelului în cascadă
sunt următoarele:
 Definirea cerinţelor (problemei);
-26-
  Analiza;
 Proiectarea;
 Dezvoltarea;
 Testarea;
 Implementarea;
 Exploatarea şi întreţinerea.
Acest model a fost lansat de W.W. Royce la începutul anilor 1970 şi este cel mai familiar
programatorilor. Caracteristica fiecărei etape constă în aceea că se finalizează cu o verificare şi
o validare în scopul eliminării eventualelor anomalii care ar putea să apară în cadrul acesteia.
Dacă se constată anomalii, atunci se va reveni la etapa precedentă până când acestea vor fi
eliminate. Astfel se realizează o minimizare a costului pentru produsul-program dezvoltat. În
acelaşi timp, trecerea de la o fază la alta, în sus şi în jos oferă modelului un caracter iterativ şi
incremental.

Figura 6. Modelul în cascadă

-27-
 2.3.2. Modelul în V
Modelul în V pote fi considerat ca un caz particular al modelului în cascadă prin faptul
că activităţile necesare elaborării produsului-program sunt reprezentate grafic sub forma lui V.
Esenţa modelului constă în aceea că separă primele etape ale procesului de dezvoltare în sub-
activităţi ce au legătură cu construcţia sistemului. Această organizare sub forma literei V este
dată de faptul că se pune în relaţie directă de dependenţă primele etape cu cele aflate în partea
de jos a modelului în cascadă.
În acest model se delimitează următoarele activităţi:
1. Analiza cerinţelor şi studiul de fezabilitate9;
2. Specificarea globală;
3. Proiectarea de ansamblu;
4. Proiectarea de detaliu;
5. Programarea;
6. Testarea unitară;
7. Integrarea şi testul de integrare;
8. Testul de acceptare;
9. Implementarea şi testul sistem.
Activităţile 1-5 influenţează în mod permanent o activitate din 6-9, ceea ce permite o
mai bună organizare a etapelor finale.
Dezavantajul acestui model constă în aceea că nu pune în evidenţă posibilitatea reluării
unei activităţi deja parcurse, ceea ce poate să conducă la depistarea unor anomalii funcţionale
ale produsului-program în faza de implementare. Acest lucru va duce la reluarea întregului
process de elaborare a produsului-program cu costuri corespunzătoare şi pierderi de timp.

-28-
 2.3.2. Activităţi specifice elaborării produselor-program
Întrucât cel mai des utilizat model pentru elaborarea produselor program este modelul
în cascadă, vom prezenta în continuare activităţile specifice de elaborare a produselor-program
utilizând acest model:
1. Definirea problemei
În activitatea de elaborare a unui produs-program este foarte important de a şti şi de a
înţelege esenţa sarcinii de îndeplinit încă înainte de începerea lucrului efectiv. Scopul activităţii
de definire a problemei este, deci, de a formula pe înţelesul echipei de lucru problema de
rezolvat şi de a descrie o strategie de rezolvare a problemei.
În această etapă se poartă discuţii cu specialişti ai domeniului şi cu potenţialii utilizatori
ai viitorului produs-program. Astfel, se urmăreşte extragerea de informaţii cu privire la
cerinţele, restricţiile şi obiectivele avute în vedere pentru asigurarea funcţionalităţii produselor-
program. Metoda cea mai des utilizată este interviul, la care se pot adăuga informaţii extrase
din diverse surse, precum: studii comparative realizate pentru produse-program similare, studii
de fezabilitate, informări.
Din această activitate trebuie să rezulte clar următoarele categorii de cerinţe:
- -cerinţe funcţionale pentru utilizări simple şi avansate
- -cerinţe tehnice (resursele tehnice minime necesare pentru utilizarea produselor-
program
- -cerinţe cu privire la livrare.
Verificarea şi validarea au loc pe tot parcursul acestei activităţi, prin faptul că atât
utilizatorii, cât şi echipa de lucru colaborează foarte strâns la obţinerea informaţiilor necesare.

2. Analiza
După obţinerea unei definiţii clare a problemei de rezolvat, se procedează la analizarea
problemei. Scopul analizei este de a determina cu exactitate ce trebuie făcut pentru rezolvarea
problemei. De regulă, elementele logice ale sistemului (limitele, procesele şi datele sale) sunt
definite în cursul analizei, având în vedere cerinţele formulate în etapa precedentă.
Rezultatul obţinut de către membrii echipei de lucru este supus verificării
corespondenţelor cu cerinţele din etapa precedentă. Validarea se realizează de către beneficiar
într-o întâlnire în care i se poate prezenta sub forma unei informări rezultatul analizei
echipei de lucru. Dacă la această întâlnire se constată că trebuie făcute completări
informaţionale legate de natura problemei de rezolvat, atunci se poate reveni la etapa de definire
a problemei şi reluarea/completarea analizei. Dacă se constată că nu există aspecte suplimentare
de clarificat, atunci are loc validarea din partea beneficiarului a activităţii de analiză şi se poate
trece la activitatea următoare.

-29-
 3. Proiectarea
Proiectarea produsului-program este procesul prin care se reprezintă funcţiile fiecărei
componente în maniera în care se relevă concret una sau mai multe unităţi funcţionale, module
etc.
Scopul activităţii de proiectare constă în a determina modul în care va fi rezolvată
problema. În timpul proiectării, atenţia analistului se va deplasa de la latura logică la cea fizică.
Procesele sunt convertite în proceduri manuale sau programe de calculator. Elementele datelor
sunt grupate pentru a forma structuri de date fizice, machete, rapoarte, fişiere şi baze de date.
Sunt definite componentele hardware care susţin programele şi datele.
Proiectarea produsului-program parcurge următoarele faze:
- proiectarea architecturală
- specificaţia produsului-program
- proiectarea de ansamblu
- proiectarea de detaliu
În faza proiectării arhitecturale se stabileşte arhitectura generală a viitorului produs-
program în corelaţie cu fazele precedente.
Specificaţia produsului-program constă într-o documentaţie care va fi obiectul unui
contract încheiat între beneficiar şi dezvoltator. În această documentaţie se va avea în vedere
stabilirea funcţiilor de informatizat şi cuprinderea condiţiilor de lucru efectiv.
În faza proiectării de ansamblu se stabileşte structura modulară a produsului- program,
pornind de la specificaţia şi arhitectura stabilită anterior. Elementul de bază al structurii îl
constituie modulul.
În faza proiectării detaliate se procedează la stabilirea algoritmului de lucru pentru
fiecare modul şi se ţine cont de toate detaliile funcţionale ale acestuia.
Prin parcurgerea acestor faze se va obţine un proiect cu două categorii de informaţii, de
ansamblu şi de detaliu. Parcurgerea unor faze din cele prezentate se poate repeta prin aşa-
numitul proces de rafinare prin care se verifică rezultatul obţinut după proiectarea de detaliu cu
proiectarea arhitecturală şi specificaţiile produsului-program.
Verificarea are loc permanent prin raportare atât la cerinţele stabilite în prima activitate,
cât şi la arhitectura generală stabilită la începutul acestei activităţi. Validarea se pune în evidenţă
prin acceptarea produsului-program de către beneficiar.

-30-
 4. Dezvoltarea
Crearea propriu-zisă a produsului-program are loc în cadrul activităţii de dezvoltare. În
cadrul acesteia au loc următoarele sub-activităţi:
- -codificarea algoritmilor de lucru pentru fiecare modul al arhitecturii produsului-
program;
- -documentarea şi testarea fiecărei componente arhitecturale ;
- -pregătirea documentaţiei pentru utilizatorul final ;
- -iniţializarea bazelor de date şi a fişierelor;
- -instruirea utilizatorilor.
Procesul dezvoltării produselor-program de la stadiu de proiect la stadiu de aplicaţie se
poate realiza pe două căi:
- dezvoltarea top-down (descendentă);
- dezvoltarea bottom-up (ascendentă).
Alegerea unei modalităţi de dezvoltare a produselor-program depinde de metoda de
proiectare şi de obişnuinţa echipei de lucru. În cazul dezvoltării descendente, produsul-program
este considerat a fi o ierarhie de componente şi presupune începerea activităţilor specifice de la
vârf către componente, în timp ce în cazul dezvoltării ascendente se porneşte de la componente
către vârf.
1. Dezvoltarea descendentă
În acest caz activitatea de programare începe cu modulul director, adică modulul aflat
pe nivelul cel mai înalt al ierarhiei, după care sunt tratate modulele de pe nivelul următor, până
când se codifică toate modulele de pe toate nivelurile de descompunere. Pe măsura definitivării
codificării componentelor de la un nivel se
trece la cele de pe nivelul următor. Prin această tehnică de dezvoltare se obţin
programe mai lizibile şi mai fiabile, cu posibilitatea întreţinerii foarte uşoare.
2. Dezvoltarea ascendentă
În cazul dezvoltării ascendente activitatea de codificare începe cu modulele de la cel
mai mic nivel şi se trece treptat la modulele de pe nivelul superior. Această dezvoltare este mai
potrivită pentru optimizări cu caracter local în costul şi în calitatea produselor program. Se
recomandă în cazul produselor-program complexe când, la rândul lor, modulele se constituie în
aplicaţii de sine-stătătoare, iar gradul de interconectare este mare.
În practică, de cele mai multe ori, se acceptă o combinaţie a celor două tehnici de
dezvoltare pentru a se câştiga timp şi bani.
În activitatea de dezvoltare, verificarea are loc prin compararea fiecărui modul cu
cerinţele iniţiale şi specificaţia produsului-program, precum şi cu ocazia testării funcţionalităţii
fiecărui modul codificat chiar de către echipa de programatori.

-31-
 Verificarea se realizează în colaborare cu specialiştii şi utilizatorii desemanţi de către
beneficiar.

5. Testarea
Integrarea şi testarea produsului-program este faza în care unităţile de program,
testate anterior separat, sunt integrate şi testate ca un sistem pentru ca echipa de proiectare să
se convingă împreună cu beneficiarii de asigurarea funcţionalităţii produsului-program în
ansamblu. Această etapă presupune şi validarea funcţionalităţii produsului-program cu date de
test stabilite de viitorul beneficiar.

6. Implementarea
După ce programul trece şi ultimul test şi sunt corectate eventualele probleme apărute,
sistemul poate fi implementat direct la beneficiar. Această activitate se constituie din
următoarele acţiuni: instalare, parametrizare, iniţializare cu datele beneficiarului. De cele mai
multe ori, dezvoltatorul se implică şi în acţiuni de formare a personalului ce va utiliza produsul-
program. Eventualele anomalii constatate la implementare pot atrage reluarea unor activităţi
precedente.

7. Exploatarea şi întreţinerea
Utilizarea şi întreţinerea este faza cea mai îndelungată a ciclului de viaţă a unui produs-
program.
Produsul-program este instalat şi pus în funcţiune la utilizator. Această activitate implică
descoperirea şi eliminarea tuturor eventualelor erori care nu au putut fi descoperite în fazele
precedente, îmbunătăţirea implementării unor unităţi de program astfel încât să încorporeze noi
funcţii cerute de beneficiari.
După trimiterea sistemului, încep lucrările de întreţinere. Obiectivul întreţinerii este
menţinerea funcţionării sistemului la un nivel acceptabil.
Pentru ţinerea sub control a activităţilor specifice fiecărei faze este necesară elaborarea
unei documentaţii specfice care se va utilize cu precădere ca suport de lucru în etapele
următoare. Având în vedere multitudinea de etape şi numărul mare de specificaţii necesare
derulării fiecărei etape, acest model nu este folosit în practică pentru aplicaţii mici, dezvoltate
în logica utilizatorului final.

-32-
 2.3.3. Modelul evolutiv
Constă în efectuarea unei investigaţii iniţiale, elaborarea unei strategii pentru
descompunerea proiectului în părţi/segmente, fiecare cu o valoare deosebită pentru client. Ele
sunt realizate şi livrate în mod iterativ şi contribuie la sporirea performanţelor sistemului.

Etapele parcurse în cadrul acestiu model, sunt:

 Analiza cerinţelor şi studiul de fezabilitate. Studiul de fezabilitate are rolul de a
asigura informaţiile obiectiv necesare pentru a cunoaşte dacă un proiect poate fi
demarat sau nu sau dacă un proiect deja început mai poate fi continuat.
 Specificarea globală
 Proiectarea de ansamblu
 Proiectarea de detaliu
 Programarea
 Test unitar
 Integrarea şi testul de integritate
 Testul de acceptare
 Implementarea şi testul sistem
Formele obţinute pentru părţile componente nu sunt foarte detaliate, lăsându-se loc
pentru adaptări şi modificări ulterioare.
Oricare dintre segmentele/părţile luate în studiu trece prin toate fazele de dezvoltare a
sistemului: definirea cerinţelor, analiză, proiectare, implementare, testare, utilizare. Clientul
intră în posesia unei forme cvasi-finite la terminarea fiecărui segment.

2.3.4. Modelul în spirală

Modelul în spirală a fost propus în 1988 de către B.W. Boehm şi este cel mai cunoscut
model evolutiv. El are la bază două premise:
• Natura iterativă a dezvoltării şi nevoia de planificare şi evaluare a riscurilor fiecărei
iteraţii;
• Realizarea validării cât mai devreme posibil şi de cât mai multe ori, prin construirea
prototipurilor.
Obiectivul principal urmărit prin modelul spirală este gestiunea atentă a riscurilor prin
combinarea modelului cascadă cu prototipizarea. Se construieşte mai întâi o primă versiune a
sistemului, sub forma unui prototip în care nu este definit întregul sistem, ci sunt luate în
considerare doar caracteristicile sale principale. După transpunerea prototipului în aplicaţie,
aceasta este evaluată de beneficiari, iar în funcţie de rezultatul evaluării se pot defini şi
implementa noi caracteristici ale sistemului, construindu-se un nou prototip ce va fi supus

-33-
evaluării. Acest proces se reia de mai multe ori, următoarele prototipuri fiind versiuni din ce în
ce mai complete ale produsului propus. Modelul cascadă se va regăsi în cadrul fiecărei iteraţii.
Modelul spirală este descompus în mai multe activităţi-cadru, maxim 6, şi anume:
1. Comunicarea cu beneficiarul (stabilirea şi menţinerea contactului dintre
beneficiar şi proiectant)
2. Planificarea (definirea resurselor, a termenilor limită de realizare)
3. Analiza riscului (riscuri tehnice şi de organizare)
4. Proiectarea (definirea uneia sau a mai multor reprezentări ale aplicaţiei)
5. Construirea şi lansarea
6. Evaluarea beneficiarului (feed-back din partea beneficiarului asupra
schimbărilor din noua versiune instalată).
Printre avantajele modelului în spirală se pot enumera:
 Diminuarea riscurilor la nivel de prototip, prin angajarea treptată în proiect a echipei
de dezvoltare şi a beneficiarilor
 Valorificarea experienţei anterioare în planificarea activităţilor pentru prototipul
următor
 Evaluarea riscurilor asociate proiectului în mai multe momente
 Simplificarea operaţiunilor de evaluare a ceea ce este necesar în etapa (prototipul)
următoare, inclusiv prin prisma costurilor.
Aplicarea cu succes a modelului spirală este condiţionată de profesionalismul echipei
de dezvoltare şi flexibilitatea în acţiune, inclusiv în alocarea de fonduri, dar şi în definirea
activităţilor de întreprins.

2.3.5. Modelul liniar

Modelul liniar de elaborare a produselor-program pune accent pe următoarele activităţi:
1. analiza problemei;
2. stabilirea algoritmului de rezolvare;
3. stabilirea resurselor necesare rezolvării;
4. scrierea programului;
5. dezvoltarea programului;
6. corectarea şi testarea;
7. elaborarea documentaţiei;
8. exploatarea curentă;
9. întreţinerea.
Caracteristica principală a acestui model constă în faptul că nu sunt avute în vedere
posibilele reveniri la etapele precedente. În acest caz, responsabilitatea echipei de lucru este
foarte mare pentru fiecare etapă în parte.

-34-
 2.3.6. Modelul RAD (Rapid Application Development)
Dezvoltarea aplicaţiilor trebuie să răspundă principiului productivităţii şi eficienţei
economice. Astfel, în dezvoltarea unei aplicaţii trebuie avute în vedere productivitatea
resurselor, calitatea produsului, timpul de realizare, simplificarea întreţinerii, satisfacerea
utilizatorului.
Modelul RAD îşi propune să pornească de la nevoile utilizatorului, acesta fiind clientul
sistemului ce se realizează.
RAD reprezintă un arhetip revoluţionar de succes în software-ul anilor ’90, caracterizat
pe scurt prin “mai repede, mai bine, mai ieftin”, ceea ce este posibil de realizat printr-o abordare
riguroasă, bazată pe echipe mici de specialişti bine pregătiţi, pe utilizarea prototipurilor şi
impunerea unor limite rigide de timp în planificarea activităţilor.
RAD se bazează pe modelul spirală, ceea ce permite dezvoltarea incrementală şi
repetitivă. RAD apelează la generarea automată a codurilor prin sisteme CAPS (Computer
Aided Prototyping System) care înlocuiesc scrierea manuală, mai înceată a codului şi
minimizează erorile. RAD înseamnă flxibilitate prin faptul că permite utilizatorilor să utilizeze
propriile limbaje de interogare şi generatoare de rapoarte. Trebuie precizată şi influenţa
metodelor orientate obiect ce asigură o eficienţă sporită pentru RAD prin utilizarea unor
componente prefabricate.
RAD se individualizează prin următoarele caracteristici:
 Utilizarea de echipe mixte, formate în medie din 6 persoane, incluzându-i pe
utilizatorii finali, manageri şi dezvoltatorii sistemului (cu cunoştinţe specifice
analizei de sistem, de proiectare şi programare). Experienţa anterioară este foarte
importantă, iar succesul proiectului este asigurat prin implicarea activă a
utilizatorilor, dar şi prin comunicarea şi colaborarea permanentă între membrii
echipei.
 Utilizarea de instrumente specializate care asigură dezvoltarea vizuală, crearea de
prototipuri, planificarea şi gestiunea timpului, colaborarea şi lucrul în echipă,
folosirea componentelor reutilizabile şi a componentelor API, controlul versiunilor.
 Renunţarea la caracteristici sau componente secundare (în special cu rol de
îmbunătăţire a interfeţei sau a dialogului cu utilizatorul) pentru a asigura încadrarea
în termenele stabilite. De regulă, întregul proces nu trebuie să depăşeasă 6 luni.
 Prototipizarea iterativă, evolutivă.
Etapele unui ciclu de dezvoltare RAD pot fi prezentate şi în succesiunea analiză,
proiectare, realizare şi integrare, testare şi implementare, dar într-un mod diferit faţă de modelul
clasic. Pentru ilustrare ne vom opri asupra ciclului de dezvoltare James Martin (părintele acestui
concept), cel mai reprezentativ dintre ciclurile de dezvoltare RAD. Există patru faze în acest
ciclu: identificarea şi planificarea cerinţelor, proiectare, construire şi finalizare.

-35-
 Planificarea cerinţelor are ca obiectiv determinarea cerinţelor sistemului. Utilizatorul
trebuie să aibă un rol activ în această fază. Faza se desfăşoară în aşa-numitele ateliere de lucru
(workshop) de tip Joint Requirements Planning. Activităţile desfăşurate pot fi grupate în
evidenţierea problemelor, identificarea şi precizarea cerinţelor, planificarea sarcinilor.
Proiectarea realizează modelarea sistemului prin prototipuri şi alte instrumente de
modelare. Activitatea se desfăşoară în ateliere de lucru de tip Joint Application Design. După
stabilirea modelului de lucru se stabileşte prototipul. Fiecare prototip va fi testat şi validat în
atelierele de lucru.
Construirea sistemului este apanajul specialiştilor informaticieni care transpun
modelele fazei anterioare în programe. Utilizatorii testează componentele şi le validează sau
solicită, dacă este necesar ameliorarea acestora. Faza se încheie prin integrarea componentelor
în produsul final. Această fază şi precedenta se constituie într-un ciclu iterativ până la obţinerea
rezultatului final.
Finalizarea se referă la punerea la punct a sistemului. Această fază continuă testările
asupra produsului final, impune schimbări organizaţionale, formează şi instruieşte utilizatorii
finali.
În sinteză, modelul RAD se bazează pe următoarele soluţii:
Includerea utilizatorilor în echipa de realizare a aplicaţiei şi implicarea activă a
acestora. S-a pornit de la faptul că utilizatorii sunt sursa cerinţelor informaţionale, ca şi
beneficiarii direcţi ai aplicaţiei, deci opinia lor este determinantă pentru succesul aplicaţiei.
Gestiunea optimă a timpului. Se fixează intervale scurte de timp pentru realizarea
componentelor. Un proiect de dimensiuni mari va fi descompus în subproiecte cu posibilităţi
de realizare în paralel. Pentru a asigura respectarea termenelor se vor realiza mai întâi versiuni
care vor cuprinde doar funcţionalităţile de bază. În final se vor integra şi funcţionalităţile
complementare.
Dezvoltarea incrementală, numită şi ciclu de elaborare în spirală. În loc să se lanseze
direct produsul final, aplicaţia va apărea în versiuni succesive. Se realizează prototipuri ale
aplicaţiei prin parcurgerea a trei etape: determinarea cerinţelor informaţionale, transpunerea lor
sub formă de aplicaţie, testarea acestora de către utilizatori. Utilizarea prototipurilor permite ca
utilizatorii să observe şi să corecteze sistemul.
Reutilizarea. O aplicaţie nu mai este văzută ca un ansamblu de programe executabile
împreună cu un ansamblu de date care comunică prin intermediul unor interfeţe. Aplicaţia
reprezintă un ansamblu de servicii/componente care răspund unor obiective sau cerinţe.
Utilizarea de instrumente CASE pentru generarea rapidă şi fără erori a programelor.

-36-