Тематический план
- Общее
- Structura cursului (cu Java)
Structura cursului (cu Java)
- Cuprins
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 IDEJDK: kitul pentru dezvoltatori (includejavac, 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 dejavac, 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-cheieIdentificator: 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-circuitPrimitive: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 peString).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 ConstructorClasă: șablon pentru structură (câmpuri) și comportament (metode).Obiect: instanță creată cunewsau 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 MVCSwing: 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 conditionThread: 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 TimeoutSocket: 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 HibernateJDBC: 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 managerReflection: 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)
Structura cursului (cu Python)
- Cuprins
- Introducere & ecosistemul Python
- Structura lexicală a limbajului Python
- Tipuri de date. Controlul execuției. Liste și tupluri
- Funcții, clase și module în Python
- Interfața grafică cu utilizatorul (Tkinter / PyQt)
- Fire de execuție și programare concurentă
- Programare în rețea (socket, HTTP, API REST)
- Lucrul cu baza de date (SQLite / PostgreSQL)
- Importul dinamic de module și reflexie
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 scriptInterpreter: 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.pycare 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 comentariuIndentare: 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,isetc.).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 comprehensiuneListă: 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 pachetFuncție: bloc de cod reutilizabil apelat prin nume.Clasă: șablon pentru obiecte (atribute + metode).Modul: fișier.pycu 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 eventTkinter: 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
asynciopentru programare asincronă; - măsurarea performanței și sincronizarea proceselor.
Cuvinte-cheie: threading asyncio lock queue taskThreading: permite rularea mai multor sarcini simultan în același proces.Asyncio: model asincron bazat peawaitșiasyncpentru 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.serversau Flask; - consumarea și crearea de API-uri REST.
Cuvinte-cheie: socket HTTP Flask REST API requestSocket: 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șipsycopg2; - implementarea ORM cu SQLAlchemy.
Cuvinte-cheie: SQLite PostgreSQL cursor SQLAlchemy ORMSQLite: 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țieImportlib: 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
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-8localhost: 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.- configurarea unui proiect minim Java + pagină
- Lucrarea practică 2
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 GridHTML5 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.- utilizarea tagurilor semantice HTML5:
- Lucrarea practică 3
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 cardancoră (#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
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ă/tooltipChart.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
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 tableJDBC: 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ăriSELECT.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
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- Traseul A — Java: citire serial + API web + acces DB implementate în Java (ex.: Spring Boot, JPA). Frontend HTML/CSS/JS.
- 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 — JavaStack 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).- Serial: citește din port (baud/paritate/stop) și inseră în DB (batch sau per eșantion).
- Persistență: entitate
Measurement+Repository(JPA), migrare inițială. - API:
GET /api/data(ultimele N valori) +/ws(push live) sau/sse. - UI: pagina web statică servită de Spring; JS pentru chart și actualizări.
- 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 — PythonStack propus: FastAPI (REST/WebSocket) sau Flask (+ Flask-SocketIO), SQLAlchemy,pyserial, driver DB (SQLite/PostgreSQL/MySQL), Chart în front-end (Chart.js).- Serial:
pyserialcitește cadrele STM32 și le persistă în DB. - Persistență: model ORM
Measurement, migrare inițială. - API:
GET /api/data+/ws(SocketIO/WebSocket) sau/sse. - UI: pagină statică servită de framework sau Nginx; JS pentru chart și actualizări.
- 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- Schema DB: creați
measurements(id PK, value REAL, unit TEXT, source TEXT, created_at TIMESTAMP). - Achiziție serial: configurați baud/paritate/stop; validați și normalizați unitățile.
- Persistență: inserați cu tranzacții; index pe
created_at. - API: implementați
GET /api/data?limit=N+ WebSocket/SSE pentru live. - UI: tabel + grafic (ultimele N puncte) cu auto-actualizare.
- Testare: date reale + mod simulator; test la căderi (port/DB).
- 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 ValidationWebSocket/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
Curs
1
2
Lucrări practice
1
2
3
4
5
Lucru individual
•••
Evaluări
•••