Тематический план

  • Общее

    • Curs
    1
    2
    Lucrări practice
    1
    2
    3
    4
    5
    Lucru individual
    •••
    Evaluări
    •••

  • Structura cursului (cu Java)

    • T1. Introducere & ecosistemul Java

      Obiective
      • înțelegerea principiului „write once, run anywhere” și rolul JVM;
      • identificarea componentelor JDK/JRE și a fluxului de build & run;
      • configurarea mediului (JDK, IDE, CLI) și rularea primului program;
      • cunoașterea versiunilor LTS și a managementului de versiuni.
      Cuvinte-cheie: JDK JRE JVM Bytecode JIT LTS CLI IDE
      JDK: kitul pentru dezvoltatori (include javac, instrumente și biblioteci).
      JRE: mediul de rulare (JVM + biblioteci) necesar execuției.
      JVM: mașina virtuală care execută bytecode pe orice platformă.
      Bytecode: cod intermediar generat de javac, portabil.
      JIT: compilare „Just-In-Time” pentru secvențe frecvente, crește performanța.
      LTS: versiuni cu suport extins (ex.: 8, 11, 17, 21).
      CLI: linie de comandă pentru build/rulare scriptată.
      IDE: medii integrate (IntelliJ, Eclipse, VS Code) cu editor și debug.

      T2. Structura lexicală a limbajului Java

      Obiective
      • recunoașterea tokenilor: identificatori, cuvinte-cheie, literali, operatori;
      • aplicarea regulilor de denumire (camelCase, PascalCase);
      • utilizarea corectă a separatoarelor și a comentariilor;
      • înțelegerea rolului spațiilor albe în parsing.
      Cuvinte-cheie: Identificator Literal Operator Separator Comentariu CamelCase Cuvânt-cheie
      Identificator: nume pentru clase/metode/variabile; nu începe cu cifră.
      Literal: valoare scrisă direct (numerică, booleană, caracter, șir, null).
      Operator: simbol al unei operații (aritmetică, logică, relațională).
      Separator: semne de punctuație: ;, ,, (), {} etc.
      Comentariu: // linie, /* */ bloc, /** */ Javadoc.
      CamelCase: prima literă mică, cuvintele interne capitalizate.
      Cuvânt-cheie: termen rezervat (ex.: class, if, return).

      T3. Tipuri de date. Controlul execuției. Vectori

      Obiective
      • clasificarea tipurilor primare și de referință;
      • utilizarea structurilor de control (if, switch, bucle);
      • inițializarea și parcurgerea vectorilor 1D/2D;
      • gestionarea conversiilor (widening/narrowing) și autoboxing;
      • aplicarea scurtcircuitării logice.
      Cuvinte-cheie: Primitive Referință Autoboxing Switch For-each Array 2D Short-circuit
      Primitive: byte, short, int, long, float, double, char, boolean.
      Referință: obiecte și tablouri; variabila stochează o adresă din heap.
      Autoboxing: conversie automată între primitive și tipurile wrapper.
      Switch: selecție multiplă (inclusiv pe String).
      For-each: parcurgere simplificată pentru colecții/tablouri.
      Array 2D: tablouri de tablouri (matrici), inclusiv neregulate (jagged).
      Short-circuit: evaluare parțială la && și ||.

      T4. Obiecte și clase în Java. Organizarea claselor

      Obiective
      • definirea claselor cu câmpuri, constructori și metode;
      • aplicarea încapsulării și a modificatorilor de acces;
      • utilizarea moștenirii și a polimorfismului;
      • organizarea pe pachete și convenții de proiect;
      • implementarea toString(), equals(), hashCode().
      Cuvinte-cheie: Clasă Obiect Încapsulare Moștenire Polimorfism Pachet Constructor
      Clasă: șablon pentru structură (câmpuri) și comportament (metode).
      Obiect: instanță creată cu new sau fabrici.
      Încapsulare: ascunderea detaliilor interne și expunere controlată (gettere/settere).
      Moștenire: relație is-a pentru reutilizare/extindere.
      Polimorfism: comportamente diferite prin aceeași interfață.
      Pachet: grupare logică de clase; ajută la organizare și controlul accesului.
      Constructor: inițializează obiectul; poate fi supraîncărcat.

      T5. Interfața grafică cu utilizatorul

      Obiective
      • înțelegerea AWT/Swing/JavaFX;
      • gestionarea evenimentelor și a firului UI;
      • utilizarea layout-urilor și a componentelor de bază;
      • separarea prezentării (MVC simplificat);
      • crearea unei ferestre simple cu interacțiuni.
      Cuvinte-cheie: Swing JavaFX Event handling Layout Thread UI MVC
      Swing: toolkit GUI bazat pe AWT; componente ușoare, portabile.
      JavaFX: framework modern (scene graph, FXML, stilizare de tip CSS).
      Event handling: model ascultător/observator pentru click/tastatură.
      Layout: BorderLayout, Grid, VBox/HBox etc., pentru aranjarea componentelor.
      Thread UI: fir dedicat actualizărilor vizuale; evită blocările.
      MVC: separare Model-View-Controller pentru claritate și testabilitate.

      T6. Fire de execuție

      Obiective
      • crearea și pornirea firelor (Thread, Runnable);
      • sincronizare și probleme de concurență;
      • utilizarea executors și thread pools;
      • gestionarea întreruperilor și a ciclului de viață;
      • evitarea condițiilor de cursă și a deadlock-urilor.
      Cuvinte-cheie: Thread Runnable Synchronized Volatile Executor Deadlock Race condition
      Thread: unitate de execuție concurentă.
      Runnable: interfață ce furnizează logica executabilă unui fir.
      Synchronized: control pentru acces exclusiv la resurse partajate.
      Volatile: garantează vizibilitatea scrierilor între fire.
      Executor: abstractizează crearea/gestionarea firelor (pool-uri).
      Deadlock: blocaj reciproc între fire.
      Race condition: rezultate nedeterminate din intercalări necontrolate.

      T7. Programare în rețea

      Obiective
      • modelul client–server și protocoalele TCP/UDP;
      • comunicare cu socket-uri;
      • I/O blocant vs. non-blocant (NIO);
      • serializarea datelor pentru transport;
      • gestionarea erorilor și timeout-urilor.
      Cuvinte-cheie: Socket ServerSocket TCP UDP NIO Serialization Timeout
      Socket: capăt de conexiune pe client.
      ServerSocket: ascultă conexiuni de la clienți (TCP).
      TCP: protocol orientat pe conexiune, fiabil și ordonat.
      UDP: protocol fără conexiune, rapid, fără garanții.
      NIO: API pentru I/O non-blocant (canale + buffere).
      Serialization: transformarea obiectelor în flux de octeți.
      Timeout: limită de timp pentru operații de rețea.

      T8. Lucrul cu baza de date

      Obiective
      • conectarea la DB prin JDBC și executarea interogărilor;
      • mapare obiect-relațională (JPA/Hibernate);
      • gestionarea tranzacțiilor și a conexiunilor;
      • prevenirea SQL Injection (prepared statements);
      • modelarea simplă a schemelor și relațiilor.
      Cuvinte-cheie: JDBC Driver PreparedStatement ResultSet Transaction JPA Hibernate
      JDBC: API standard pentru conectare/lucru cu DB.
      Driver: adaptor specific (ex.: PostgreSQL, MySQL) pentru JDBC.
      PreparedStatement: interogare parametrizată, sigură și eficientă.
      ResultSet: cursor peste rezultatele unei interogări.
      Transaction: grup de operații cu garanții ACID.
      JPA: specificație ORM pentru mapare obiect-relațională.
      Hibernate: implementare JPA cu HQL și caching.

      T9. Lucrul dinamic cu clase

      Obiective
      • inspectarea tipurilor la rulare cu Reflection API;
      • încărcare dinamică de clase cu ClassLoader;
      • invocare de metode și acces la câmpuri dinamic;
      • utilizarea adnotărilor (annotations) și meta-informației;
      • înțelegerea riscurilor și costurilor de performanță.
      Cuvinte-cheie: Reflection ClassLoader Annotation Method Field Proxy Security manager
      Reflection: interogarea/manipularea tipurilor/obiectelor la runtime.
      ClassLoader: mecanismul JVM care încarcă bytecode în memorie.
      Annotation: meta-date atașate tipurilor/membrilor; procesabile la runtime/compile-time.
      Method: reprezentare reflectivă a unei metode pentru invocare dinamică.
      Field: reprezentare reflectivă a unui câmp; permite citire/scriere.
      Proxy: obiect dinamic care interceptează apeluri către o interfață.
      Security manager: control al permisiunilor (depreciat în versiunile recente).

  • Structura cursului (cu Python)

    • T1. Introducere & ecosistemul Python

      Obiective
      • cunoașterea principiului „write once, run everywhere” aplicat Python;
      • înțelegerea diferenței între CPython, PyPy, MicroPython;
      • configurarea unui mediu de lucru (Python, pip, venv, IDE);
      • executarea primului script în terminal și în IDE.
      Cuvinte-cheie: Python Interpreter venv pip IDE script
      Interpreter: program care execută codul linie cu linie.
      venv: mediu virtual pentru izolarea dependențelor.
      pip: manager de pachete Python.
      IDE: mediu de dezvoltare (VS Code, PyCharm, Thonny etc.).
      Script: fișier cu extensia .py care conține instrucțiuni executabile.

      T2. Structura lexicală a limbajului Python

      Obiective
      • recunoașterea indentării și blocurilor logice;
      • utilizarea identificatorilor, operatorilor și separatorilor;
      • cunoașterea convențiilor PEP8 și a comentariilor;
      • gestionarea șirurilor de caractere și a docstring-urilor.
      Cuvinte-cheie: indentare identificator literal operator comentariu
      Indentare: Python folosește spații în loc de acolade pentru blocuri.
      Literal: valori directe – numere, șiruri, liste, dicționare.
      Operator: simbol ce realizează o operație (+, and, is etc.).
      Comentariu: linie începută cu # sau bloc de documentare cu """ ... """.

      T3. Tipuri de date. Controlul execuției. Liste și tupluri

      Obiective
      • cunoașterea tipurilor fundamentale (int, float, bool, str);
      • utilizarea structurilor de control if, for, while;
      • crearea și manipularea listelor și tuplurilor;
      • înțelegerea comprehensiunilor și a funcțiilor lambda.
      Cuvinte-cheie: listă tuplu lambda comprehensiune
      Listă: colecție mutabilă, ordonată, delimitată de [].
      Tuplu: colecție imutabilă, delimitată de ().
      Lambda: funcție anonimă scrisă într-o singură linie.
      Comprehensiune: expresie concisă pentru a crea liste/tupluri.

      T4. Funcții, clase și module în Python

      Obiective
      • definirea funcțiilor și a parametrilor (poziționali, implicați, *args, **kwargs);
      • crearea claselor și a metodelor; principiile OOP;
      • împachetarea codului în module și pachete;
      • gestionarea importurilor și a namespace-urilor.
      Cuvinte-cheie: funcție clasă metodă modul pachet
      Funcție: bloc de cod reutilizabil apelat prin nume.
      Clasă: șablon pentru obiecte (atribute + metode).
      Modul: fișier .py cu funcții/clase reutilizabile.
      Pachet: director cu fișier __init__.py.

      T5. Interfața grafică cu utilizatorul (Tkinter / PyQt)

      Obiective
      • crearea ferestrelor și a widgeturilor grafice (buton, etichetă, intrare);
      • gestionarea evenimentelor (click, input, timer);
      • organizarea layoutului (grid, pack, place);
      • actualizarea interfeței în timp real.
      Cuvinte-cheie: Tkinter PyQt widget layout event
      Tkinter: bibliotecă GUI standard inclusă în Python.
      PyQt: framework GUI puternic, bazat pe Qt.
      Widget: element grafic (buton, listă, text box etc.).
      Event: acțiune generată de utilizator (click, tastă, timer).

      T6. Fire de execuție și programare concurentă

      Obiective
      • utilizarea firelor de execuție cu modulul threading;
      • gestionarea execuției paralele și a blocărilor (locks);
      • utilizarea asyncio pentru programare asincronă;
      • măsurarea performanței și sincronizarea proceselor.
      Cuvinte-cheie: threading asyncio lock queue task
      Threading: permite rularea mai multor sarcini simultan în același proces.
      Asyncio: model asincron bazat pe await și async pentru I/O.
      Lock: mecanism de protecție pentru resurse partajate.
      Queue: coadă sigură pentru comunicarea între fire.

      T7. Programare în rețea (socket, HTTP, API REST)

      Obiective
      • crearea conexiunilor TCP/UDP cu socket;
      • trimiterea și recepționarea mesajelor binare și text;
      • realizarea unui server web simplu cu http.server sau Flask;
      • consumarea și crearea de API-uri REST.
      Cuvinte-cheie: socket HTTP Flask REST API request
      Socket: interfață de comunicație pentru rețele TCP/IP.
      HTTP: protocol pentru transferul de date web.
      REST API: arhitectură bazată pe cereri GET/POST/PUT/DELETE.
      Flask: framework minimal pentru aplicații web Python.

      T8. Lucrul cu baza de date (SQLite / PostgreSQL)

      Obiective
      • conectarea la o bază de date locală sau externă;
      • crearea, inserarea și interogarea datelor;
      • utilizarea modulelor sqlite3 și psycopg2;
      • implementarea ORM cu SQLAlchemy.
      Cuvinte-cheie: SQLite PostgreSQL cursor SQLAlchemy ORM
      SQLite: bază de date locală inclusă cu Python.
      PostgreSQL: sistem robust pentru aplicații complexe.
      Cursor: obiect care execută interogări SQL.
      ORM: transformă tabelele SQL în clase Python.

      T9. Importul dinamic de module și reflexie

      Obiective
      • încărcarea dinamică a modulelor la runtime (importlib);
      • accesarea atributelor și metodelor prin introspecție;
      • utilizarea funcțiilor getattr(), setattr(), dir();
      • implementarea plugin-urilor modulare în aplicații Python.
      Cuvinte-cheie: importlib getattr setattr dir introspecție
      Importlib: modul standard pentru încărcarea dinamică a codului.
      Getattr/Setattr: permit accesul dinamic la atributele unui obiect.
      Dir: returnează lista atributelor disponibile.
      Introspecție: examinarea structurilor interne ale obiectelor la runtime.

  • Lucrarea practică 1

    • Afișarea numelui și prenumelui pe localhost

      Obiective
      • configurarea unui proiect minim Java + pagină index.html;
      • pornirea unui server local și servirea paginii în browser;
      • afișarea corectă a numelui și prenumelui (diacritice, UTF-8).
      Cuvinte-cheie: localhost port HTTP index.html UTF-8
      localhost: adresa buclei locale (127.0.0.1) pentru testare pe propriul PC.
      port: numărul pe care ascultă serverul (ex.: 8080).
      HTTP: protocolul de transport pentru pagini web.
      index.html: documentul web implicit servit în rădăcina aplicației.
      UTF-8: codare a caracterelor care afișează corect diacriticele.

  • Lucrarea practică 2

    • Structurarea paginii: header, meniu + content, footer

      Obiective
      • utilizarea tagurilor semantice HTML5: header, nav, main, aside, footer;
      • împărțirea zonei centrale în meniu + content (layout cu Flexbox/Grid);
      • stilizare de bază (culori, spațiere, border) doar cu CSS.
      Cuvinte-cheie: HTML5 semantic header nav main/aside footer Flexbox CSS Grid
      HTML5 semantic: taguri care descriu rolul conținutului (mai clar pentru SEO și accesibilitate).
      header/nav: bandă superioară + zonă de meniu cu linkuri.
      main/aside: conținutul principal + bara laterală (meniul).
      footer: informații de subsol: autor, an, licență.
      Flexbox / CSS Grid: tehnici CSS pentru împărțirea și alinierea zonelor.

  • Lucrarea practică 3

    • Popularea meniului și a conținutului principal

      Obiective
      • încărcarea meniului în stânga sau dreapta (la alegere) cu linkuri interne;
      • organizarea conținutului pe secțiuni (titluri, paragrafe, imagini/tabele);
      • stilizarea stării „activ” pentru elementul din meniu aferent secțiunii vizibile.
      Cuvinte-cheie: ancoră (#id) listă de navigare stare activă responsiv card
      ancoră (#id): link către o secțiune din aceeași pagină (<a href="#sec1">).
      listă de navigare: meniul realizat cu <ul><li><a>.
      stare activă: linkul curent evidențiat (ex.: .nav a.active).
      responsiv: adaptare la diferite lățimi (media queries).
      card: bloc de conținut cu chenar, colțuri rotunjite, umplutură.

  • Lucrarea practică 4

    • Charturi: colectare și afișare de date

      Obiective
      • integrarea unui chart într-o pagină web (ex.: <canvas> + librărie JS);
      • adăugarea/actualizarea dataset-urilor din formular sau din fișier JSON;
      • afișarea legendelor, axelor și tooltip-urilor.
      Cuvinte-cheie: Chart.js / Google Charts canvas dataset JSON legendă/tooltip
      Chart.js / Google Charts: librării JS pentru grafice (line, bar, pie etc.).
      canvas: element HTML pentru desenare 2D în browser.
      dataset: set de valori reprezentat în grafic.
      JSON: format textual ușor pentru schimb de date.
      legendă/tooltip: elemente UI care explică seriile și valorile la hover.

  • Lucrarea practică 5

    • Bază de date: creare, populare și afișare în interfața web

      Obiective
      • crearea unei baze de date simple (ex.: SQLite/MySQL) și a unei tabele;
      • conectarea din Java prin JDBC (driver, conexiune, interogări parametrizate);
      • afișarea rezultatelor într-un tabel HTML în pagina web.
      Cuvinte-cheie: JDBC Driver Connection PreparedStatement ResultSet CRUD HTML table
      JDBC: API standard Java pentru acces DB.
      Driver: bibliotecă specifică SGBD-ului (ex.: sqlite-jdbc, mysql-connector-j).
      Connection: sesiune deschisă către baza de date.
      PreparedStatement: interogare parametrizată, sigură și eficientă.
      ResultSet: rezultate iterabile ale unei interogări SELECT.
      CRUD: Create, Read, Update, Delete – operații de bază pe date.
      HTML table: randarea datelor în <table> cu antet și rânduri.

  • Sarcina lucru individual

    • Proiect web cu date în timp real dintr-o bază de date locală

      Studentul poate alege traseul Java sau traseul Python pentru implementare.
      Obiective
      • realizarea unui flux end-to-end: achiziție date de pe STM32 → port serial → DB locală → interfață web;
      • afișarea datelor în timp real (grafic + tabel), cu latență percepută ≤ 2 secunde;
      • documentarea arhitecturii și a pașilor de rulare pentru traseul ales (Java sau Python).
      Alegeți unul dintre trasee
      1. Traseul A — Java: citire serial + API web + acces DB implementate în Java (ex.: Spring Boot, JPA). Frontend HTML/CSS/JS.
      2. Traseul B — Python: citire serial + API web + acces DB implementate în Python (ex.: FastAPI/Flask, SQLAlchemy). Frontend HTML/CSS/JS.
      Cerințe minime (comune ambelor trasee)
      • DB locală cu tabel minim measurements(id, value, unit, source, created_at);
      • API care oferă datele: GET /api/data?limit=N și endpoint „live” (WebSocket sau SSE / polling 1s);
      • UI HTML/CSS/JS cu un chart și un tabel ce se actualizează automat;
      • Loguri & eroare: mesaje clare la port indisponibil, DB căzut, date invalide;
      • README cu pașii de rulare, configurări (port serial, DSN) și diagrama arhitecturii.
      Traseul A — Java
      Stack propus: Spring Boot (REST/WebSocket), JPA/Hibernate (JDBC), driver DB (SQLite/PostgreSQL/MySQL), librărie serial (ex.: com.fazecast:jSerialComm), Chart în front-end (Chart.js).
      1. Serial: citește din port (baud/paritate/stop) și inseră în DB (batch sau per eșantion).
      2. Persistență: entitate Measurement + Repository (JPA), migrare inițială.
      3. API: GET /api/data (ultimele N valori) + /ws (push live) sau /sse.
      4. UI: pagina web statică servită de Spring; JS pentru chart și actualizări.
      5. Test: mod „simulator” dacă portul nu e conectat (generează valori).
      Notă: dacă preferați, citiți serial-ul într-un thread dedicat sau cu programare reactivă.
      Traseul B — Python
      Stack propus: FastAPI (REST/WebSocket) sau Flask (+ Flask-SocketIO), SQLAlchemy, pyserial, driver DB (SQLite/PostgreSQL/MySQL), Chart în front-end (Chart.js).
      1. Serial: pyserial citește cadrele STM32 și le persistă în DB.
      2. Persistență: model ORM Measurement, migrare inițială.
      3. API: GET /api/data + /ws (SocketIO/WebSocket) sau /sse.
      4. UI: pagină statică servită de framework sau Nginx; JS pentru chart și actualizări.
      5. Test: „simulator” de date dacă STM32 nu e prezent.
      Notă: FastAPI oferă nativ tipare asincrone utile pentru conexiuni live.
      Arhitectură (schematică textuală)
      Traseul A (Java): STM32 → Serial → Java (jSerialComm) → DB → Java REST/WS → HTML/CSS/JS (Chart)
      Traseul B (Python): STM32 → Serial → Python (pyserial) → DB → Python REST/WS → HTML/CSS/JS (Chart)
      Etape recomandate
      1. Schema DB: creați measurements(id PK, value REAL, unit TEXT, source TEXT, created_at TIMESTAMP).
      2. Achiziție serial: configurați baud/paritate/stop; validați și normalizați unitățile.
      3. Persistență: inserați cu tranzacții; index pe created_at.
      4. API: implementați GET /api/data?limit=N + WebSocket/SSE pentru live.
      5. UI: tabel + grafic (ultimele N puncte) cu auto-actualizare.
      6. Testare: date reale + mod simulator; test la căderi (port/DB).
      7. Documentare: README cu diagrame, setări și comenzi de rulare.
      Livrabile
      • cod sursă pentru traseul ales (Java sau Python) + front-end HTML/CSS/JS;
      • fișiere SQL/migrări; configurări (.env / application.properties / settings.py);
      • README cu pași, diagrame, explicații arhitecturale, mod simulator;
      • screenshoturi/clip scurt care evidențiază actualizarea în timp real.
      Criterii de evaluare (100p)
      • Funcționalitate end-to-end (serial→DB→API→UI): 40p
      • Real-time (push/poll ≤ 1s, reactivitate UI): 20p
      • Calitatea codului (structură, erori, loguri, validare): 20p
      • UI/UX (claritate, responsive minim, chart lizibil): 10p
      • Documentare (README, diagrame, reproducibilitate): 10p
      Cuvinte-cheie: STM32 Serial / UART DB locală Java Spring Boot JPA / JDBC Python FastAPI / Flask WebSocket / SSE Chart ORM Validation
      WebSocket/SSE: canale pentru actualizări live; alternativ, polling la 1s.
      ORM: mapare obiect–relațională (JPA/Hibernate în Java; SQLAlchemy în Python).
      Validation: verificarea câmpurilor/intervalelor la ingestie și expunere.
      Checklist de acceptanță
      • aplicația pe traseul ales pornește și creează schema DB la nevoie;
      • datele sosesc din serial și apar în DB (loguri vizibile);
      • UI afișează tabel + grafic, care se actualizează continuu;
      • fall-back „simulator” funcționează fără STM32;
      • README permite rularea proiectului pe un alt calculator, pas cu pas.

  • Evaluări