avansat

Tehnologii Web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

programare Web: Node.js – supliment
Prof. Sabin Corneliu Buraga – profs.info.uaic.ro/~busaco/
 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
„Cine a văzut vreodată o bijuterie frumos cizelată
de bijutier cu ajutorul ciocanului?”

Jan Amos Comenius

 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
JavaScript (ECMAScript)
un limbaj de programare pentru Web
 Inventat de Brendan Eich (1995)

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

detalii în cadrul prelegerilor
Limbajul de programare JavaScript.
Aspecte esențiale
profs.info.uaic.ro/~busaco/teach/courses/staw/web-film.html#week2

Limbajul de programare JavaScript.

Aspecte moderne: ES6 et al.
profs.info.uaic.ro/~busaco/teach/courses/staw/web-film.html#week3

a se considera și
Ingineria dezvoltării aplicaţiilor JavaScript
profs.info.uaic.ro/~busaco/teach/courses/staw/web-film.html#week7
 Cum dezvoltăm cu JavaScript
aplicații Web la nivel de server?

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

“Node.js® is a JavaScript runtime
built on Chrome’s V8 JavaScript engine.”

“Node.js uses an event-driven, non-blocking I/O model

that makes it lightweight and efficient.”
 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

“Node.js is designed to build scalable network applications.”

“Node.js is an open-source, cross-platform, JavaScript

runtime environment that executes JavaScript code
outside of a browser.”

“Node.js represents a JavaScript everywhere paradigm.”

 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Oferă suport pentru cele mai importante
protocoale Web și Internet

HTTP (HyperText Transfer Protocol)

DNS (Domain Name System)
TLS (Transport Layer Security)
functionalități de nivel scăzut (socket-uri TCP)
 Ryan Dahl concepe Node.js (2009) – nodejs.org
rulează pe mașini respectând POSIX + Windows (2011)

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

adoptat de industrie (din 2012)
e.g., Cloud9 IDE, eBay, Google, LinkedIn, NASA, Netflix, Walmart
hackernoon.com/@nodejs

Node.js Foundation (2015)

IBM, Intel, Joyent, Microsoft, RedHat, SAP, The Linux Foundation,…

Node.js 18.16 LTS – Long Term Support (12 aprilie 2023)

versiune stabilă actuală pentru uz în producție
Node.js 20.0 (18 aprilie 2023)
versiunea cea mai recentă

github.com/nodejs/node
 node.js

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Oferă un mediu de execuție în linia de comandă,
pe baza unor biblioteci C++ și a procesorului V8

node program.js
 node.js

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Permite dezvoltarea de aplicații Web
la nivel de server în limbajul JavaScript

recurge la V8
procesor – compilează + execută codul – ECMAScript
a single threaded execution JS engine
creat de Google, implementat în C++ și JS, disponibil liber

v8.dev
v8.dev/docs
node.js

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

 node.js

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Permite dezvoltarea de aplicații Web
la nivel de server în limbajul JavaScript

utilizează libluv
bibliotecă multi-platformă disponibilă liber
axată pe efectuarea de operații I/O asincrone
implementare C++
libuv.org
 node.js

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

“libuv uses a thread pool to make asynchronous file I/O operations
possible, but network I/O is always performed in a single thread,
each loop’s thread”

docs.libuv.org/en/v1.x/design.html
 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Intern, mediul recurge la
diverse biblioteci open source C sau C++

libuv (asynchronous I/O) – docs.libuv.org

c-ares (asynchronous DNS requests) – c-ares.haxx.se
OpenSSL (crypto + SSL/TLS) – www.openssl.org
zlib (compression) – zlib.net
V8 (JavaScript engine) – v8docs.nodesource.com
 node.js

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

 node.js:
Uzual, o aplicație Web caracterizare
realizează un număr mare de
operații – în acest caz, asincrone – de intrare/ieșire

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

G. Yeh (2014): www.slideshare.net/garyyeh165/basic-understanding-and-implement-of-nodejs
 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Operațiile de intrare/ieșire sunt asincrone

fiecare cerere (operație) adresată aplicației

– e.g., acces la disc, la rețea, la alt proces – poate avea
atașată o funcție de tratare a unui eveniment specific

evented I/O
 cod JS executat de cod JS rulat pe partea
client (browser Web) de server (node.js)
procesare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

așteaptă și tratează
evenimente de bazată pe așteaptă și tratează
interacțiune evenimente cereri (evenimente)
(onclick, onmouseover, evented/ provenite de la client(i)
onkeypressed,…) event-based

programul trebuie să fie programul trebuie să fie

responsiv atunci când responsiv atunci când
așteaptă încărcarea asincronism așteaptă încărcarea
datelor de pe rețea (e.g., operatii datelor locale/externe
(JSON, XML, neblocante) (preluate din baze de
imagini, video etc.) date, fișiere,
via Ajax ori Web sockets servicii Web, API-uri,…)

adaptare după Ben Sheldon (2012)

 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

O aplicație node.js rulează într-un singur proces

event loop ≡ “an entity that handles & processes external

events and converts them into callback invocations”
 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

O aplicație node.js rulează într-un singur proces

event loop ≡ “an entity that handles & processes external

events and converts them into callback invocations”

codul JavaScript nu este executat paralel,

dar tratează în mod asincron diverse evenimente I/O
 Aplicația Node.js „reacționează” la evenimente
context mainode.js: caracterizare
larg: reactive programming – reactivex.io

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

G. Yeh (2014): www.slideshare.net/garyyeh165/basic-understanding-and-implement-of-nodejs
 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

O aplicație Node.js rulează într-un singur proces

deosebire esențială față de serverele de aplicații Web

tradiționale ce recurg la servere multi-process/threaded
 server Web clasic
cerere mulțimea
📺 ⧁ HTTP: server Web
firelor de

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

execuție
(thread pool)
cerere
☎ ⧁ resurse
cereri ⌛ (date/servicii)
💻 ⦷ ⧁ 🖴⎘⎙☁
cereri operații I/O
blocante
⚙️ ⦷ ⦷ ⧁
⧁ în execuție
server Web multi-threaded ⦷ în așteptare

cererile multiple de la diverși clienți nu pot fi deservite simultan

(numărul firelor de execuție asociate unui proces este limitat)
 Node.js
cerere event loop
📺 HTTP: server Web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

cerere
☎ resurse
POSIX
⧁ ⟺ async (date/servicii)
cereri
💻 threads 🖴⎘⎙☁
cereri
⧁⧁ operații I/O
neblocante
⚙️ ⧁⧁
⧁ în execuție
server Node.js ⟺ delegare

cererile multiple de la diverși clienți pot fi deservite simultan

 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Mediul Node.js e disponibil gratuit – open source –
pentru platformele Linux, Windows, macOS

nodejs.org/en/download/

inclusiv imagini-sistem Docker: hub.docker.com/_/node/

 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
Funcționalități suplimentare oferite de module
administrate cu Node Package Manager
npm

utilitar în linia de comandă dezvoltat complet în JavaScript

(inițiat de Isaac Z. Schlueter în 2010)

npmjs.com
github.com/npm
 node.js: caracterizare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Utilitarul npm poate gestiona dependențe imbricate

detalii la docs.npmjs.com
 node.js: exemplu

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Un prim program care emite mesaje de salut

// salutari.js: un program (de sine-stătător) care emite un salut

console.log ('Salutări banale din Node.js');

invocarea unei
metode oferită de
un obiect predefinit
 node.js: exemplu

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Un prim program care emite mesaje de salut

// salutari.js: un program (de sine-stătător) care emite un salut

console.log ('Salutări banale din Node.js');

> node salutari.js

Salutări banale din Node.js
 /* Un program JavaScript ilustrând comportamentul asincron
al operațiilor I/O implementate de Node.js */
 const fs = require ('fs'); // acces la sistemul de fișiere

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

fs.readFile ('salutari.txt', 'utf-8', function (eroare, date) {
if (eroare)
throw eroare; // excepție de citire
console.log (date);
})
console.log ('Gata!');

execuția (cod interpretat) pornește

de la prima linie a programului JavaScript
 /* Un program JavaScript ilustrând comportamentul asincron
al operațiilor I/O implementate de Node.js */
const fs = require ('fs'); // acces la sistemul de fișiere

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

 fs.readFile ('salutari.txt', 'utf-8', function (eroare, date) {
if (eroare)
throw eroare; // excepție de citire
console.log (date);
})
console.log ('Gata!');

începe execuția unei operații asincrone

(aici, citirea conținutului unui fișier text)
care returnează imediat
 /* Un program JavaScript ilustrând comportamentul asincron
al operațiilor I/O implementate de Node.js */
const fs = require ('fs'); // acces la sistemul de fișiere

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

fs.readFile ('salutari.txt', 'utf-8', function (eroare, date) {
if (eroare)
throw eroare; // excepție de citire
console.log (date);
})
 console.log ('Gata!');

execuția continuă cu ultima linie de program

> node asincronism.js

Gata!
 /* Un program JavaScript ilustrând comportamentul asincron
al operațiilor I/O implementate de Node.js */
const fs = require ('fs'); // acces la sistemul de fișiere

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

fs.readFile ('salutari.txt', 'utf-8', function (eroare, date) {
if (eroare)
throw eroare; // excepție de citire
 console.log (date);
})
console.log ('Gata!');

…după care sunt afișate datele preluate din fișier

> node asincronism.js

Gata!
Un prim salut...
Acesta este al doilea salut.
// Un program JavaScript care salută toți posibilii săi clienți Web
const http = require ('http'); // folosim 'http', un modul Node predefinit

http.createServer ( // creăm un server Web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

// funcție anonimă ce tratează o cerere și trimite un răspuns
function (cerere, raspuns) {
// afișăm la consola serverului mesaje de diagnostic
console.log ('Am primit o cerere...');
// stabilim valori pentru diverse câmpuri din antetul mesajului HTTP
raspuns.writeHead (200, { 'Content-Type': 'text/html' });
// emitem răspunsul propriu-zis conform tipului MIME (aici, cod HTML)
raspuns.end ('<html><body><h1>Salutari…</h1></body></html>');
}
// serverul ascultă cereri la portul 8080 al mașinii locale
).listen (8080, "127.0.0.1");

console.log ('Serverul creat asteapta cereri la http://127.0.0.1:8080/');

programul JavaScript creat funcționează ca un server Web
pentru fiecare cerere emisă de un posibil client (browser,
aplicație desktop etc.) conform modelului client/server

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

pe partea de server – așteptare de cereri
> node salutari-web.js
Serverul creat asteapta cereri la http://127.0.0.1:8080/
Am primit o cerere...
Am primit o cerere...
programul JavaScript creat funcționează ca un server Web
pentru fiecare cerere emisă de un posibil client (browser,
aplicație desktop etc.) conform modelului client/server

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

pe partea de server – așteptare de cereri
> node salutari-web.js
Serverul creat asteapta cereri la http://127.0.0.1:8080/
Am primit o cerere...
Am primit o cerere...

la client – recepționarea răspunsului conform cererii GET

emise de un program desktop și de un navigator Web
> node client-salutari.js
Am primit raspuns de la server -- cod HTTP: 200
Continut receptionat: <html><body>
<h1>Salutari din Node.js</h1></body></html>
// Un program JS care implementează un client pentru serviciul de salut
const http = require ('http');

http.get ('http://127.0.0.1:8080/', // emite o cerere HTTP

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

function (raspuns) {
console.log ('Am primit raspuns de la server -- cod HTTP: '
+ raspuns.statusCode); // statusCode: 200, 404,…
})
// tratăm diverse evenimente via funcții (eventual, anonime) de tip callback
.on ('error', // eroare
function (e) { console.log ('Eroare: ' + e.message); })
.on ('response', // receptare răspuns de la server
function (raspuns) { // există date de procesat
raspuns.on ('data', function (date) {
console.log ('Continut receptionat: ' + date);
});
}
);
// Aceleași acțiuni realizate în ES6
// Implementează un client pentru serviciul de salut
const http = require ('http');

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

http.get ('http://127.0.0.1:8080/’, // emite o cerere HTTP
raspuns => console.log ('Am primit raspuns de la server -- cod HTTP: '
+ raspuns.statusCode) // statusCode: 200, 404,...
)
// tratăm diverse evenimente
.on ('error', e => console.log ('Eroare: ' + e.message)) // eroare
.on ('response', // receptare răspuns de la server
raspuns => { // există date de procesat
raspuns.on ('data',
date => console.log ("Continut receptionat:\n" + date));
console.log ('Campuri-antet HTTP primite: '
+ JSON.stringify(raspuns.headers, null, '\t'));
}
);
 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
> node client-salutari.js

Am primit raspuns de la server -- cod HTTP: 200

Campuri-antet HTTP primite: {
"content-type": "text/html",
"date": "Tue, 25 Apr 2023 08:45:32 GMT",
"connection": "close",
"transfer-encoding": "chunked"
}
Continut receptionat:
<html><body><h1>Salutari din Node.js</h1></body></html>
 node.js: module

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Funcția require () specifică utilizarea unui modul Node.js

module predefinite (built-in) – exemple:

privitoare la tehnologii Web – http, https, url, querystring

referitoare la fișiere – fs, path
vizând rețeaua – net, dns, dgram, tls,…
resurse privind sistemul de operare – os, child_process
alte aspecte de interes – buffer, console, util, crypto
suport multi-core – cluster
node.js: module

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

documentația online aferentă

nodejs.org/en/docs/
devdocs.io/node/
 atenție: o parte
dintre funcționalități
node.js: module sunt experimentale

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

nodejs.org/api/documentation.html
 node.js: module – http

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Dezvoltarea de aplicații Web via modulul http

funcționalități HTTP de bază

crearea unui server Web: createServer()

realizarea de cereri HTTP: request() get()

 node.js: module – http

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Dezvoltarea de aplicații Web via modulul http

servire de cereri HTTP – clasa http.Server

metode uzuale:
listen() setTimeout() close()

evenimente ce pot fi tratate:

request connect close clientError etc.
 node.js: module – http

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Dezvoltarea de aplicații Web via modulul http

răspuns emis de server – clasa http.ServerResponse

metode uzuale:
writeHead() getHeader() removeHeader() write() end() etc.

evenimente: close finish

proprietăți folositoare: statusCode headersSent

 node.js: module – http

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Dezvoltarea de aplicații Web via modulul http

cerere emisă de client – clasa http.ClientRequest

metode uzuale:
write() abort() end() setTimeout() setSocketKeepAlive()

evenimente ce pot fi tratate:

response connect continue socket etc.
 node.js: module – http

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Dezvoltarea de aplicații Web via modulul http

mesaj vehiculat – clasa http.IncomingMessage

metode: setEncoding() setTimeout() pause() resume()

evenimente ce pot fi tratate: data end close

proprietăți de interes:
httpVersion headers method url statusCode socket
 node.js: module – http

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Suplimentar, pot fi folosite modulele interne:

https – suport pentru HTTPS

nodejs.org/api/https.html

http2 – implementează HTTP/2

nodejs.org/api/http2.html
 node.js: module – url

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Procesarea adreselor Web via modulul url

clase oferite:
URL() URLSearchParams()

nodejs.org/api/url.html
let adresaWeb = new URL
('http://undeva.info:8080/oferta/jucarii/produs/?nume=Tux&marime=17#oferta');
adresaWeb.host = 'acolo';

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

adresaWeb.protocol = 'https';

console.log (adresaWeb);

// parametrii din query string (valoarea proprietății search)

// sunt încapsulați de obiectul URLSearchParams
let params = new URLSearchParams (adresaWeb.search);

if (params.get ('marime') > 13) {

console.log ('Jucaria e in regula.');
} else {
console.log ('Jucaria e stricata.');
}
> node url.js
URL {
href:

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

'https://acolo:8080/oferta/jucarii/produs/?nume=Tux&marime=17#oferta',
origin: 'https://acolo:8080',
protocol: 'https:',
username: '',
password: '',
host: 'acolo:8080',
hostname: 'acolo',
port: '8080',
pathname: '/oferta/jucarii/produs/',
search: '?nume=Tux&marime=17',
searchParams: URLSearchParams { 'nume' => 'Tux', 'marime' => '17' },
hash: '#oferta' }
Jucaria e in regula.
 node.js: module – net

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Crearea de aplicații Internet – modulul net

partea de server:

createServer()
+
clasa net.Server
metode: listen() close() address() getConnections()
evenimente: listening connection close error
proprietăți: listening maxConnections
 node.js: module – net

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Crearea de aplicații Internet – modulul net

partea de client:

connect()
createConnection()
 node.js: module – net

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Crearea de aplicații Internet – modulul net

acces la socket-uri – clasa net.Socket

metode: connect() write() setEncoding() destroy() end() etc.

evenimente: connect data end timeout drain error close

proprietăți utile: localAddress localPort

remoteAddress remotePort bytesRead bytesWritten bufferSize
 node.js: module – fs

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Acces la sistemul de fișiere via modulul fs

clase importante:
fs.ReadStream – flux de citire
fs.WriteStream – flux de scriere
fs.Stats – informații despre un fișier
fs.FSWatcher – monitorizează schimbările dintr-un fișier
(obiecte de tip EventEmitter – evenimentul change)
fs.Dirent – element dintr-un director (directory entry)
 node.js: module – fs

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Acces la sistemul de fișiere via modulul fs

metode folosite uzual – comportament asincron:

open() read() write() close()

truncate() stat() chmod() rename() unlink() watch()

isFile() isDirectory() isBlockDevice() isSocket()

mkdir() rmdir() readdir()

 node.js: module – fs

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Acces la sistemul de fișiere via modulul fs

unele metode au comportament sincron

(numele lor sunt sufixate cu Sync)

exemple:
openSync() readSync() writeSync() closeSync()
appendFileSync() chmodSync() unlinkSync() mkdirSync()
const http = require ("http");
const url = require ("url"); mini-server Web oferind
const path = require ("path"); fișiere statice stocate în 'public/'
const fs = require ("fs");
http.createServer ((cerere, raspuns) => {

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

let uri = url.parse (cerere.url).pathname; // preluăm URL și calea spre fișierul dorit
let numefis = path.join (process.cwd (), 'public/', uri);
fs.access (numefis, fs.constants.R_OK, (eroare) => {
if (eroare) { // resursa nu există, trimitem bine-cunoscutul cod 404
raspuns.writeHead (404, { "Content-Type": "text/plain" });
raspuns.write ("404 Not Found\n");
raspuns.end (); // închidem fluxul de date spre client
return;
}
fs.readFile (numefis, "binary", (eroare, fisier) => { // resursa există, poate fi citită
if (eroare) { // eroare de citire a fisierului, trimitem 500
raspuns.writeHead (500, { "Content-Type": "text/plain" });
raspuns.write (eroare + "\n"); raspuns.end (); return;
}
raspuns.writeHead (200); // totul e în regulă, trimitem fișierul ca flux binar
raspuns.write (fisier, "binary");
raspuns.end ();
});
}); }).listen (8080);
console.log ('Serverul de fișiere așteaptă cereri la http://127.0.0.1:8080/');
 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
cererea GET de acces a reprezentării resursei de la
http://127.0.0.1:8080/Tux.png conduce la obținerea
unei imagini în format PNG
(aici, inspecția transferului datelor
cu instrumentele oferite de browser)
 node.js: fluxuri de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Accesul la date poate fi realizat
prin intermediul fluxurilor (streams)

abstractizează accesul la date stocate parțial

(partially buffered data)

se emit evenimente ce pot fi tratate de codul aplicației

 node.js: fluxuri de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Accesul la date poate fi realizat
prin intermediul fluxurilor (streams)

pot fi citite – stream.Readable

pot fi scrise – stream.Writable
duplex (citite și scrise) – stream.Duplex
realizând o transformare a datelor – stream.Transform

detalii la nodejs.org/api/stream.html
 node.js: fluxuri de date
Readable Streams Writable Streams

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

HTTP response (client) HTTP requests (client)
HTTP requests (server) HTTP responses (server)
fs read streams fs write streams
zlib streams zlib streams
crypto streams crypto streams
TCP sockets TCP sockets
child process stdout & stderr child process stdin
process.stdin process.stdout process.stderr

github.com/samerbuna/efficient-node
 node.js: fluxuri de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Accesul la date poate fi realizat
prin intermediul fluxurilor (streams)

fluxuri ce pot fi citite (readable streams)

e.g., create de fs.createReadStream() http.ServerRequest
http.ClientResponse net.Socket child.stdout process.stdin
 node.js: fluxuri de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Accesul la date poate fi realizat
prin intermediul fluxurilor (streams)

fluxuri ce pot fi citite (readable streams)

e.g., create de fs.createReadStream() http.ServerRequest
http.ClientResponse net.Socket child.stdout process.stdin

emit evenimentele readable data end error

 node.js: fluxuri de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Accesul la date poate fi realizat
prin intermediul fluxurilor (streams)

fluxuri ce pot fi citite (readable streams)

e.g., create de fs.createReadStream() http.ServerRequest
http.ClientResponse net.Socket child.stdout process.stdin

au asociate metodele pause() resume() destroy()

 node.js: fluxuri de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Accesul la date poate fi realizat
prin intermediul fluxurilor (streams)

fluxuri ce pot fi scrise (writeable streams)

e.g., create de fs.createWriteStream() http.ServerResponse
http.ClientRequest net.Socket child.stdin process.stdout
 node.js: fluxuri de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Accesul la date poate fi realizat
prin intermediul fluxurilor (streams)

fluxuri ce pot fi scrise (writeable streams)

e.g., create de fs.createWriteStream() http.ServerResponse
http.ClientRequest net.Socket child.stdin process.stdout

emit evenimentele drain error

 node.js: fluxuri de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Accesul la date poate fi realizat
prin intermediul fluxurilor (streams)

fluxuri ce pot fi scrise (writeable streams)

e.g., create de fs.createWriteStream() http.ServerResponse
http.ClientRequest net.Socket child.stdin process.stdout

oferă metodele write() end() destroy()

// Program ce preia ceea ce tastează utilizatorul la intrarea standard
// și scrie într-un fișier – adaptare după M. Takada
let fs = require ('fs');

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

let fisier = fs.createWriteStream ('./spion.txt');

// la apariția datelor, le scriem în fișier

process.stdin.on ('data', date => fisier.write (date));

// tratăm evenimentul de terminare a fluxului

process.stdin.on ('end', () => fisier.end ());

// "reactivăm" intrarea standard; implicit, e în starea 'paused'

process.stdin.resume ();

obiectul process e global – detalii la nodejs.org/api/process.html

 node.js: fluxuri de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Accesul la date poate fi realizat
prin intermediul fluxurilor (streams)

exemple de fluxuri de tip duplex:

socket-uri TCP create cu net.Socket()
privind arhivele create cu zlib – nodejs.org/api/zlib.html
date criptate via crypto – nodejs.org/api/crypto.html
 node.js: rulare temporizată

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Se poate planifica execuția codului JavaScript

recurgerea la funcțiile globale

setTimeout () clearTimeout () – execuție la un anumit moment
setInterval () clearInterval () – execuție recurentă
setImmediate () clearImmediate () – execuție „imediată”

amănunte la nodejs.org/api/timers.html
// creăm un server Web care trimite fiecărui client secvența valorilor unui contor
let server = http.createServer ().listen (8080, '127.0.0.1');

// stabilim un comportament la apariția evenimentului 'request' (cerere de la un client)

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

server.on ('request', function (cerere, raspuns) {
console.log ('Cerere de la clientul ' + cerere.headers['user-agent']);
raspuns.writeHead (200, { 'Content-Type': 'text/html' });

let contor = 0;
let interval = setInterval ( // generăm valori ale contorului conform intervalului de timp
function () {
raspuns.write ('<p>Contorul are valoarea ' + contor + '</p>');
console.log ('Contorul are valoarea ' + contor);
contor++;
if (contor >= 7) {
clearInterval (interval); // ștergem intervalul
raspuns.end (); // închidem fluxul de răspuns
console.log ('Am trimis raspuns clientului ' + cerere.headers['user-agent']);
}
}, 1000); // cod rulat la interval de 1000 milisecunde
});
Cerere de la clientul … Mozilla/5.0 (Windows NT 10.0 …) … Firefox/110.0
Contorul are valoarea 0
Contorul are valoarea 1
Contorul are valoarea 2

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Contorul are valoarea 3
Cerere de la clientul … Edg/112.0.1722.58
Contorul are valoarea 4
Contorul are valoarea 0 codul este rulat
Contorul are valoarea 5
Contorul are valoarea 1
asincron
Contorul are valoarea 6
Am trimis raspuns clientului … Mozilla/5.0 (Windows NT 10.0 …) … Firefox/110.0
Contorul are valoarea 2
Contorul are valoarea 3
Contorul are valoarea 4
Contorul are valoarea 5
Contorul are valoarea 6
Am trimis raspuns clientului … Edg/112.0.1722.58
Cerere de la clientul … Mozilla/5.0 (Windows NT 10.0 …) … Firefox/110.0
Contorul are valoarea 0
Contorul are valoarea 1
Contorul are valoarea 2

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Contorul are valoarea 3
Cerere de la clientul … Edg/112.0.1722.58
Contorul are valoarea 4
Contorul are valoarea 0
Contorul are valoarea 5
Contorul are valoarea 1
Contorul are valoarea 6
Am trimis raspuns clientului … Mozilla/5.0 (Windows NT 10.0 …) … Firefox/110.0
Contorul are valoarea 2
Contorul are valoarea 3
Contorul are valoarea 4
Contorul are valoarea 5
Contorul are valoarea 6
Am trimis raspuns clientului … Edg/112.0.1722.58

browser-ul Web va aștepta ca întreaga secvență de valori

de ce? să fie trimisă de către server
 node.js: evenimente

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Emiterea (lansarea) și tratarea (prinderea)
evenimentelor specificate de programator
se realizează via event.EventEmitter

clasă utilizată intern de multe biblioteci de bază

nodejs.org/api/events.html
const EventEmitter = require('events');
const cataclism = Symbol('©©©');
class Emițător extends EventEmitter {}

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

const emițător = new Emițător(); // un emițător de evenimente
// tratăm evenimentele 'bum' și 'cataclism'
emitator.on('bum', () => { console.log('Bum, bum, bum...'); });
emitator.on('cataclism', (e) => { console.error('Cataclism! ' + e.message); });
// emitem evenimente (proprii și deja existente)
try {
emițător.emit('bum');
emițător.emit('cataclism', new Error(cataclism.toString()));
emițător.emit('error');
} catch (e) {
console.error ('A survenit o eroare... ' + e.message);
}
const EventEmitter = require('events');
const cataclism = Symbol('©©©');
class Emițător extends EventEmitter {}

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

const emițător = new Emițător(); // un emițător de evenimente
// tratăm evenimentele 'bum' și 'cataclism'
emitator.on('bum', () => { console.log('Bum, bum, bum...'); });
emitator.on('cataclism', (e) => { console.error('Cataclism! ' + e.message); });
// emitem evenimente (proprii și deja existente)
try {
emițător.emit('bum');
emițător.emit('cataclism', new Error(cataclism.toString()));
emițător.emit('error');
} catch (e) {
> node 'emitere-evenim.js
console.error ('A survenit o eroare... + e.message);
Bum, bum, bum...
}
Cataclism! Symbol(©©©)
A survenit o eroare... Unhandled error. (undefined)
 node.js: module externe

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Funcția require () specifică utilizarea unui modul Node.js

module disponibile on-line

(instalate și gestionate via utilitarul npm)

tutorial:
www.sitepoint.com/npm-guide/
 node.js: module externe

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Funcția require () specifică utilizarea unui modul Node.js

instalare globală a unui modul: npm install modul –g

listarea modulelor ce sunt instalate local: npm list
căutarea unui modul: npm search modul
eliminarea unui modul: npm uninstall modul
actualizarea unui modul: npm update modul

amănunte la docs.npmjs.com
node.js: module – acces la baze de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Operații cu baze de date relaționale SQLite

recurgerea la modulul sql.js via compilatorul emscripten

utilizează o bază de date virtuală stocată în memoria RAM

(importă fișiere SQLite, exportă obiecte typed array)

detalii la www.npmjs.com/package/sql.js
 node.js: module – acces la baze de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Operații cu baze de date relaționale SQLite

sql.js nu depinde de alte module

actualmente, implementat în WebAssembly (WASM)

developer.mozilla.org/docs/WebAssembly

exemple demonstrative (interpretor SQL ca aplicație Web):

sql.js.org/examples/GUI/
node.js: module – acces la baze de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Operații cu baze de date relaționale

Sequalize
acces abstractizat via ORM (Object-Relational Mapping)
pentru servere relaționale: Postgres, MySQL, MariaDB,
SQLite și Microsoft SQL Server

sequelize.org
 node.js: module – acces la baze de date

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Operații cu baze de date relaționale

alternative ORM la Sequalize:

Objection.js – vincit.github.io/objection.js/
bazat pe Knex – a SQL query builder: knexjs.org
dev.to/mrscx/a-definitive-guide-to-sql-in-nodejs-with-objection-js-knex-part-1-4c2e

Bookshelf.js – bookshelfjs.org
tutorial: zetcode.com/javascript/bookshelf/
node.js: module – prelucrări HTML

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Procesarea documentelor HTML

modulul JSDOM conceput integral în JavaScript

simulează comportamentul unui browser Web

și are suport pentru execuție de script-uri JS
util pentru testare și preluarea datelor
din documente HTML (Web scraping)

github.com/jsdom/jsdom
 node.js: module – prelucrări HTML

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

const jsdom = require("jsdom");
const { JSDOM } = jsdom; // acces la obiectul JSDOM oferit de modul

const URL = "https://profs.info.uaic.ro/~busaco/teach/courses/web/index.html";

JSDOM.fromURL(URL, { storageQuota: 5000 }) // promite să preia datele

.then(dom => {
console.log
(dom.window.document.body.querySelector("p").textContent);
console.log(dom.serialize());
})
.catch(eroare => console.error ('Eroare! ' + eroare.message));
 node.js: module – prelucrări HTML

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

const jsdom = require("jsdom");
const { JSDOM } = jsdom; // acces la obiectul JSDOM oferit de modul

const URL = "https://profs.info.uaic.ro/~busaco/teach/courses/web/index.html";

JSDOM.fromURL(URL, { storageQuota: 5000 }) // promite să preia datele

.then(dom => {
console.log
(dom.window.document.body.querySelector("p").textContent);
console.log(dom.serialize()); DOM
})
.catch(eroare => console.error ('Eroare! ' + eroare.message));
> node mini-robot.js
fundația unui viitor dezvoltator Web profesionist
 node.js: module – prelucrări HTML

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Procesarea documentelor HTML

alternative la JSDOM:

htmlparser2 – procesor HTML/XML fără validare

github.com/fb55/htmlparser2

node-html-parser – axat asupra vitezei (DOM simplificat)

github.com/taoqf/node-html-parser
node.js: module – prelucrări XML

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Procesarea documentelor XML

fast-xml-parser – procesor XML↔JSON

naturalintelligence.github.io/fast-xml-parser/

libxmljs – portarea bibliotecii LibXML

libxmljs.github.io/libxmljs/

parse-xml – procesor rapid, fără dependențe

rgrove.github.io/parse-xml/
Aspecte vizând arhitectura și
ingineria aplicațiilor Node.js?

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

 node.js: multithreading

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Actualmente (Node.js 12+), există suport
pentru fire de execuție multiple via modulul worker_threads

utilizări tipice: operații de calcul îndelungate

(CPU-intensive operations)

nodejs.org/api/worker_threads.html

medium.com/lazy-engineering/node-worker-threads-b57a32d84845
 event loop + worker thread pool

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

activitățile consumatoare de timp pot fi efectuate de
„lucrători” (workers) – programe JS neinteractive

itnext.io/an-intro-to-node-js-that-you-may-have-missed-b175ef4277f7
 node.js: pachete

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Un proiect (aplicație) Node.js compus(ă) din fișiere
multiple poate fi organizat ca un pachet/modul
 node.js: pachete

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

package.json

meta-date (numele pachetului, versiune, autor,…) +

informații privind dependențele de alte module

docs.npmjs.com/creating-a-package-json-file
{
"name": "WebApp",
node.js: module – prelucrări HTML
"version": "1.0.0",
"main": "index.js",

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

"dependencies": {
"xml": "^1.0.1", main specifică numele fișie-
"another_dep": "~2.2.0" rului (uzual, index.js) ce va fi
}, încărcat când modulul este
"devDependencies" : {
"test_framework": "1.0.0 - 1.2.0" solicitat de altă aplicație
}
"keywords": [ "xml", "json" ], poate reprezenta programul
"license": "BSD-2-Clause", principal, executat primul
"author": {
"name": "Tuxy Pinguinnesscool", de mediul de rulare
"email": "[email protected]"
},
"description": "…"
}
{
"name": "WebApp",
node.js: module – prelucrări HTML
"version": "1.0.0",
"main": "index.js",

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

"dependencies": {
"xml": "^1.0.1", dependențele de alte module
"another_dep": "~2.2.0" se declară via dependencies
}, + aspecte vizând versiunea
"devDependencies" : { docs.npmjs.com/about-semantic-versioning
"test_framework": "1.0.0 - 1.2.0"
}
"keywords": [ "xml", "json" ], devDependencies include
"license": "BSD-2-Clause", dependențele necesare doar
"author": {
"name": "Tuxy Pinguinnesscool", în faza de dezvoltare
"email": "[email protected]"
},
"description": "…"
}
 node.js: pachete

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Un pachet poate avea un domeniu de vizibilitate (scope)
docs.npmjs.com/about-scopes

package.json poate fi generat automat cu npm init sau

npm init --scope=@organizație
 node.js: pachete

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Pachetele care n-au specificat domeniul de vizibilitate
sunt considerate automat publice

pachetele private trebuie să aibă obligatoriu asociat

un domeniu de vizibilitate
(private packages are always scoped)
 node.js: pachete

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Pentru publicarea în registrul on-line al modulelor NPM
se folosește npm publish

docs.npmjs.com/cli/publish
 node.js: pachete

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

package-lock.json

generat automat când se modifică arborele de module

(node_modules) sau fișierul package.json
descrie arborele curent de dependențe al unui proiect
pentru a facilita instalarea și mentenanța
docs.npmjs.com/files/package-lock.json
 node.js: pachete

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

vezi arhiva
exemplelor

editarea, organizarea și rularea on-line a codului Node.js

cu instrumentul Web Replit – replit.com/languages/nodejs
aici, un program ce transformă date JSON în format XML
pe baza modulului extern xml
 node.js: framework-uri web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Uzual, încurajează dezvoltarea de aplicații Web
în care interacțiunea cu utilizatorul
se realizează într-o singură pagină
(SPA – Single-Page Applications)

real-time single-page Web apps

Paul Sherman, How Single-Page Applications Work (2018)

blog.pshrmn.com/how-single-page-applications-work/
 node.js: framework-uri web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Alte facilități notabile:

MVC (Model-View-Controller) și variantele

transfer de date în timp-real – e.g., cu Socket.IO
servicii Web – REST și/sau GraphQL
suport pentru baze de date (No)SQL
machete de redare a conținutului (templates)

Alex Ivanovs, The Most Popular Node.js Frameworks in 2023

stackdiary.com/node-js-frameworks/
 node.js: framework-uri web – express

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Framework minimalist
ce încurajează dezvoltarea de aplicații Web

tradiționale – reprezentări multiple via hipermedia

bazate pe un unic punct de acces: SPA (Single Page App)
hibride (Web + aplicații native)

expressjs.com
developer.mozilla.org/docs/Learn/Server-side/Express_Nodejs
.
├── app.js
├── bin
│ └── www
├── package.json
├── public conținut static destinat clientului

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

│ ├── images
│ ├── javascripts (e.g., foi de stiluri CSS, biblioteci JS
│ └── stylesheets procesate de browser, imagini,…)
│ └── style.css
├── routes rute vizând deservirea cererilor pe
│ ├── index.js
│ └── users.js baza URL-urilor solicitate de client
└── views specificarea interfeței (view-ul)
├── error.pug
├── index.pug via machete de vizualizare bazate
└── layout.pug pe Pug: pugjs.org

eșafodajul unei aplicații Web bazate pe Express

create cu express --view=pug web-project

implicit, aplicația va putea fi accesată la http://localhost:3000/

 node.js: framework-uri web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

MEAN (MongoDB, Express, Angular, Node.js)

Matthew Martin, What is Mean Stack Developer? (2023)

www.guru99.com/mean-stack-developer.html
 node.js: framework-uri web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

MEAN recurgând la un API REST
 node.js: framework-uri web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

MERN (MongoDB, Express, React, Node.js)

tutoriale:
MERN Stack
www.mongodb.com/mern-stack
MERN stack A to Z
blog.logrocket.com/mern-stack-tutorial/
 node.js: framework-uri web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

pentru acces asincron la serverul MongoDB
se poate folosi modulul Mongoose
mongoosejs.com
node.js: framework-uri web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Alternative/specializări:

Adonis – adonisjs.com/docs/
Fastify – www.fastify.io/docs/latest/
Koa.js – github.com/koajs
Lad – github.com/ladjs/lad
Loopback – loopback.io/doc/
Nanoexpress – nanoexpress.js.org
Nest – docs.nestjs.com
Sails – sailsjs.com/documentation/concepts
 node.js: framework-uri web

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Implementarea (micro-)serviciilor Web
ghiduri practice:
blog.logrocket.com/building-microservices-node-js/
www.twilio.com/blog/building-javascript-microservices-node-js
 node.js: utilizări pragmatice

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Deservirea unui volum mare de conexiuni
concurente cu necesar minim de resurse
(procesor, memorie) într-un singur proces
 node.js: utilizări pragmatice

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Procesarea în timp-real
a datelor JSON oferite de API-uri (multiple)

inclusiv, crearea de aplicații

oferind fluxuri de date (streaming data)

context: Internet Web of Things

 node.js: utilizări pragmatice

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Procesarea în timp-real
a datelor JSON oferite de API-uri (multiple)

studii de caz:
www.pubnub.com/blog/tag/node-js/
 node.js: utilizări pragmatice

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Dezvoltarea rapidă de servicii Web
sau API-uri conform paradigmei REST
(REpresentational State Transfer) ori GraphQL

framework-uri pentru dezvoltarea de API-uri – exemple:

egg, Hapi, LoopBack, NestJS,
Restgoose, restify, TypeGraphQL
 node.js: utilizări pragmatice

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Crearea de aplicații native (desktop)
folosind tehnologii Web moderne precum HTML5

NW.js (fost node-webkit) – nwjs.io

utilizarea modulelor Node.js
direct la nivel de DOM via Chromium
node.js: instrumente de dezvoltare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Mediu de dezvoltare tradițional (desktop)

exemplificări:
Node.js in Visual Studio Code
code.visualstudio.com/docs/nodejs/nodejs-tutorial
Node.js Tools for Visual Studio
visualstudio.microsoft.com/vs/features/node-js/
 node.js: instrumente de dezvoltare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

execuția aplicațiilor Node.js în „nori”: AWS SDK for JS
docs.aws.amazon.com/sdk-for-javascript/
aws.amazon.com/sdk-for-javascript/
 node.js: instrumente de dezvoltare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

execuția aplicațiilor Node.js în „nori”: Azure SDK for JS
learn.microsoft.com/en-us/azure/developer/javascript/
Azure Tools for Visual Studio Code
github.com/microsoft/vscode-node-azure-pack
 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
execuția aplicațiilor Node.js în „nori”:
Node.js on Google Cloud – cloud.google.com/nodejs/
 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
execuția aplicațiilor Node.js în „nori”: Node.js on Heroku
www.heroku.com/nodejs
Getting Started on Heroku with Node.js
devcenter.heroku.com/articles/getting-started-with-nodejs
 node.js: instrumente de dezvoltare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

În cazul DigitalOcean, a se explora tutorialele
www.digitalocean.com/community/tutorials?q=[JavaScript]
 node.js: instrumente de dezvoltare

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

În contextul generării statice de conținuturi oferite de
API-uri (JAMstack), a se considera soluții precum Netlify
în conjuncție cu generatoare de situri Web statice
(e.g., Docusaurus, Gatsby, Next.js, Nuxt) și sisteme de
management al conținutului (Ghost, Strapi, Webiny,...)
jamstack.org/generators/
 node.js: alternative

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Deno

a JavaScript, TypeScript, and WebAssembly runtime

built on V8, Rust, and Tokio

deno.land/manual
 node.js: alternative

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Bun

an all-in-one toolkit for JavaScript and TypeScript

designed as a faster, leaner,
more modern replacement for Node.js

bun.sh/docs
 Câteva studii
de caz concrete…

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

 node.js: exemplu – smartfetcher

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Scop: recomandare în timp-real de știri de interes
(ziare, blog-uri,…), pe baza profilului utilizatorului
și a interacțiunii sale cu sistemul

recurge la tehnici de învățare automată, în funcție și

de sentimentul manifestat față de un articol dat
 arhitecturi: exemplu – smartfetcher

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

la nivel de server (backend): Node.js (framework-ul Sails)
API REST – eventual, folosit via WebSocket-uri
pentru comunicarea în timp-real cu clienții

pe partea client (frontend): Angular și Bootstrap

 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
proiect de licență al absolvenților Raluca Jalaboi & Bogdan
Spiridon (Facultatea de Informatică, UAIC Iași, 2015)
 node.js: exemplu – muser

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

MuSeR (Music Smart Enhancer) – a cross-platform semantic
Web application developed for music lovers able to generate
& manage in a “smart” way favorite playlists

surse de date/cunoștințe externe: DBpedia + Spotify

implementare Node.js bazată pe micro-servicii Web:
Serverless Framework – serverless.com
exploatare în „nori” via AWS (Amazon Web Services)
independența de client facilitată de Ionic
 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
Lila-Ciprian Lazăr, Alexandru Cristea, Dan Cehan
(studii de master @ FII, UAIC Iași, 2017—2018)
cypmaster14.github.io/MuSer/
 node.js: exemplu – harperdb

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

HarperDB – sistem scalabil conceput în Node.js pentru
management de baze de date via un API REST: harperdb.io

hackernoon.com/brief-history-of-how-we-develop-harperdb-pb3z33qr
 node.js: exemplu

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Stive tehnologice (tech stacks) ce includ Node.js

tech stack
desemnează mulțimea tehnologiilor – limbaje,
framework-uri, biblioteci, servere, soluții de interacțiune
cu utilizatorul, utilitare, metodologii etc. – pe care
un producător software le folosește
pentru a dezvolta o aplicație (Web, mobilă,…)
 Dr. Sabin Buragaprofs.info.uaic.ro/~busaco
inspectarea
tehnologiilor folosite
de o aplicație Web
cu instrumentul
WhatRuns
 stackshare.io/ebay/ebay/
node.js: exemplu

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

 node.js: exemplu

stackshare.io/udemy/udemy/

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

 node.js: exemplu

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

stackshare.io/food-and-more/food-and-more/
 node.js: exemplu

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

stackshare.io/bootstrapcdn/bootstrapcdn/
 node.js: alte resurse utile

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

Design, Architecture & Best Practices
alexkondov.com/tao-of-node/
github.com/goldbergyoni/nodebestpractices
devcenter.heroku.com/articles/node-best-practices
Awesome Node.js
github.com/sindresorhus/awesome-nodejs
Node Weekly
nodeweekly.com
#nodejs Stories @ Hacker Noon
hackernoon.com/tagged/nodejs
 rezumat

Dr. Sabin Buragaprofs.info.uaic.ro/~busaco

⍟
dezvoltarea de aplicații Web la nivel de server
cu Node.js – caracteristici, module, exemple