STILUL PROGRAMATORULUI
Alegerea variabilelor
Prefixarea rolului unor variabile
Flexibilitatea la definire a dimensiunilor
Managementul listelor de marametri
Omogenitatea secventelor de cod cod
Utilizarea etichetelor
Construirea de blocuri
Reutilizarea de cod
Managementul stilului de programare
Alegerea variabilelor
Programatorul, indiferent de maniera in care lucreaza, utilizeaza in program variabile pe care si le defineste.
Numele variabilelor trebuie sa indeplineasca o serie de conditii, precum:
- sa respecte regulile impuse de limbaj pentru construirea identificatorilor
- sa nu fie foarte lungi pentru a mari eforul de scriere a programului
- sa fie diferite unele de altele pentru a nu crea confuzii
- sa fie stabile, pentru a fi utilizate de la un program la altul daca au aceeasi semnificatie
- sa fie regasite cu usurinta in textul sursa daca trebuie urmarite
- sa nu difere foarte mult in raport cu indicatorii pe care ii preia din problema reala.
Construirea numelor de variabila prin preluarea exect a denumirii variabilei din modelul asociat problemei de rezolvat, precum:
cantitate
timp
viteza
pret
trimestrul
persoana
nume
varsta
salariu
impozit
adresa
greutate.
Constituirea numelor de variabile prin preluarea prescurtarilor uzuale,precum:
um pentru unitate de masura
cant pentru cantitate
pr pentru pret
imp pentru impozit
prpl pentru pret planificat
sal pentru salariu
valprod pentru valoarea productiei
disp pentru dispersie
med pentru medie
val pentru valoare.
Utilizarea de notatii consacrate, precum:
tva pentru taxa pe valoare adaugata
v pentru viteza
t pentru timp
w pentru productivitate
q pentru cantitate
var pentru varianta.
Utilizarea caracterului _ pentru a construi nume compuse precum:
valoare_totala
coeficient_corelatie
medir_aritmetica
trim_1
trim_2
_calcul
sortare_
x_fisier
y_fisier.
Folosirea combinata a literelor mici si a literelor mari, pentru a delimita cuvintele compuse, precum:
CantitateAprovizionata
CantitateExpediata
CantitateStoc
PretIntern
PretAchizitie
PretVanzare
PopulatieBucuresti
populatieGalati
RosioriiDeVede
BolintinulDinVale
ProceduraCalculMedieAritmetica
ProcSortareFisier.
Denumirile de variabile trebuie sa fie cat mai ortogonale, adica, sa fie cat mai diferite unele de celelalte.
revenire

Prefixarea rolului unor variabile
Programatorul trebuie sa fixeze rolul unor variabile.
cand doreste sa calculeze sume ale elementelor omogene va defini variabile cu numele total si va fixa ca regula initializarea la definire a acestor variabile.
int total=0;
int total_cant=0;
int total_val=0;
int total_vect[10]={0,0,0,0,0,0,0,0,0,0}; int totalxx[100]; for(i=0;i<100;i++)totalxx[i]=0; De asemenea, programatorul va fixa ca regula ca variabilele i,j si k sa fie utilizate numai in expresii de referire a elementelor unor masive, precum:
x[i]
a[i][i]
b[i][j]
c[i*j+2][j*j+i]
d[i][j][k]
h[i][j+2][k*i*j+1].
Pentru variabilele pointer va asocia nume care difera printr-o litera p fata de variabila a carei adresa o contin.
int a,b,c,d,*pa,*pb,*pc,*pd;
struct articol{
int a;
float b;
char nume[20];
}art, *part;
Numarul de aparitii ale literei p in nume depinde de numarul nivelurilor de indirectare.
int a,***pppa;
int b,**ppb;
int x,*px, **ppx, ***pppx;
revenire

Flexibilitatea la definire a dimensiunilor
Cand se construieste un program este dificil sa se obtina de la inceput o imagine clara asupra dimensiunii problemei de rezolvat.
Pentru a obtine o buna flexibilitate, se va cauta sa se efectueze astfel de definiri incat numarul de modificari in textul sursa sa fie cat mai redus atunci cand se trece la o alta dimensiune a problemei de rezolvat.
#define N 10
#define M 10
................
int a[M][N];
float x[N];
char y[M];
....................
if(n>N)afisare_mesaj(1);
if(m>M)afisare_mesaj(2);
.......................
Daca nu se procedeaza astfel, la orice schimbare a dimensiunilor masivelor se va opera la nivelul instructiunilor de definire si de testare.
revenire

Managementul listelor de marametri
Listele de marametri se impart in trei subliste:
- sublista parametrilor ce contin date de intrare care apar numai in membrul drept al expresiilor de atribuire si care nu fac obiectul unor modificari de continut
- sublista rezultatelor, care apar in partea stanga a expresiilor de atribuire
- sublista variabilelor de stare cxare descriu modul in care s-au efectuat prelucrarile.
Pentru procedura care evalueaza expresia:
e:=a/(b+c)+d/(b-a)+c*d*a;
lista parametrilor contine:
- sublista datelor de intrare a,b,c,d
- sublista rezultatelor formata numai din variabila e
- sublista variabilelor de stare formata din variabila vb care este vb:=0 daca rezultatul este corect, vb=1 daca expresia nu s-a calculat pentru ca (b+c)==0, vb=10 daca expresia nu s-a calculat pentru ca (b-a)==0 si vb=11 daca simultan (b-a)==0 si (b+c)==0.
Se atribuie variabilei e valoarea -1 daca nu se poate efectua evaluarea expresiei.
Procedura este:
void calcul(int a, int b, int c, int d, int *pe, int *pvb) {
*pvb=0; if((b+c)==0)*pvb+=1;
if((b-a)==0) *pvb+=10;
if(*pvb!=0)*pe=-1;
else
*pe=a/(b+c)+d/(b-a)+c*d*a;
}
Daca se adopta sa se lucreze cu proceduri, toate procedurile vor fi de tip void. In cazul in care stilul de programare este definit sa se lucreze astfel incat toate functiile returneaza variabila de stare vb, se efectueaza modificarile de proiectare a codului.
Procedura calcul devine:
int calcul(int a, int b, int c, int d, int *pe, ) {
int vb;
vb=0;
if((b+c)==0)vb+=1;
if((b-a)==0) vb+=10;
if(*pvb!=0)*pe=-1;
else
*pe=a/(b+c)+d/(b-a)+c*d*a;
return (vb); }
Toate functiile vor fi croite sa returneze coduri.
Programatorul va construi in timp o lista de coduri care include toate tipurile de erori care se intalnesc.
000 - rezultate corect si complet al prelucrarii
001 - prelucrare corecta dar incompleta
002 - numitor nul
003 - numar in afara limitelor impuse de utilizator
004 - depasire de capacitate
...............................
Procedurile si functiile au nume care reflecta prelucrarile pe care le efectueaza.
revenire

Omogenitatea secventelor de cod
Secventele de cod trebuie sa fie omogene, calitate obtinuta prin:
- utilizarea acelorasi instructiuni si operatori pentru aceleasi prelucrari
- gruparea instructiunilor pe operatii cat mai apropiate unele de altele
- scrierea de functii care dezvolta operatii cu acelasi nivel de complexitate.
Pentru expresia
variabila:=variabila+1;
ori se foloseste aceasta expresie, ori se foloseste mereu operatorul de incrementare.
Stilul de programare presupune consecventa in folosirea unei conventii.
Intr-un program se va scrie:
for(i=0; i {
s1+=x[i];
s2+=y[i];
s3+=x[i]*y[i];
}
folosind consecvent operatorul +=.
In secventa:
for(i=0; i {
s1+=x[i];
s2+=y[i];
s3+=x[i]*y[i];
}
j=0; for(; j {
ss1=ss1+x[j]*x[j];
ss2+=y[j];
ss3=ss3+x[j]*y[j];
}
se observa lipsa de consecventa in a utiliza operatorul ++ si operatorul +=.
Desi exista o multitudine de modalitati de definire si initializare a variabilelor, daca se stabilesc reguli, acestea trebuie respectate.
Pastrarea acestor reguli conduca la eliminarea diferentelor semnificative dintre programe.
Omogenitatea apare si intre outputurile programatorilor
Este ca si cum se da o aceeasi problema la 100 de programatori care lucreaza independent.
Procedura rezultata nu difera semnificativ prin:
- numar de linii sursa
- mod de definire variabile
- cum se compun instructiunile if()
- ce instructiuni repetitive si ce contin ele
- revenirea in programul apelator, ca numar de instructiuni return()
- dispunerea liniilor sursa pe pagina
- compunerea pe blocuri
- lungimea listei de parametri si dispunerea parametrilor.
revenire

Utilizarea etichetelor
Etichetele sunt elemente legate de instructiunile de salt neconditionat
Cum in programarea moderna instructiunea
goto este evitata, in programe nu apar instructiuni etichetate.
Pentru procesul de depanare sunt necesare etichete asociate instructiunilor.
Programatorul va defini etichete construite dupa reguli care sa-i permita regasirea cu usurinta a instructiunilor.
Aceste reguli sunt:
- includerea in numele etichetei o secventa de cifre care sa asigure ordinea crescatoare
- simularea termenilor unei progresii aritmetice care chiar daca se insereaza si alte etichete, ordinea sa ramana crescatoare
- de la procedura la procedura, numele etichetelor preiau ceva din numele fiecarei proceduri.
int sortare(.............)
{
............
sort0010: i++;
..............
sort0050: s++art[i].salariu;
................
...............
sort0400: printf("\n rezultat=%d", rezultat);
..............
return(total);
}
In cazul in care exista proceduri de calcul care includ o serie de elemente constante, este rezonabil ca in denumire sa fie incluse aceste constante si dispunerea procedurilor in textul sursa sa fie ori in ordine alfabetica ori tinand seama de aceste constante asigurand o ordine crescatoare, ori tinand seama de ambele aspecte.
int adunare(......);
char analiza(.........);
char comparare(..........);
char teste(.............);
int calcul0010(...........);
int calcul0050(...........);
int calcul0150(...........);
int calcul0250(...........);
int calcul0350(...........);
int calcul0450(...........);
int total0050(...........);
int total0150(...........);
int total0250(...........);
long double invmat(............);
Ordonarea se efectueaza dupa tip si in interiorul fiecarui tip, dupa nume.
daca numele este acelasi se adauga o secventa cifrica asigurand dispunerea in ordine crescatoare.
Omogenitatea programelor inseamna a accepta si a aplica aceasta regula.
revenire

Construirea de blocuri
Blocurile definesc entitati cu comportament similar intr-un context dat.
O functie sau o procedura sau chiar programul principal sunt formate din cate un bloc.
Ele devin in acest fel constructii bine delimitate.
Programatorul preia subprobleme pentru care elaboreaza componente.
Este convenabil daca fiecarei subprobleme ii corespunde un bloc.
In cazul in care se realizeaza repetarea unor prelucrari, acestea se grupeaza in cadrul unui bloc.
Marimea blocului depinde strict de conceptia de elaborare a programelor.
Stilul de programare este cel care defineste:
- gradul de omogenitate a blocului
- dimensiunea blocului
- pozitia blocului in instructiuni compuse
- nivelurile de imbricare ale blocurilor.
Pentru calculul sumelor slin[] a elementelor de pe liniile si a sumelor scol[] a elementelor de pe coloanele unei matrice a[][], variantele de program sunt:
varianta 1
...................
int a[10][10];
int slin[10];
int scol[10];
int i,j;
int nrlin,nrcol;
..............
for(i=0; i scol[i]=0;
for(j=0;j slin[j]=0;
for(i=0; i for(j=0;j {
scol[i]+=a[j][i];
slin[j]+=a[j][i];
}
Aceasta varianta include un singur bloc.
Volumul de prelucrari VP1 include:
2*nrcol operatii elementare pentru initializarea elementelor scol[i]
2*nrlin operatii elementare pentru initializarea elementelor slin[j]
3*nrlin*nrcol operatii pentru insumarea elementelor matricei a[j][i]
nrcol repetari ale instructiunii for() cu blocul de insumare, adica:
VP1=2*(nrlin+nrcol)+nrcol(1+3*nrlin)
varianta 2
...................
int a[10][10];
int slin[10];
int scol[10];
int i,j;
int nrlin,nrcol;
..............
for(j=0;j slin[j]=0;
for(i=0; i {
scol[i]=0; for(j=0;j {
scol[i]+=a[j][i];
slin[j]+=a[j][i];
}
Aceasta varianta include un singur bloc.
Volumul de prelucrari VP3 include:
2*nrlin operatii elementare pentru initializarea elementelor slin[j]
3*nrlin*nrcol operatii pentru insumarea elementelor matricei a[j][i]
2*nrcol repetari ale instructiunii for() cu blocul de insumare si initializare elemente scol[i], adica:
VP2=2*nrlin+nrcol*(2+3*nrlin)
varianta 3
...................
int a[10][10];
int slin[10];
int scol[10];
int i,j;
int nrlin,nrcol;
..............
for(i=0; i for(j=0;j {
if(i==0)scol[i]=0;
if(j==0)slin[j]=0;
scol[i]+=a[j][i];
slin[j]+=a[j][i];
}
Aceasta varianta include un singur bloc.
Volumul de prelucrari VP3 include:
nrcol operatii elementare pentru for(i=0;i 5*nrlin*nrcol operatii pentru insumarea elementelor matricei a[j][i]
nrcol repetari ale instructiunii for() cu blocul de insumare, adica:
VP3=nrcol+5*nrcol*nrlin
Exista diferente intre cele treivolume de prelucrari, derivate din secvente ce difera de modul in care au fost regrupate in blocuri instructiunile.
Exista situatii in care in instructiunea if() se utilizeaza blocuri vide, dar daca se schimba sensul de evaluare prin folosirea operatorului de negare, aceasta situatie se schimba si constructia se simplifica.
In loc de:
if(conditie) { bloc vid }
else
{ secventa de
instructiuni
}
se va folosi constructia:
if(!conditie)
{
secventa de
instructiuni
}
Blocurile reprezinta pentru procesul de mentenanta elementul cheie intrucat schimbarile la nivel de bloc sunt cele mai usor de realizat, daca programul este bine structurat pe blocuri.
revenire

Reutilizarea de cod
La nivelul companiilor care elaboreaza software sau a echipelor de dezvoltare software stilul de programare se construieste pas de pas prin comunicare intre programatori si prin acceptarea de catre acestia:
- a secventelor eficiente de instructiuni
- a procedurilor care sa faca obiectul reutilizarii
- a conventiilor de definire a variabilelor
- a modalitatilor de initializare.
reutilizarea de cod presupune:
- crearea de biblioteci de proceduri
- dezvoltarea de biblioteci de clase
- asigurarea calitatii componentelor incluse in biblioteci
- asigurarea usurintei in referirea componentelor din biblioteci
- mentinerea stabilitatii componentelor din biblioteci.
In biblioteci se stocheaza proceduri in care au parametri despre care cei ce le vor referi stiu ce semnificatie au si mai ales ce tip si ce dimensiune au.
Impunerea reutilizarii prin includere a unor fisiere de linii sursa cu restrictia de a nu modifica continutul acelor fisiere asigura mentinerea conceptiei unitare de abordare.
Daca in fisier se gasesc variabilele definite si initializate, programatorii sunt obligati sa foloseasca in programe acele definiri.
Daca in biblioteci se gasesc proceduri suficient de generale, programatorii isi adapteaza propriile proceduri astfel incat sa dispuna de toate elementele necesare transmiterii de parametri spre acele proceduri din biblioteca.
Reutilizarea de cod impune ca dupa fiecare procedura referita din biblioteca sa exista instructiuni care verifica modul in care s-a efectuat prelucrarea si sa determine continuarea prelucrarii numai daca ceea ce a transmis ca rezultat procedura apelata este exeact ceea ce trebuie ca sa se continue.
Managementul stilului de programare

Managementul presupune:
- imbogatirea cu reguli noi care asigura eficienta muncii programatorilor
- schimbarea stilului de programare atunci cand se trece la o noua tehnica de programare
- crearea unui climat bun de comunicare intre programatori in vederea obtinerii unor abordari care prin generalizare conduc la cresterea productivitatii programatorilor si la cresterea calitatii programelor
- masurarea consumurilor de resurse pe care le genereaza solutiile de programare supuse unui proces de generalizare, pentru a obtine in final programe performante
- diferentierea programatorilor dupa contributia la definirea stilului de programare si mai ales dupa modul in care asigura respectarea stilului definit
- impunerea ca regula in stilul de programare includerea de comentarii in secventele de program
- crearea de fluxuri precise de evaluare a stilului de programare si mai ales stabilirea efectelor negative atunci cand stilul de programare nu a fost respectat
- asigurarea transparentei in asa fel incat insusirea stilului de programare sa decurga natural, prin avantajele demonstrate asupra calitatii programului si asupra productivitatii programatoruilor
- definirea unui proiect distinct si urmarirea etapelor de perfectionare a stilului de programare ca element esential in managementul de dezvoltare a proiectelor software.
revenire

revenire