Expresii cu variabile pointer la referirea elementelor din masive

Dacă cineva vrea să folosescă în programe construcții omogene și în program să apară preponderent lucru cu variabile pointer, are mii de posibilități să facă acest lucru lejer, frumos și interesant.

Un programator va scrie secvența:

int x[100];

int i, n, s=0;

..............

for(i=0, i<n, i++) s+=x[i];

...............

dar tot at\t de bine, folosind faptul v[ v este de fapt un pointer spre o zonă de memorie de 100 de cuvinte alocate la definire, folosind variabila pointer v se va scrie:

for(i=0, i<n, i++) s+=*(x+i);

Aritmetica de pointeri arată că variabila i se incrementeaz[ cu lungimea unui cuvânt.

parantezele rotunde au prioritatea 1, deci ele se evaluează primele, ceea ce înseamnă că la adresa lui x se adună de i ori lungimea unui cuvânt, ceea ce duce la aflarea adresei elementului al i-lea din vector. Operatorul de referire are prioritatea 2 ceea ce înseamnă că se execută după evaluarea expresiei din paranteze. Deci referirea înseamnă extragerea conținutului din zona de memorie a cărei adresă a fost calculată.

Dacă se lucrează cu masive bidimensionale lucrurile stau tot așa, ceea ce permite și o generalizare.

int xx[17][12];

int i, j, n=9, m=11, s=0;

..............

for(i=0, i<n, i++) 

for(j=0, i<m, i++) s+=xx[i][j];

...............

Masivul bidimensional xx este de fapt o variabilă pointer spre pointer, adică are dpuă niveluri de indirectare. În loc de xx[i][j] se va scrie *(*(xx+i)+j) și aplicând regulile de de parcurgere de la stânga spre dreapta și restricțiile de la aritmetica de pointeri se va obține adresa elementului xx[i][j]. Se știe că xx+i înseamnă că la adresa lui xx se adaugă 12 de înmulțit cu lungimea cuvântului, așa cum este definită variabila de tip întreg. Se obține adrea de început a liniei i din matrice. Apoi se adaugă deplasarea elementului j și primul * din partea stângă ca permite referitea elementului de la acea adresă, adică a elementului xx[i][j], cum cere algoritmul de evaluare a sumei elementelor unei matrice. Pentru un masiv tridimensional definit prin:

int yy[17][12][18];

referirea elementului yy[i][j][k] se va realiza folosind variabila pointer yy care are trei niveluri de indirectare cu expfresia:

*(*(*((yy+i)+j)+k). 

.......

for(i=0, i<n, i++) 

for(j=0, i<m, i++) s+=*(*(*((yy+i)+j)+k);

Frumos, nu?
Lucrul cu aceste expresii este perfect în momentul în care are loc alocarea dinamică a masivelor uni, bi și tridimensionale, ceea ce dă o mare șansă programatorilor de a ameliora gradul de ocupare al zonelor de memorie.

(15 noiembrie 2017)

Lucru cu variabile pointer

Istoria informaticii românești ar comite o mare greșeală dacră ar consemna faptul că variabilele pointer au venit în programare să zicem cu limbajul PASCAL sau cu limbajul C. S-a lucrat cu variabile pointer masiv în limbajele de asamblare, căci mai toate limbajele de asamblare au avut modul de adresare indirectă și posibilitatea de a încărca în diferite zone de memorie deplasări ale variabilelor, așa-zisele adrese chiar la definirea de variabile. Ceea ce se numește acum aritmetica pointerilor, exista și în programarea în limbaje de asamblare, numai că programatorii erau obligați să respecte regulile pentru a face referiri corecte de variabile, știută fiind obligativitatea ca adresele operanzilor să fie niște numere divizibile prin niște constante, funcție de tipul operației care se executa, căci una este să lucrezi cu operanzi pe 2 baiți, alta este ca operandul să fie definit pe 4 baiți și tot așa.

Definirea și referirea variabilelor pointer elementare se realizează prin instrucțiunile de forma:

tip_variabilă_elementară  *nume_variabilă_pointer, nume variabilă_elementară;

........................

nume_variabilă_pointer=&nume variabilă_elementară;

......................................

*nume_variabilă_pointer=valoare;

...............................

Exemplu:

#include <stdio.h>

void main()

{

    int *pa, *pb, *pc, *pe, a=5, b=7, c=12, e;

    pa=&a;

    pb=&b;

    pc=&c;

    pe=&e;

   *pe=*pa+*pb+*pc;

    printf("e = %d",*pe);

}

Programatorul are la dispoziție posibilitatea de a defini variabile pointer și de a le inițializa la definire prin construcții de forma:

int a=5, b=7, c=12, e, *pa=&a, *pb=&b, *pc=&c, *pe=&e ;

Dacă nu s-ar lucra cu variabile pointeri exemplud de mai sus ar arăta astfel:

void main()

{

    int  a=5, b=7, c-12, e;

    e=a+b+c;

   printf("e = %d",e);

}

ceea ce este cu mult mai simplu. Numai că rolul variabilelor pointer este să permită evaluarea unei aceleiași expresii cu alți operanzi și scrierea să fie în forme cu mult mai concentrate.

void main()

{

    int *pa, *pb, *pc, *pe, a=5, b=7, c=12, e;

    int *px, *py, *pz, *pw, x=5, y=7, z=12, w;

    pa=&a; px=&x;

    pb=&b; py=&y;

    pc=&c; px=&z;

    pe=&e;pw=&w;

   *pe=*pa+*pb+*pc;

   *pw=*px+*py+*pz;

    printf("e = %d",*pe);

    printf("w = %d",*pw);

}

Cei ce au venit din programarea în limbaj de asamblare au înțeles marile avantaje oferite de variabilele pointer mai ales atunci când lucrează cu proceduri și trebuie să returneze nu o singură valoare. Ei concentrează acea mulțime de rezultate ce trebuie returnate într-o variabilă agregată și procedura returnează un rezultat care este de fapt o variabilă pointer. Deci inseamnă că funcția returnează un ponter spre un vector sau spre o matrice sau returnează un pointer spre o variabilă de tip struct.
Funcția care inițializează un vector cu date de la tastatură este:
int *initvector (int n).

{

int v[100], i;
for(i=0; i<n; i++)
   {
    printf("componenta  v[ %d] ",i);
    scanf("%d ",&v[i]);
    }
    return (v);

}
O funcție care returnează și valoarea lui n dar și vectorul va impune definirea unei variavile de structură:
struct alfa {
                 int n;
                 int v[100];
                 }, *palfa;

Pentru a simplifica lucrurile cu typedef se definește un tip beta de dată struct și apoi se face fix orice cu el, inclusiv se impune ca funcția să returneze un pointer spre o variabilă pointer de acel tip structurat.
* beta initvector()
          {
           beta *prezult;
           ............
           return (rezult);
           }

(15 noiembrie 2017)

Program pentru formula lui HERON

Programul în FORTRAN IV pentru calcului ariei triunghiului folosind forma lui HERON este:
C Calculul areiei triunghiului cu formula lui HERON
C cititorul de cartele are simbolul 5
C imprimanta are simbolul 6
C Daca apar erori in date se tipareste un mesaj
C Unitatea de masura este metrul, m
  10 FORMAT(3I5)
  20 FORMAT(4H A= ,I5,5H  B= ,I5,5H  C= ,I5,8H  AREA= ,F10.2,
     $13H Matri PATRATI)
  30 FORMAT(14SFARSIT NORNAL)
  40 FORMAT(53HEROARE IN DATELE DE INTRARE, TOATE VALORILE SUNT ZERO)
      INTEGER A,B,C
   50 READ(5,10) A,B,C
      IF(A.EQ.0 .AND. B.EQ.0 .AND. C.EQ.0) GO TO 60
      IF(A.EQ.0 .OR.  B.EQ.0 .OR.  C.EQ.0) GO TO 70
      S = (A + B + C) / 2.0
      AREA = SQRT( S * (S - A) * (S - B) * (S - C) )
      WRITE(6,20) A,B,C,AREA
      GO TO 10
   60 WRITE(6,40)
      STOP
   70 WRITE(6,40)
      STOP
      END
Programul C pentru calculul ariei triunghiului folosind forma lui HERON este:
/* Program C pentru calculul ariei unui triunghi cu formula lui HERON */
#include<stdio.h>
#include<math.h>
void main()
{
     float a,b,c,p=0,s=0;
     printf("Introduceti lungimile in metri ale laturilor triunghiului \n");
     scanf("%f %f %f",&a,&b,&c)
     if(a>0 && b>0 && c>0)
              {
                  p = (a+b+c)/2.0; /* s este semiparametrul*/
                  s = (sqrt)(p*(p-a)*(p-b)*(p-c));
                  printf("\n Area of triangle =\t %f",s);
               }
               else printf("\n Laturile nu formează un triunghi");
     getch();
}
Programul PASCAL pentru calculul ariei triunghiului folosind forma lui HERON este:
{.Program SuprafataTriunghului.}
var
A:real;
B:real;
C:real;
S:real;
P:real;
begin
    writeln ('Introduceti prima latura');
    read (A);
    writeln ('Introduceti a doua latura');
    read (B);
    writeln ('Introduceti a treia latura');
    read (C);
    if(A>0)AND (B>0)AND (C>0) then
            {
             P:=(A+B+C)/2;
             S:= Sqrt(P*((P-A)*(P-B)*(P-C)));
             writeln ('Suprafata triunghi = ', S);
            }
             else writeln ('Valorile nu formeaza laturi triunghi');
 end.
Programul COBOL pentru calculul ariei triunghiului folosind forma lui HERON este:
IDENTIFICATION DIVISION.
PROGRAM-ID.  Formula-Heron.
AUTHOR.  Ion IVAN.
DATA DIVISION.
WORKING-STORAGE SECTION.
77  A           PIC 9(5)  VALUE ZEROS.
77  B           PIC 9(5)  VALUE ZEROS.
77  V           PIC 9(5)  VALUE ZEROS.
77  SUM     PIC 9(5)  VALUE ZEROS.
77  P           PIC 9(5)V99  VALUE ZEROS.
77  TMP1   PIC 9(5)V99  VALUE ZEROS.
77  TMP2   PIC 9(5)V99  VALUE ZEROS.
77  TMP3   PIC 9(5)V99  VALUE ZEROS.
77  S           PIC 9(8)V99  VALUE ZEROS.
PROCEDURE DIVISION.
CITIRE-DATE.
       DISPLAY "Introduceti prima latura a triunghiului : " WITH NO ADVANCING.
       ACCEPT A.
       DISPLAY "Introduceti a doua latura a triunghiului : " WITH NO ADVANCING.
       ACCEPT B.
       DISPLAY "Introduceti a treia latura a triunghiului : " WITH NO ADVANCING.
       ACCEPT C
CALCULE..
       ADD A TO SUM.
       ADD B TO SUM.
       ADD C TO SUM.
       DIVIDE 2 INTO SUM GIVING P.
       SUBTRACT A FROM P GIVING TMP1.
       SUBTRACT B FROM P GIVING TMP2.
       SUBTRACT C FROM P GIVING TMP3.
       COMPUTE S=P*TMP1*TPM2*TMP3.
       COMPUTE S=S**.5.
       DISPLAY "Aria triunghiului este = ", S.
    SFARSIT-PROGRAM.
    STOP RUN.
În programul COBOL și calculul celebrei expresii se realiza lălăit bucată cu bucată, dar am preferat folosirea lui COMPUTE, iar pentru extragere de radical numai folosind ridicarea la puterea 0.5 s-a realizat calculul exact al expresiei așa cum zice geometria.
Sunt interesante abordările și se vede că limbajul C este de departe cel mai comod pentru a soluționa această problemă.
Programul pentru formula lui HERON scris în diferite limbaje de programare evidențiază diferențele dintre aceste limbaje și direcționează programatorii spre a pune în corespondență tipuri de probleme cu tipuri de limbaje de programare.

(14 noiembrie 2017)

Structurarea pe blocuri

Limbajele de programare permit implementări care asigură încărcarea echilibrată a membrilor unei echipe de programatori, ceea ce înseamnă că aceștia au posibilitatea de a lucra cu unități de program numite fie module, fie blocuri, fiecare dintre ele având reguli proprii de asamblare a părților în întreg.
Sunt limbaje în care se lucrează cu blocuri delimitate prin acolade, {,  }.
Sunt limbaje care permit lucru cu subprograme care se constituie în entități independente.
Sunt limbaje care sunt structurate pe secvențe delimitate prin etichete.
Indiferent cum stau lucrurile, trebuie definite variabile pe diferite niveluri și gestionat conținutul acestora astfel încât să nu apară rezultate imprevizibile. Limbajele PASCAL și C operează cu variabile locale în raport cu blocul definit prin acolade, fiind considerate variabile locale, întrucât alocarea lor se realizaeză la intrarea în bloc și care se dealocă la ieșirea din bloc.

În lucru acum

(13 noiembrie 2017)

Alcătuirea bibliotecilor standard

Limbajele de programare au biblioteci standard care sunt asociate programelor prin comanda include.
Limbajul PASCAL conține biblioteci pentru:
- conversii;
- calcule matematice abs(), odd(), sqr(), sqrt(), sin(), cos(), ln(), exp();
- alocare dinamică a memoriei new, dispose, ;
- șiruri de caractere StrConcat(), StrDelete(), StrInsert(), StrLen(), StrScan(), StrSize(),
  SubStr(),Delete(), Insert(), Copy(), Length(), Str();

- lucru cu pointeri address(), Ofs(), Addr(), RawPointer(), peek(), poke(), Move(), Seg();

- generare numere pseudoaleatoare initrandom(), random();

- funcții pe mulțimi succ(), pred();

Limbajul  are biblioteci pentru:

- funcții matematice care se inserează în programe cu <math.h>;

- funcții de manipulare șiruri care se inserează în programe cu<string.h>;

- funcții matematice cu numere complexe se inserează în programe cu <complex.h>;

- funcții de gestiune a timpului din calculator care se inserează în programe cu <time.h>.
Limbajul C conține cu mult mai multe biblioteci precum <stdio.h>, <limits.h>, <stddef.h> și multe altele. Este necesar după ce programatorul se familiarizează cu limbajul să treacă la studierea acestor biblioteci și cu mare atenție să vadp ce parametri au funcțiile, dar mai elas ce returnează ele, căci el are posibilitatea de a exploata acele rezultate returnate, precum se întâmplă la instrucțiunile de citire scriere dar și la cele de deschidere, repsectiv de închidere de fișiere unde numărul returnat dă informații prețioase pe care programatorul le introduce inteligent în expresii condiționale și după aceea în secvențe compuse în care apare if(), neinițiații mirându-se siderați.

În lucru acum

(13 noiembrie 2017)

Sintaxa limbajului

Înainte de orice, programatorul trebuie să citească cu atenție regulile de sintaxă ale limbajului pentru a ști:
- ce să ceară limbajului;
- ce are voie să scrie în programe;
- care este lista de cuvinte cheie;
- care este setul de caractere utilizat;
- ce nu are voie să construiască;
- cum se termină o instrucțiune;
- ce rol alre spațiul între cuvinte;
- care este diferența între - și _;
- cum se scriu comentariile;
- ce este obligatoriu și ce nu.
Sunt definite complet folosind diferite modalități toate limbajele de programare. Cel mai frecvent este folosită pentru a descrie sintaxa unui limbaj BNF - Backus-Naur Form.
Pentru expresiile unare din limbajul C se propune definirea:
<unary-expression> ::= <postfix-expression>
                     | ++ <unary-expression>
                     | -- <unary-expression>
                     | <unary-operator> <cast-expression>
                     | sizeof <unary-expression>
                     | sizeof <type-name>
Toate celelalte definiri sunt date la adresa, unde construcțiile se realizează din aproape în aproape. Intrând pe Internet se găsesc definirile BNF pentru toate limbajele de programare. Este esențial să se citească și elementele cantitative referitoare la lungimi, complexități și niveluri de indirectare.
În FORTRAN numărul maxim de dimensiuni este 7 pentru masive.
În limbajul C numărul maxim al nivelurilor de indirectare este 3.
În COBOL lungimea etichetelor nu depășește 31 de caractere.

În lucru acum

(13 noiembrie 2017)

Implementarea structurilor fundamentale de control

Structurile fundamentale sunt:

• structura liniară în care instrucțiunile se execută una după cealaltă;
• structura alternativă în care se produce o selecție funcție de care se execută una sau alta dintre instrucțiuni, după care se revine la execuție în secvență:
• structura repetitivă în care o anumită secvență de instrucțiuni se execută de mai multe ori, fie că numărul de repetări este cunoscut, fie până când o condiție este îndeplinită și numărul de repetări nu este cunoscut de dinainte;
• structura alternativă multiplă care presupune selectarea dintre mai multe secvențe de instrucțiuni a uneia care se execută la un moment dat, după care se revine la execuția în secvență a altor instrucțiuni.

De la limbaj la limbaj există diferite implementări ale acestor structuri de control și am mari dubii că sunt prea multe limbajele în care să nu existe instrucțiunea IF() THEN....ELSE.
Limbajul de asamblare conține tot felul de implementări și încă libere ale structurilor de control. Dacă în FORTRAN nu sunt permise intersecțiile de domenii în secvențele de program scrise în limbaj de asamblare așa ceva este permis. În limbajele de asamblare însă se construiesc secvențele pas cu pas, prin evaluări de expresii, comparări și salturi necondiționate cât îi poftește inima programatorului. Chiar dacă există instrucțiunea LOOP programatorul o gestionează chiar cum vrea el sau o ignoră construind repetitivitatea după pofta inimii cu evaluări, comparări și salturi condiționate combinate cu salturi necondiționate.

Limbajul FORTRAN implementează structurile fundamentale de control destul de ușor și simplu. Pentru structura alternativă implementarea este  prin:
IF(expresie) eticheta1,eticheta2,eticheta3

unde:
eticheta1 - dirijează execuția spre o secvență dacă expreia evaluată este mai mică decât  zero;
eticheta2 - dirijează execuția spre o secvență dacă expreia evaluată este egală cu zero;
eticheta3 - dirijează execuția spre o secvență dacă expreia evaluată este mai mare ca zero.
Structura repetitivă este implementată cu construcția:
                 DO eticheta  variabila_control = valoare_inițială, valoare_finală, rație
                 ......................
eticheta    ultima_instrucțiune_repetată
unde:
eticheta  - delimitează sfârșitul secvenței de repetat care începe după instrucțiunea DO;
variabila_control  - variabila cu care se gestionează numărul repetărilor, căci nivelul este între valoarea inițială și valoarea finală;
valoare_inițială - valoarea de start a variabilei de control;
valoare_finală - este valoarea limită superioară care nu este depășită de variabila de control; în caz de depășire repetarea este întrerultă;
rație - este o constantă sau o variabilă care arată cu cât se modifică variabila de control la iterația următoare.
Astructura alternativă multiplă este implementată în acest limbaj cu ceea ce se numea GO TO calculat, o construcție de forma:
GO TO (eticheta1, eticheta2, eticheta3,...., etichetan), variabilă_control
în care:
etichetai  -  arata la ce instrucțiune se face saltul dacă variabila_control este egală cu i:
variabila_control - este variavila care are valori cuprinse între 1 și n.
Acest limbaj nu are structura repetitivă condiționată anterior DO-WHILE și nici pe dea condiționată posterior, DO-UNTIL. Acestea se simulează folosind IF() și o întrețesere de instrucțiuni GO TO, ceea ce programarea structurată implementată forțat pentru FORTRAN IV se străduia să facă greoi, aproape imposibil de acceptat.
Limbajul C dispune de tot tacâmul de construcții pentru a implementa toate structurile de control fără mari probleme și tocmai de aceea a fost acceptat ca fiind un limbaj complet, ușor și prietenos.
Structura liniară este implementată folosind expresii aritmetice, expresii de atribuire dar și apeluri de funcții.
Structura alternativă este implementată folosind construcția:
if (expresie) {
                      secventa1;
                     }
                      else
                     {
                      secventa2;
                      }
dacă după evaluarea expresiei se obține că este adevărată se execută secventa1, În caz contrar se execută secventa2. Se observă că lipsește then pentru a selecta secventa1, lucru nenecesar, ci presupus, că nu tot ceea ce este în vorbirea curentă trebuie preluat în limbaj.
        

În lucru acum

(13 noiembrie 2017)

Modul de implementare a recursivității

Limbajul FORTRAN nu are implementată recursibitatea.
Limbajul COBOL nu are implementată recursibitatea.
Limbajul ALGOL nu are implementată recursibitatea.
Limbajul PASCAL are implementată recursibitatea chiar la nivel de definire de variabile.
Limbajul C are implementată recursibitatea chiar la nivel de definire de variabile.
Limbajele de  asamblare implementează recursibitatea prin gestionarea stivelor de către programator.

În lucru acum

(13 noiembrie 2017)

Modul în care se scriu comentariile

Cei ce au făcut mentenanță în programe FORTRAN și COBOL știu pe pielea lor de programatori care au fost binefacerile introducerii de comentarii în programe care au lămurit:
- semnificația datelor definite;
- semnificația secvențelor de prelucrare;
- localizarea sursei unde se află formulele de calcul;
- legislația care a stat la baza unor blocuri decizionale;
- numele programatorilor care au realizat textele;
- semnificația unor constante folosite pentru diferite stări;
- semnificația codurilor utilizate;
- restricții privind pentru definirile  parametrilor.
În limbajul FORTRAN comentariile sunt date de litera C pe prima coloană a formularului de programare.
În limbajul C pentru comentarii există două modalități de a le introduce:
- dacă se dorește mai multe linii de comentarii succesive se folosesc /* pentru debut și */ pentru final;
- dacă se dorește comentariu pentru o linie sursă se scrie un text oarecare după //.
În limbajul PASCAL comentariile se introduc prin (* texte oarecare *) sau  {*text oarecare *}, iar dacă se dorește pe linia unei instrucțiuni să se introducă un text se scrie // text oarecare.
În limbajele de asamblare comentariile diferă de la calculator la calculator.În limbajul ASSEMBLER al IBM comentariile încep cu un asterisc pe prima coloană. În limbajul ASSIRIS comentariul este și el la loc de cinste. În limbajul ASM cel folosit acum de toate PC-urile comentariile au în fața textului punct și virgulă, adică ; permițând scrierea în acest fel de texte pe o line dar și după fiecare instrucțiune pentru a lămuri semnificația acesteia.

În lucru acum

(13 noiembrie 2017)

Regula de evaluare a expresiilor

Limbajele de programare au operanzi și operatori cu care construiesc expresii mai complexe sau mai puțin complexe. Există o singură regulă de evaluare a expresiilor, indiferent care sunt acestea și această regulă vizează:
- prioritatea operatorilor;
- sensul de parcurgere în procesul de evaluare.
Pentru limbajul C există tabelul:

Prioritatea	Operator	Descrierea	Asociativitatea
1	++ --	Post incrementare, respectiv decrementare	Stânga la dreapta
	()	Apel funcție
	[]	Definire în masiv
	.	Referire membru în articol
	->	accesare pointeri în structuri
	(type){list}	Compunere literali
2	++ --	Pre Incrementare și pre decrementare	Dreapta la stânga
	+ -	Operatori unari
	! ~	negarea logică NOT și complement pe biți NOT
	(type)	Tipul
	*	Referirea lui
	&	Adrea lui
	sizeof	Lungimea lui
	_Alignof	Aliniere impusă
3	* / %	Înmulțire, împărțire și împărțire cu rest	Stânga la dreapta
4	+ -	Adunare și scădere
5	<< >>	Deplasare pe biți
6	< <=	Operatorul relațional  <  și ≤
	> >=	Operatorul relațional  >  și ≥
7	== !=	Operatorul relațional =  și  ≠
8	&	Operatorul și pe bițiAND
9	^	Operatorul logic sau exclusiv  XOR (exclusive or)
10	|	Operatorul logic sau iclusiv OR
11	&&	Operatorul logic AND
12	||	Operatorul logic OR
13	?:	Operatorul ternar	Dreapta la stânga
14	=	Simple assignment
	+= -=	Assignment by sum and difference
	*= /= %=	Atribuire cu operații aritmetice
	<<= >>=	Atribuirea cu deplasare biți spre stânga, dreapta
	&= ^= |=	Atribuirea cu operații pe biți AND, XOR, and OR
15	,	Virgula	Stânga la dreapta

Expresiile din parantezele rotunde se evaluează primele.
Expresia *alfa++ se evaluează *(alfa++) pentru că postincrementarea are prioritatea 1, iar operatorul de referire are prioritatea 2.
Expresia  a=3, b=5, c=7;
se evaluează de la stânga spre dreapta căci operatorul virgulă așa cere.  Se evaluează mai întâi atribuirea a=3, apoi se inițializează  b și la urmă se evaluează expresia c=7.
Expresia:
e = a < d ? a++ : a = d
se evaluează astfel:
e = ( ((a < d) ? (a++) : a) = d )
Operatorul = are prioritatea 14 și presupune evaluare de la stânga la dreapta.
Operatorul < are prioritatea 6.
Operatorul  de postincrementare ++ are prioritatea 1.
Operatorul ?: are prioritatea 13.
Se evaluează expresia a<d.
Dacă rezultatul evaluării este adevărat are loc postincrementarea și apoi e=a.
Dacă rezultatul evaluării nu este adevărat are loc atribuirea e=d.

În lucru acum

(13 noiembrie 2017)

Lista de operatori și rangurile lor

Un limbaj diferă de altul prin lista de operatori, listă care dă puterea unui limbaj. Operatorii sunt cei care spun de fapt ce se întâmplă cu zonele de memorie, până unde se merge , adică la ce nivel:
- bit;
- byte;
- șir de biți;
- cuvânt;
- dublu cuvânt;
- caracter;
- șir de caractere.

Limbajele mai slabe merg la nivel de byte și la nivel de cuvânt sau dublu cuvânt și șir de caractere. Limbajele mai sofisticate merg și în interiorul byte sau a cuvântului.
Lista operatorilor în limbajele de asamblare este dată de lista de instrucțiuni, căci fiecare cod de operație înseamnă un operator de fapt. Conchid că limbajul de asamblare are cea mai complexă listă de operatori și că în limbajul de asamblare se face orice cu orice. SE găsesc instrucțiuni pentru:
- operatorii aritmetici;
- operatorii de comparare;
- operatorii logici;
- operatorii pe șiruri de biți;
- operatori atribuire;
- operatori de inițializare;
- operatori incrementare/decrementare;
- operatorii pe șiruti de caractere.
Lista operatorilor în limbajul COBOL este  formată din:
- operatorii aritmetici + - * / **, add, subtract, multiply, divide;
- operatorii de comparare = < > <= >= <> less than, greater thac, equal to ;
- operatorii logici and, or, not ;
- operatorii pe șiruri de biți b-and, b-or, b-xor, b-not, b-left, b-right;
- operatori atribuire move, set, compute;
- operatori de inițializare move;
- operatorii pe șiruti de caractere move .
Lista operatorilor în limbajul C este  formată din:
- operatorii aritmetici +, -, *, /, %;
- operatorii de comparare == != ;
- operatorii logici !, &&, ||, or, not, ;
- operatorii pe șiruri de biți ~, &, |, ^,<<, >>  ;
- operatori atribuire compu;i +=,-=, *=,/=,%=,  |=, ^=, &=,<<=, >>= ;
- operatori de inițializare;
- operatori incrementare/decrementare ++, --;<, <=, !<, >,>=, !>
- operatori pentru membrii unei structuri agregate de date . și -> ;
- operatori cu pointeri & și *;
- operatorii pe șiruri de caractere definiți ca funcții  în biblioteca string.h.
În limbajul C virgula este operator. Există operatorul ternar ?:, dar și mulți alți operatori care sunt de fapt funcții implementate în limbaj precum sizeof(), new, delete, type și mulți alții.
Lista operatorilor în limbajul PASCAL este  formată din:
- operatori arithmetici +, -, *, /, %;
- operatori relationali =, <, <=, >, >=, <> ;
- operatori booleeni and, and  then, or, or else, not;
- operatori pe biți &, |, !, ~, <<, >> ;
- operatori pe mulțimi +, -, *, ><, <=, include, exclude, in;
- operatori pe șiruri de caractere sub forma unor funcții de bibliotecă.
Comparând listele operatorilor, se vede că limbajul C este cel mai puternic, dar după oricare alt limbaj de asamblare, deși limbajul PASCAL permite operare elegantă pe mulțimi.

În lucru acum

(13 noiembrie 2017)

Flexibilitatea de a defini tipuri și structuri de date

În lucru acum

(13 noiembrie 2017)

Setul de caractere

Fiecare limbaj are setul său de caractere.
Limbajul C are setul de caractere format din:
- literele mari de la A la Z, literele mici de la a la z;
- cifrele 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
- caracterele speciale  ~, %, |, @, +, <, _, -, >, ^, #, =, &, $, /, (, *, \, ), ′, :, [, ", ;, ], !, ,, {, ?, ., };
- caracterele denumite spații albe \b, \t, \v,  \r, \f, \n, \\, \’, \", \?, \0, \a, \x, \o.
Limbajul FORTRAN are setul de caractere format din:
- literele mari de la A la Z;
- cifrele 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;

- caractere speciale ., , (, ), =, +, -, /, *, **, $, blanc.
Limbajul COBOL are setul de caractere format din:
- literele mari de la A la Z;
- cifrele 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;

- caractere speciale ., , (, ), =, +, -, /, *, **,  blanc.
Limbajul PASCAL are setul de caractere format din:

- literele mari de la A la Z;
- literele mici de la a la z;
- cifrele 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;

- caractere speciale ., , (, ), =, +, -, /, *, **,  blanc, {, }, [, ], ;, :, =, <. >, ~, %, $, #, !.
Semnificația caracterelor trebuie studiată cu mare atenție căci nu este obligatoriu ca un simbol să aibă aceeași semnificație la toate limbajele de programare. Se învață un limbaj cunoscând diferențele față de limbajul anterior în care a lucrat programatorul, dar acele diiferențe trebuie nu identificate, ci învățate și trebuie ținut seama de ele.

În lucru acum

(13 noiembrie 2017)

Cuvintele cheie în limbajele de programare

Cuvintele cheie în limbajele de programare formează un vocabular și este obligatoriu ca programatorii să nu le folosească în alt scop decât cel care a fost stabilit în sintaxa limbajului. Sunt și limbaje care nu impun acestă restricție, dar mi se pare civilizat ca programatorii să nu le amestece printre numele lor de variabile sau de etichete pentru a nu crea confuzii în procesul de depanare sau de mentenanță, căci 99% dintre programatori nu schimbă semnificația nici a lui DO nici a lui IF nici a lui READ, nici a lui REAL, nici a lui INTEGER și nici a lui WRITE din FORTRAN.

Lista cuvintelor rezervate în limbajul COBOL este:

ACCEPT

ACCESS

ADD

ADDRESS

ADVANCING

AFTER

ALL

ALPHABET

ALPHABETIC

ALPHABETIC-LOWER

ALPHABETIC-UPPER

ALPHANUMERIC

ALPHANUMERIC-EDITED

ALSO

ALTER

ALTERNATE

AND

ANY

APPLY

ARE

AREA

AREAS

ASCENDING

ASSIGN

AT

AUTHOR

BASIS

BEFORE

BEGINNING

BINARY

BLANK

BLOCK

BOTTOM

BY

CALL

CANCEL

CBL

CD

CF

CH

CHARACTER

CHARACTERS

CLASS

CLASS-ID

CLOCK-UNITS

CLOSE

COBOL

CODE

CODE-SET

COLLATING

COLUMN

COM-REG

COMMA

COMMON

COMMUNICATION

COMP

COMP-1

COMP-2

COMP-3

COMP-4

COMP-5

COMPUTATIONAL

COMPUTATIONAL-1

COMPUTATIONAL-2

COMPUTATIONAL-3

COMPUTATIONAL-4

COMPUTATIONAL-5

COMPUTE

CONFIGURATION

CONTAINS

CONTENT

CONTINUE

CONTROL

CONTROLS

CONVERTING

COPY

CORR

CORRESPONDING

COUNT

CURRENCY

DATA

DATE-COMPILED

DATE-WRITTEN

DAY

DAY-OF-WEEK

DBCS

DE

DEBUG-CONTENTS

DEBUG-ITEM

DEBUG-LINE

DEBUG-NAME

DEBUG-SUB-1

DEBUG-SUB-2

DEBUG-SUB-3

DEBUGGING

DECIMAL-POINT

DECLARATIVES

DELETE

DELIMITED

DELIMITER

DEPENDING

DESCENDING

DESTINATION

DETAIL

DISPLAY

DISPLAY-1

DIVIDE

DIVISION

DOWN

DUPLICATES

DYNAMIC

EGCS

EGI

EJECT

ELSE

EMI

ENABLE

END

END-ADD

END-CALL

END-COMPUTE

END-DELETE

END-DIVIDE

END-EVALUATE

END-IF

END-INVOKE

END-MULTIPLY

END-OF-PAGE

END-PERFORM

END-READ

END-RECEIVE

END-RETURN

END-REWRITE

END-SEARCH

END-START

END-STRING

END-SUBTRACT

END-UNSTRING

END-WRITE

ENDING

ENTER

ENTRY

ENVIRONMENT

EOP

EQUAL

ERROR

ESI

EVALUATE

EVERY

EXCEPTION

EXIT

EXTEND

EXTERNAL

FALSE

FD

FILE

FILE-CONTROL

FILLER

FINAL

FIRST

FOOTING

FOR

FROM

FUNCTION

GENERATE

GIVING

GLOBAL

GO

GOBACK

GREATER

GROUP

HEADING

HIGH-VALUE

HIGH-VALUES

-O

I-O-CONTROL

ID

IDENTIFICATION

IF

IN

INDEX

INDEXED

INDICATE

INHERITS

INITIAL

INITIALIZE

INITIATE

INPUT

INPUT-OUTPUT

INSERT

INSPECT

INSTALLATION

INTO

INVALID

INVOKE

IS

UST

JUSTIFIED  

KANJI

KEY  

LABEL

LAST

LEADING

LEFT

LENGTH

LESS

LIMIT

LIMITS

LINAGE

LINAGE-COUNTER

LINE

LINE-COUNTER

LINES

LINKAGE

LOCAL-STORAGE

LOCK

LOW-VALUE

LOW-VALUES

MEMORY

MERGE

MESSAGE

METACLASS

METHOD

METHOD-ID

MODE

MODULES

MORE-LABELS

MOVE

MULTIPLE

MULTIPLY

NATIVE

NATIVE_BINARY

NEGATIVE

NEXT

NO

NOT

NULL

NULLS

NUMBER

NUMERIC

NUMERIC-EDITED

OBJECT

OBJECT-COMPUTER

OCCURS

OF

OFF

OMITTED

ON

OPEN

OPTIONAL

OR

ORDER

ORGANIZATION

OTHER

OUTPUT

OVERFLOW

OVERRIDE

PACKED-DECIMAL

PADDING

PAGE

PAGE-COUNTER

PASSWORD

PERFORM

PF

PH

PIC

PICTURE

PLUS

POINTER

POSITION

POSITIVE

PRINTING

PROCEDURE

PROCEDURE-POINTER

PROCEDURES

PROCEED

PROCESSING

PROGRAM

PROGRAM-ID

PURGE

QUEUE

QUOTE

QUOTES

RANDOM

RD

READ

READY

RECEIVE

RECORD

RECORDING

RECORDS

RECURSIVE

REDEFINES

REEL

REFERENCE

REFERENCES

RELATIVE

RELEASE

RELOAD

REMAINDER

REMOVAL

RENAMES

REPLACE

REPLACING

REPORT

REPORTING

REPORTS

REPOSITORY

RERUN

RESERVE

RESET

RETURN

RETURN-CODE

RETURNING

REVERSED

REWIND

REWRITE

RF

RH

RIGHT

ROUNDED

RUN

SAME

SD

SEARCH

SECTION

SECURITY

SEGMENT

SEGMENT-LIMIT

SELECT

SELF

SEND

SENTENCE

SEPARATE

SEQUENCE

SEQUENTIAL

SERVICE

SET

SHIFT-IN

SHIFT-OUT

SIGN

SIZE

SKIP1

SKIP2

SKIP3

SORT

SORT-CONTROL

SORT-CORE-SIZE

SORT-FILE-SIZE

SORT-MERGE

SORT-MESSAGE

SORT-MODE-SIZE

SORT-RETURN

SOURCE

SOURCE-COMPUTER

SPACE

SPACES

SPECIAL-NAMES

STANDARD

STANDARD-1

STANDARD-2

START

STATUS

STOP

STRING

SUB-QUEUE-1

SUB-QUEUE-2

SUB-QUEUE-3

SUBTRACT

SUM

SUPER

SUPPRESS

SYMBOLIC

SYNC

SYNCHRONIZED

TABLE

TALLY

TALLYING

TAPE

TERMINAL

TERMINATE

TEST

TEXT

THAN

THEN

THROUGH

THRU

TIME

TIMES

TITLE

TO

TOP

TRACE

TRAILING

TRUE

TYPE

UNIT

UNSTRING

UNTIL

UP

UPON

USAGE

USE

USING

VALUE

VALUES

VARYING

WHEN

WHEN-COMPILED

WITH

WORDS

WORKING-STORAGE

WRITE

WRITE-ONLY

ZERO

ZEROES

ZEROS

Este obligatoriu de a studia și actualiza această listă atunci când se scriu programe căci și limbajul COBOL a evoluat în ultimele decenii acceptând inclusiv abordarea obiectuală cu cuvinte cheie noi.

Lista cuvintelor rezervate în limbajul PASCAL este:

true, false

 +, -, *, /, 

div

mod

>=    <=  =, >  =  > <   <>

and

or

not

sqrt 

trunc

round

random

abs

length

ord

chr

val

str

copy

const

procedure

var

integer

real

char

string

Boolean

text

array..of

program

input

output

begin...end

 :=

for...to

downto...do, (*...*)

if...then...else

while...do,

repeat...until

case...of...end

write

writeln

read

readln

assign

reset

rewrite

eof

close

Lista cuvintelor rezervate în limbajul C++ este:
alignas
alignof
and
and_eq
asm
atomic_cancel
atomic_commit
atomic_noexcept
auto(1)
bitand
bitor
bool
break
case
catch
char
char16_t
char32_t
class
compl
concept
const
constexpr
const_cast
continue
co_await
co_return
co_yield
decltype
default
delete
do
double
dynamic_cast
else
enum
explicit
export
extern
false
float
for
friend
goto
if
import
inline
int
long
module
mutable(1)
namespace
new
noexcept
not
not_eq
nullptr
operator
or
or_eq
private
protected
public
register
reinterpret_cast
requires
return
short
signed
sizeof
static_assert
static_cast
struct(1)
switch
synchronized
template
this
thread_local
throw
true
try
typedef
typeid
typename
union
unsigned
using
virtual
void
volatile
wchar_t
while
xor
xor_eq
Limbajul C++ evoluează dramatic și o dată cu el lista cuvintelor rezervate și de aceea este important ca la fiecare versiune a limbajului această listă să se actualizeze ăentru a nu apare situații care scapă de sub control.

Lista cuvintelor rezervate în limbajul C este:
auto
break
case
char
const
continue
default
do
else
enum
extern
float
for
if
int
long
register
return
short
signed
goto
static
struct
switch
typedef
union
unsigned
void
sizeof
volatile
while.
Limbajul C a impresionat printr-o putere fantastică bazată pe un vocabular restrâns ca o chintesență a tot ceea ce cunoscuseră limbajele de dinaintea lui, forma fiind foarte concentrată.
Cuvintele rezervate ale limbajului PYTHON sunt:
and
as
assert
break
class
continue
def
del
elif
else
except
False
finally
for
from
global
if
import
in
is
lambda
None
not
nonlocal
or
pass
raise
return
True
try
while
with
yield.
Deși limbajul este foarte frecventat de programatori, o explicație se găsește în faptul că lungimea vocabularului de cuvinte rezervate este scurtă.

Cuvintele cheie în limbajele de programare arat[ cât de bogat este limbajul de programare sau din contră, dac[ este o listă foarte extinsă arată că acel limbaj are foarte multe constrângeri, așa cum este limbajul COBOL.

(12 noiembrie 2017)

(12 noiembrie 2017)

Atribuirea multiplă

Sunt situații în care limbajele de programare sunt considerate ca aparținând unei generații mai noi dacă anumite mecanisme sunt implementate. Dacă acele mecanisme se află la limbaje aparținând mai multor generații, lucrurile se complcă destul de tare.

dacă se dorește inițializarea unor variabile cu o aceeași valoare ca de exemplu

a=0

b=0

c=0

d=0

d=0

e=0

f=0

g=0

în limbajul COBOL totul se realizează folosind instrucțiunea

MOVE ZERO TO A, B, B, C, D, E, F, G.

în limbajul C sau în limbajul C++ se folosește expresia

a=b=c=d=d=e=f=g=0;

iar în limbajul PASCAL se folosește construcția

a:=b:=c:=d:=d:=e:=f:=g;=0;

în limbajul FORTRAN secvența va fi 

a=0

b=0

c=0

d=0

d=0

e=0

f=0

g=0       ceea ce arată destul de nasol.

Limbajul FORTRAN arată că este un limbaj de nivel scăzut, dar limbajul COBOL considerat cam de aceeași facută face excepție în acestaă situație punctuală.

Programatorii noștri au exploatat foarte mult  definirea la inițializare a variabilelor în toate limbajele. Atribuirea multiplă evidențiază cât de bun este programatorul, căci un programator bun scrie expresii foarte concentrate, exploatând la maximul facilitățile de la definirea limbajului.

(09 noiembrie 2017)

Istoria românească a limbajelor evoluate

Când spun limbaje evoluat zic limbajul  PASCAL și limbajul C. Aceste limbaje au fiecare tăticul lui. Pentru limbajul PASCAL tăticul a fost Niklaus WIRTH, iar limbajul a fost  creat cu puțin timp înainte de 1970. La noi a pătruns cam după 10 ani, dar mai sigur după 1977 când a fost produs calculatorul I-100. Tăticul limbajului C a fost Dennis RITCHIE, iar apariția limbajului s-a produs în anul 1972. Când am studiat limbajul PASCAL vedeam că era destul de apropiat de limbajul ALGOL, iar când am studiat limbajul C am văzut că avea frumusețea și simplitatea de la FORTRAN dar atât PASCA cât și C erau altceva, adică limbajul C era cel mai cel și de aceea el a prins foarte multe. Eu zic: ac, cui, nasture, C.  Atât de utile, atât de necesare, atât de simple!
Primele implementări superbe au fost făcute de compania Borland și tot timpul se vorbea ce Borland PASCAL și de Borland C. Această companie avea mediile de dezvoltare cele mai bune. După aceea au venit alții din urmă și poezia s-a dus, a făcut loc programării obiectual, unde reutilizarea însemna totul, iar arta prea puțin.
În C pentru a defini variabile de tip întreg se folosește cuvântul cheie int, în PASCAL se folosește cuvântul cheie integer, delimitat de lista de variabile prin două puncte. Trecerea de la 3 litere la 7 litere plus caracterul două puncte însemnând 8 caractere e o diferență supărătoare, iar FORTRN-iștii s-au enervat teribil.
În C o definire de forma:
int a,b,c,d:
devine în PASCAL
a,b,c,d: integer;
Operatorului de incremetare ++ din C  nu-i corespunde un operator în PASCAL. Ceea ce în FORTRAN se scria
x = x +1
în C devine:
x++;
iar în PASCAL
x:=x+1;
În FORTRAN sunt 5 caractere, în C sunt 4 caractere și în PASCAL sunt 7 caractere.
La definirea masivelor există deosebiri foarte mari între limbajele C și PASCAL, iar dacă îi luăm în calcul pe cei ce proveneau din zona FORTRAN ca programatori, lucrurile sunt și mai încurcate.
Pentru a defini un masiv unidimensionat cu 100 de componente de tip întreg în FORTRAN se folosea
integer x(100)
deci se folosesc 13 caractere,
iar pentru a defini același lucru în C se folosește:
int x[100];
se folosesc 10 caractere
în timp ce în PASCAL pentru a avea același efect definirea este:
x = array [1..100] of integer;
unde se folosesc 25 caractere fără separatorul blanc. În PASCAL se dă senzația modului în care este strigat Gheorghe bețivanul a lui Leana din deal,  la țară în loc de Gheorghe Popescu să zicem.
Lumea nu avrut să creadă că motivele din care limbajul PASCAL a fost abandonat nu sunt legate de puterea limbajului, putere comparabilă cu cea a limbajului C, ci datorită lungimilor supărătoare. Așa se explică faptul că americana este diferită de limba engleză de manual, clasică întrucât maericanii mănâncă litere din cuvinte tocmai pentru a se exprima rapid și concis și evită folosirea lui of și the. Trebuie să spun totuși că în zona variabilelor pointer limbajul PASCAL a depășit granița celor trei niveluri de indirectare, dar e mult prea puțin pentru a câștiga un război.
Delimitările dintre limbaje nu sunt concludente întotdeauna și atribuirea multiplă arată acest lucru.
Istoria românească a limbajelor evoluate arată cu claritate că programatorii noștri n-au prea scris software în PASCAL, ci în limbajul C iar mai apoi în C++ și C#, limbajul PASCAL părându-li-se greoi, vetust și aiurea.

(07 noiembrie 2017)

Istoria românească a limbajelor cod mașină

Istoria românească a limbajelor cod mașină este extrem de bogată pentru că:
- au fosty construite multe calculatoare electronice înainte de 1965;
- primele calculatoare erau originale și difereau unele de altele;
- calculatoarele cu tuburi și relee lucrau numai în cod mașină;
- ceea ce a pătruns de la alți constructori erau tot la nivelul de cod mașină;
- simțul practic a simplificat multe la designul limbajelor cod mașină.

Trebuie pornit de la ideia că în vremurile de demult se știau multe despre bazele de numerație, dar una era să se știe și cu totul altceva era să se și lucreze efectiv în acele baze de numerație cu ușurința de azi. De aceea superba bază B16 de azi era ocolită în anii '50 căci implementarea era problema din cauza vitezei de prelucrare și a capacității de memorie, ambele extrem de limitate. Calculatorul CIFA 1 avea 50 operații pe secundă și capacitate de memorie de 512 cuvinte a 4 biți fiecare cuvânt, adică 256 bytes de azi, adică 0,25 Kb, ceea ce este dramatic de puțin. Și totuși...
Când se programa în cod mașină trebuia lucrat numai cu numere pentru că:
- se lucra cu operanzi din memorie M și din registre/regiștri R;
- textul programului scris în limbaj natural este T;
- textul programului scris în cod mașină este T';
- operanzii erau stocați în zone de memorie ale căror adrese erau numere;
- operatorii erau puși în corespondență cu numere;
- totul era la nivel de operații elementare;
- operațiile elementare erau de tipul R-M, M-R și R-R;
- scrierea unui program se făcea mai întâi folosind cuvinte din limbajul natura, rezulta texul T;
- scrierea în cod mașină, doar cu cifre se făcea  ca proces de codificare a textului T în T';
- urma perforarea programului pe bandă de hârtie, rularea și obținere rezultate.
Entuziasmul a fost atât de mare încât dificultățile nu păreau dificil de trecut tocmai pentru că trecusem de la a lucra pe mașini mecanice sau electromecanice ce efectuau dor o singură operație, la lucru pe un automat numict calculator electronic care executa operații precum:
- adunări;
- scăderi;
- înmulțiri;
- împărțiri;
- comparații;
- salturi condiționale;
- salturi necondiționale;
- alocare cu inițializare;
- inițializări;
- atribuiri;
- încă altele multe dar nu câte are limbajul de asamblare de la microprocesoarele din ziua de azi care sunt de sub 256 dar nu cu mult sub acest număr.

       *
*           *

Istoria românească a limbajelor cod mașină este o pagină frumoasă, spumoasă, care stârnește nenumărate nostalgii. Mulți se întreabă:
- Cum a fost posibil așa ceva?
Răspunsul este banal, ca orice răspuns la o întrebare grea și anume:
- Iac-așa!
Muți de admirație mergem mai departe...
Voi veni cu detalii pe măsură ce voi găsi materiale despre listele de coduri de la diferitele calculatoare românești care lucrau în cod mașină precizând listele de coduri pentru operații, modurile de alocare de zone de memorie pentru operanzi, codificările pentru registre și restricțiile care nu erau deloc puține referitoare la tipurile de expresii de adresare, țtiut fiind faptul că nici în ziua de azi nu plouă cu operații de tip M-m și comutativitatea tipurilor de operanzi în expresiile de referire a operanzilor nu are gradul de generalitate pe care chiar ni l-am dori noi poeții care am creat Miorița și Balada Meșterului Manole, în ambele fiind vorba de crime și implicit de criminali. Ca și în acele creații folclorice, în programele scrise în cod mașină exista un secret și cheia descifrării rămânea cheie.

(07 noiembrie 2017)

Istoria românească a limbajeor de programare

Aici nu mi-am ropus să sciu despre limbaje de programare în ideia de a-i învăța pe cei dornici să lucreze cu calculatorul luând limbajele de ultmă generațue și să mă dau eu rotund cât de șmecher sunt în a programa folosind resursele acelor limbaje. Fiind ceba de istorie, voi scrie despre cum au penetrat limbajele de programare pe meleagurile noastre mioritice și cum au și dispărut, atunci când uzura lor morală le-au făcut să devină inutile și demodate.

Când la începutul anilor '70 am avut în mână cartea lui J.E. Sammet intitulată Programming Languages: History and Fundamentals, apărută în anul 1969,  mi s-a părut de-a dreptul bizar să facă cineva istorie știind că limbajul FORTRAN apăruse în 1950, limbajul COBOL apăruse și el în 1959 și eu știam că istorie înseamnă ceva cu mult mai vechi, mai hărtănit dacă nu chiar dispărut pe vecie. Iată acă acum la 67 de ani de la primul program FORTRAN scriu și eu ceva de istorie, dar nu în ideia cum au fost create și ce s-a întâmplat cu acele limbaje de programare ci despre:

- perioadele când au apărut programele la noi scrise folosindu-le;

- ieșirea limbajelor din decorul informaticii;

- eventuale implementări locale;

- limbaje specializate create la noi și implementate.

Dacă despre evenimentele de acum 2.000 e ani se vine cu mărturii scrise, cu fragmente de lespezi cu inscripționări, cu monumente legate de acele evenimente sau cu statui, în zona informaticii românești care nu depășește 70 de ani lucrurile sunt de un dramatism îngrozitor pentru că:

- nu s-au conservat calculatoare utilizate în vremurile de demult;

- nu s-au conservat imprimate cu programe scrise și datate  în vremurile de demult;

- nu există nici benzi magnetice, nici benzi perforate cu programe scrise în vremurile de demult;

- nu există brevete din care să rezulte software realizat  în vremurile de demult;

- nu există un catalog cu programe din care să rezulte drepturi de autori  în vremurile de demult;

- nu există un muzeu cu cărțile de limbaje de programare scrise în vremurile de demult;

- nu există planuri de învățământ în care să apară limbajele predate  în vremurile de demult.

Toate acum se reconstituie din frânturi, exact cum este cu limba dacă rezunată la cuvintele mânz, viezure varză, brânză,  lift.

Acum voi scrie ceea ce am identificat eu.

Cartea de FORTRAN a lui Petre DIMO a fost tipărită în 1971.

Cartea de programare în FORTRAN a lui Stelian NICULESCU a fost tipărită în 1972.

Celebra carte de FORTRAN a lui Horia GEORGESCU și Octavian BÂSCĂ a apărut în 1975.

În Centrul de calcul al ASE s-u rulat primele programe FORTRAN în 1969.

Eu am scris primele programe în FORTRAN în anul 1969 către sfârșit.

Cartea de COBOL a Margaretei DRĂGHICI a fost tipărită în 1972.

Vasile PETEANU, Sabin GORON, Geza VENCZEL, Ioan MOLDOVAN a apărut în 1976.

Cartea lui Ilie VĂDUVA, Gheorghe POPA, Vasile FLORESCU de COBOL a apărut în 1979.

În timp au apărut multe materiale în edituri cu chestii despre limbajele cele mai folosite.

Am a mă lăuda că sunt în posesia unei imprimante pe care este scris numele meu destul de veche cu un program scris în COBOL și ar constitui o piesă alături de altele dacă ar apare, pentru a sta mărturie peste timp că și la noi s-a făcut programare și în limbajul FORTRAN și în limbajul COBOL nu doar exemplificativ, ci concret pentru a rezolva probleme. La fosta Danubiana, dacă ar mai exista o arhivă, s-ar găsi acolo imprimante cu programe COBOL, știu sigur, că am scris și eu câteva și era în anul 1971, iar aplicațiile de BOMP foloseau și componente COBOL la greu căci în acele vremuri nu era niciun secret la câmpurile de adrese cu care se accesau articole din fișiere pentru a face descompunere de produse cu cumulare de repere. Eu am folosit documentație IBM de BOMP și cred că dacă mi s-ar da așa ceva, aș reconstitui cu acuratețe de unde am luat structurile de articole și ce-am făcut cu câmpurile, căci mi-au plăcut nespus de multe acele detalii și acele tehnici de regăsire a descrierii  articolelor din structurile arborescente folosind adrese din fișierele de legături.
Ca și la cechipamentele de calcul și în cazul limbajelor de programare se vorbește de generații de limbaje de programare, unde se identifică:

• prima generație de limbaje de programare, formată din limbajele cod mașină;
• a doua generație de limbaje de programare, formată din limbajele de asamblare;
• a treia generație de limbaje de programare, formată din limbajele FORTRAN, COBOL, Algol, BASIC, C, PASCAL,  C++, C#, Java, Ruby, Perl;
• a patra generație de limbaje de programare, formată din limbaje într-o listă foarte diversificată;
• a cincea generație de limbaje de programare, formată din limbajele inteligenței artificiale Lisp, XML, Planner, Prolog,Python.

Această împărțire mi se pare destul de imprecisă dacă se are în vedere faptul că totuși informatica manipulează seturi mari de date și limbajele de programare trebuie musai să se lipească de un SGBD pentru a fi în rândul utilizatorilor ce trebuie să transforme datele în informații și apoi informațiile în cunoștințe, chestie despre care toată lumea discută, dar eu nu am văzut un sistem expert care să se bazeze pe așa ceva și care să lucreze în economia reală și lumea să se bucure imens și veșnic.
Un programator trebuie să știe un limbaj de programare, oricare ar fi el, dar obligatoriu, pentru a fi programator de top mai trebuie să știe limbajul de asamblare al calculatoarelor cu care lucrează, pentru a înțelege bine cum stau lucrurile în programele pe care le scrie și le execute. În cariera sa programatorul învață tot timpul, fiind obligat să știe să lucreze cam la 7 ani cu un alt limbaj. Învățarea unui nou limbaj de programare se face prin diferențieri. Programatorul trebuie să știe la noul limbaj care sunt:
- setul de caractere;
- lista cuvintelor cheie;
- regulile de construire a identificatorilor;
- flexibilitatea de a defini tipuri și structuri de date ;
- lista de operatori și rangurile lor ;
- regula de evaluare a expresiilor ;
- modul în care se scriu comentariile ;
- modul de implementare a recursivității ;
- implementarea structurilor fundamentale de control ;
- alcătuirea bibliotecilor standard;
- sintaxa limbajului;
- structurarea pe blocuri.
Dacă programatorul a intuit cum stau lucrurile, va constata că multe lucruri se repetă de la un limbaj la altul și reținând diferențele ce apar la noul limbaj, dar folosind experiența de dinainte efortul nu este copleșitor de a trece la a scrie programe bune în noul limbaj. Lucrurile devin mai dificil de gestionat dacă limbajul vine cu o altă filosofie de programare. Programatorul nu trebuie să se năpustească el să scrie prorgame cu acel limbaj, ci să studieze programe scrise de alți programatori experimentați pentru a se familiariza cu noul context. este ca în poezie. Nimeni nu se va apuca să scrie poezie decât după ce a citit o sută de cărți de poezie.

(09 noiembrie 2017)