Sei sulla pagina 1di 28

Michele Armellini

NODE.JS E MONGODB ALLA


CONQUISTA DEL WEB
Tesina esame di stato
Anno scolastico 2014/2015

ISTITUTO TECNICO INDUSTRIALE MICHELANGELO BUONARROTI – TRENTO


Classe 5 INA
-2-
Indice

1 Introduzione....................................................................................................................... - 4 -
2 Tecnologie utilizzate.................................................................................................... - 5 -
2.1 HTML ........................................................................................................................... - 5 -
2.2 Jade ................................................................................................................................ - 7 -
2.3 Javascript...................................................................................................................... - 9 -
2.3.1 Node.js ................................................................................................................. - 10 -
2.4 Database NoSQL..................................................................................................... - 13 -
2.4.1 MongoDB............................................................................................................ - 15 -
3 Sistema realizzato ........................................................................................................... - 19 -
4 Conclusioni...................................................................................................................................... - 25 -

-3-
1 Introduzione
Fin dalla sua nascita, l’informatica è sempre stata caratterizzata da una forte crescita.
Negli ultimi quindici anni questa crescita si è sempre più accentuata, soprattutto per
quanto riguarda il mondo del web che ha infatti guadagnato sempre più popolarità.

Si è cominciato ad esempio a sostituire le tecnologie che si utilizzavano da anni con


altre sempre più recenti e innovative; si è iniziato a sacrificare la semplicità di
utilizzare dei web server basati su PHP a favore dell’efficienza di un server che
gestisce le richieste in modo asincrono, oppure si è sostituita la tradizione delle basi
di dati relazionali con modelli diversi a seconda del contesto in cui si vanno ad
utilizzare.

In questa tesina sono andato ad analizzare alcune di queste tecnologie innovative e a


realizzare un piccolo progetto che le ha viste coinvolte per testarne le potenzialità.
Ho realizzato infatti un piccolo sistema di login che consiste in un server realizzato
tramite node.js e una base di dati MongoDB.

Per rendere le pagine più piacevoli alla vista ho scelto di utilizzare anche Semantic-
UI, un framework che consiste in un file CSS già pronto per l’utilizzo che aiuta a
realizzare pagine sia belle dal punto di vista estetico che responsive, permettendone
una visione corretta sia da schermi grandi che da quelli piccoli di telefoni o tablet.

-4-
2 Tecnologie utilizzate

2.1 HTML

L’HTML (HyperText Markup Language) è un linguaggio di mark-up utilizzato


esclusivamente per la formattazione e l’impaginazione di pagine Web, ovvero per la
definizione del contenuto delle pagine e di come questo contenuto appare.

Sviluppato da Tim Berners-Lee al CERN di Ginevra negli anni ottanta, questo


linguaggio si basa interamente su dei tag composti da una serie di caratteri compresi
tra parentesi uncinate, ovvero i segni di maggiore e minore.

La struttura della pagina è sempre la stessa:

 Un tag detto DTD (Document Type Definition) nella prima


riga e che serve a indicare lo standard che viene utilizzato nel
resto del documento, in modo che sia possibile interpretarlo
e comprenderlo;

<!DOCTYPE html>

 Un tag <html> </html> che racchiude tutta la pagina,


suddivisa in head e body;
 Il tag <head> che rappresenta l’intestazione e contiene
principalmente informazioni di definizione che non vengono
visualizzate dal browser;
 Il tag <body> che contiene il vero contenuto della pagina
che verrà visualizzata nel browser. Esempi di elementi sono:
immagini, testi e collegamenti.

-5-
1 Struttura generale di un documento HTML

-6-
2.2 Jade

Jade è un linguaggio di templating che permette di generare delle pagine HTML


utilizzando anche variabili e semplici controlli su di esse all’interno del codice.

Nonostante possa sembrare molto simile a PHP, la funzionalità di questo linguaggio è


appunto quella di generare delle pagine dinamicamente attraverso i dati che vengono
passati come parametri.

L’utilità di questo linguaggio è principalmente quella di permettere anche ai web-server


che non sono basati su PHP, e che quindi non generano delle pagine HTML
direttamente, ma ne forniscono alcune solo in determinate condizioni, di modificare il
contenuto di queste pagine in base ai dati di un database ad esempio.

La sintassi di Jade ricorda molto quella di HTML, infatti i nomi dei vari tag rimangono
invariati, mentre cambia solo la formattazione con cui vengono inseriti in una pagina. Per
quanto riguarda la chiusura di questi tag è basato sull’indentazione, ovvero gli elementi
che vengono dichiarati con un’indentazione maggiore saranno figli di quelli precedenti, in
maniera simile di quello che avviene con python.

-7-
Per fare un esempio più concreto e comprensibile il codice in Jade

doctype html

html

head

title= pageTitle

body

h1 Jade - node template engine

#container.col

if youAreUsingJade

p You are amazing

else

p Get on it!

Verrebbe tradotto nel seguente codice HTML

<!DOCTYPE html>

<html lang="en">

<head>

<title>Jade</title>

</head>

<body>

<h1>Jade - node template engine</h1>

<div id="container" class="col">

<p>You are amazing</p>

</div>

</body>

</html>

-8-
2.3 Javascript

Javascript è un linguaggio di scripting creato nel 1995 per il browser Netscape 2 da


Brendan Eich. E’ il più utilizzato per quanto riguarda la scrittura di programmi web-
based e una delle principali caratteristiche è il fatto che il codice non sia compilato
ma venga interpretato dal programma che esegue lo script, mettendo spesso a
disposizione operazioni specifiche normalmente non incluse nei costrutti del
linguaggio.

Il principale motivo del successo di Javascript e’ dovuto al fatto di poterlo integrare


all’interno di pagine HTML e di poterlo far interagire quindi con il DOM del
browser e compiere azioni dinamiche. E’ possibile ad esempio caricare dei nuovi
contenuti sulle pagine tramite Ajax senza dover ricaricare l’intera pagina, oppure
animare gli elementi di una pagina.

Come la maggior parte dei linguaggi di scripting, Javascript adotta una tipizzazione
dinamica, ovvero il tipo è associato ai valori e non alle variabili. Questo ha riscontro
anche per gli oggetti nel “Duck typing” (il nome deriva dall’affermazione di James
Whitcomb “Quando vedo un uccello che cammina come un'anatra, nuota come
un'anatra e starnazza come un'anatra, io chiamo quell'uccello 'anatra' "), dove si è
interessati solo a quegli aspetti di un oggetto che vengono utilizzati, piuttosto che al
tipo di oggetto stesso. Ovvero non importa di che tipo sia un oggetto, purche’ siano
esistenti i metodi che vengono chiamati.

-9-
2.3.1 Node.js

Node.js è un framework Open-source che permette di realizzare applicazioni web


scritte in Java-Script anche nel lato server basato sul motore V8 di Google, utilizzato
dal famoso browser Chrome.

E’ stato inventato nel 2009 da Ryan Dahl e inizialmente pubblicato per l’utilizzo
soltanto su sistemi operativi basati su Linux. Dalla presentazione dell’8 novembre
2009 alla conferenza europea JSConf, Node ha cominciato a prendere piede,
registrando una forte crescita sia nella popolarità che nel numero di utilizzi. Da
allora sono stati portati numerosi miglioramenti e aggiunte come l’introduzione del
packet manager npm, ovvero un software che permette agli utenti di installare dei
moduli che aggiungono ulteriori funzionalità a Node.js.

Una delle principali caratteristiche di Node è il fatto che sia orientato verso lo
sviluppo di codice asincrono. Linguaggi di programmazione come Java o Perl di
solito implicano lo sviluppo di applicazioni che gestiscono le richieste in modo
sincrono. Spesso questo significa avere un ciclo in cui il server sta in attesa su una
specifica porta e per ogni richiesta viene assegnato o creato un thread che si
occuperà di gestire la comunicazione con il client. Questo implica che ogni richiesta
sia bloccante, ovvero che ogni istruzione viene eseguita soltanto al termine di quella
precedente ed eventualmente sospenderà il thread durante l’attesa. E’ proprio per
questo che è stato creato il pattern di programmazione asincrono, che consiste in un
server che andrà ad eseguire alcune parti di codice soltanto al verificarsi di alcuni
eventi come ad esempio la connessione di un utente.

Node.js lavora utilizzando un singolo thread, permettendo la concorrenza di migliaia


di connessioni simultaneamente principalmente grazie all’utilizzo di callback, ovvero
delle funzioni che verranno automaticamente chiamate al termine di alcune
operazioni. E che non bloccano l’esecuzione del resto del codice. Un vantaggio
indiscusso dell’utilizzo di soltanto un thread è quello di non dover effettuare nessun

- 10 -
Context-switch, l’operazione che permette di cambiare il processo o thread in
esecuzione su una delle CPU e che comporta una grossa perdita di tempo.

Altro motivo per cui un server web asincrono è migliore è il fatto che confrontando
i tempi di lavoro dei processori al giorno d’oggi con il tempo di trasmissione nella
rete si puo’ notare che ci sono diversi ordini di grandezza di differenza. Questo
comporta che andranno persi numerosi cicli di clock del processore tra una richiesta
e l’altra.

2 Differenze tra Web-Server sincrono e quello asincrono

Per scrivere un server in node.js è necessario utilizzare la libreria http. L’unico passo
che bisogna effettuare è utilizzare la funzione http.createServer a cui viene passata
una callback.

Ecco un esempio:

var http = require(’http’);


http.createServer(function (req, res) {
res.end(’Hello World\n’);
}).listen(80, ’127.0.0.1’);
console.log(’Server running at http://127.0.0.1:80/’);

- 11 -
La funzione passata come parametro a createServer verrà invocata ad ogni ricezione
di una richiesta da parte del server e assumerà come parametri:

• request (req), un oggetto della classe http.ServerRequest che rappresenta


la richiesta HTTP e dalla quale si possono leggere eventuali parametri
inviati tramite i metodi GET e POST;
• response (res), un’istanza della classe http.ServerResponse, che
rappresenta la risposta che verrà mandata al client e che contiene il
contenuto che si vorrà inviare all’utente ed eventuali altre informazioni.

- 12 -
2.4 Database NoSQL

NoSQL è l'acronimo di “Not only SQL” ed è usato per identificare tutti quei
database che non fanno uso di un modello di dati relazionale, infatti non è detto che
siano presenti concetti come tabella, indici, chiavi primarie o esterne.

All’opposto di quanto potrebbe sembrare, il movimento NOSQL non è contrario


all'utilizzo di database relazionali. Come vuole rappresentare l’acronimo, esistono
diversi casi d'uso per i quali il modello relazionale non rappresenta una soluzione
ottimale, ma più una forzatura, ma tanti altri per i quali tale modello è ancora la
soluzione migliore.

Tra i principali esponenti possiamo trovare Google con il suo BigTable e Amazon
con DynamoDB. Da questi esperimenti sono nati i primi database NoSQL, quasi
tutti Open Source, ognuno caratterizzato da strutture dati diverse ma con alcune
caratteristiche in comuni:

- schema-free;
- la gestione di un'enorme quantità di dati garantendone comunque un
rapido accesso;
- la facilità di replicazione;
- l'utilizzo di api per l'interfacciamento con i più noti linguaggi di sviluppo
ed un abbandono di SQL.

Con l’evoluzione di Internet negli ultimi venti anni c’è stato un aumento
esponenziale della quantità di informazioni che gli utenti possono ottenere tramite
internet e basi di dati sempre più grandi. Scalare verticalmente, ovvero potenziare
dal punto di vista hardware l’infrastruttura già esistente, cominciava a diventare
troppo inefficiente ed inefficace a mantenere una disponibilità dei servizi
accettabile.

- 13 -
Dopo la nascita di Database che puntavano su una scalabilità orizzontale, ci si
accorse che questa portava non pochi problemi e nel 2000 Eric Brewer formulò
quello che viene chiamato teorema CAP e che afferma l’immpossibilita’ in un
sistema distribuito di garantire contemporaneamente:

- Consistenza (Consistency), ovvero che dopo ogni operazione il sistema


si trovi in uno stato consistente e che quindi tutti i nodi del sistema
abbiano gli stessi dati nello stesso momento;
- Disponibilità (Availability), ovvero che l’eventuale guasto o errore in un
nodo non blocchi l’intero sistema;
- Tolleranza di Partizione (Partition Tolerance), ovvero che il sistema
continui ad operare nonostante arbitrarie perdite di messaggi.

3 Classificazione dei DBMS in base alle garanzie offerte.

- 14 -
2.4.1 MongoDB

MongoDB è un DBMS non relazionale, facente quindi parte del movimento


NoSQL, orientato ai documenti. Questo significa che non è basato su tabelle come i
classici database relazionali, ma utilizza documenti in stile JSON con schema
dinamico che vengono chiamati BSON. JSON (JavaScript Object Notation) è un
formato nato per lo scambio di dati, facile da leggere per gli umani e da analizzare
per le macchine.

MongoDB ha una struttura differente da un database relazionale: al posto delle


tabelle ci sono le collection, ovvero una raccolta di documenti che possono avere
una struttura diversa (ad esempio un diverso numero di attributi o addirittura
attributi di diverso tipo) ma che sono simili o che sono simili semanticamente. I
documenti invece possono essere paragonati a dei record e consistono in una serie
di coppie chiave-valore in cui il valore può assumere diversi tipi e, in alcuni casi, può
essere anche un altro documento.

Esistono tipi di dato speciali come ObjectId che, se non vengono valorizzati
dall’utente hanno la peculiarità di venire valorizzato automaticamente. ObjectId è
infatti un tipo di dato del formato BSON che viene generato con criteri di unicità.
Ha una struttura di dimensione pari a 12 byte così composta:

 4 byte contenenti i secondi trascorsi dal 1° gennaio 1970 al momento attuale di


creazione (timestamp unix-like)
 3 byte raffiguranti l'id della macchina di creazione
 2 byte raffiguranti l'id del processo di creazione
 3 byte di contatore incrementale

- 15 -
4 Struttura ObjectId

3 Esempio di documento con evidenziata la possibilita’ di contenere altri documenti annidati.

MongoDB offre numerosi vantaggi rispetto ai tradizionali DBMS relazionali, tra i


quali:

 Assenza di una struttura: a differenza dei database relazionali dove in


una tabella ogni riga ha lo stesso numero di attributi dello stesso tipo, in
MongoDB ogni collezione (collection, ovvero il corrispettivo di una
tabella) può contenere documenti diversi tra loro nel numero di attributi
o nel loro tipo;

 Struttura del singolo oggetto è chiara e di facile comprensione;

 Assenza di complesse operazioni di unione tra le tabelle;

 Scalabilità facile da realizzare;

 Non è necessaria alcuna conversione tra i dati che si utilizzano


nell’applicazione e quelli nel database;
 Viene utilizzata la memoria RAM per mappare in modo persistente i
file.

- 16 -
RDBMS MongoDB

Database Database

Table Collection

Tuple/Row Document

column Field

Table Join Embedded Documents

Primary Key Primary Key (Default key _id provided by


mongodb itself)

5 Differenze terminologia tra MongoDB e un qualsiasi database relazionale

Caratteristica importante è quella della scalabilità, MongoDB offre infatti la


possibilità di replicare un database su server differenti, rendendolo quindi scalabile
orizzontalmente. La replicazione crea delle copie dei dati sui diversi nodi in modo da
ottenere ridondanza che garantisce dati sempre aggiornati anche in caso di guasti. E’
inoltre possibile utilizzare i nodi secondari per permettere l’accesso ai vari client,
ampliando così il numero di richieste contemporanee che si possono soddisfare.

Il sistema di replicazione chiamato replica set, è basato su un modello master-slave


con failover automatico. Esiste quindi un nodo primario su cui vengono
reindirizzate tutte le varie operazioni sui dati e che vengono registrate sul suo
“oplog”, un registro contenente le informazioni minime per riuscire a replicare
l’operazione. Periodicamente i nodi secondari controlleranno il proprio oplog per
verificare quando è stata eseguita l’ultima operazione e andranno poi a reperire tutte
le operazioni successive dall’oplog del server primario. Periodicamente vengono
anche mandati dei messaggi di stato chiamati heartbeat tra i vari server. Quando il
server primario non è più raggiungibile, quelli secondari ne eleggono uno nuovo in

- 17 -
base alla sua priorità e in caso di più nodi con pari priorità quello con i dati più
recenti.

6 Elezione di un nuovo nodo primario in un replica set.

- 18 -
3 Sistema realizzato
Per prima cosa è stato realizzato quello che poi verrà usato come server. Nonostante
inizialmente fossi intenzionato ad utilizzare javascript “puro”, ovvero senza librerie
di terze parti, dopo svariati tentativi nel capirne la logica ho optato per utilizzare la
libreria forse più famosa per la gestione delle richieste, ovvero express.

Analizzeremo ora il file server.js, che gestisce le richieste, fornendo pagine HTML e
connettendosi al database.

var express = require('express'),


http = require('http'),
mongoose = require('mongoose');
var app = express();

Nella prima parte del file server.js vengono inizializzate le librerie che verranno
utilizzate, ovvero express per quanto riguarda la gestione delle richieste e mongoose
per collegarsi alla base di dati MongoDB.

mongoose.connect("mongodb://localhost/etrentin");
var UserSchema = new mongoose.Schema({
username: String,
password: String,
nome: String,
cognome: String
});
var User = mongoose.model('users', UserSchema);

Nella prima di queste righe di codice viene stabilita la connessione con il database.
Le seguenti servono per definire la struttura del documento “users” che è quello nel
quale verranno verificate le credenziali. Si può notare il formato simile a JSON del
documento, con un tag seguito dai due punti e, in questo caso essendo uno schema,
dal tipo di dato che ospiterà.

- 19 -
app.configure(function () {
app.use(express.bodyParser());
app.use(express.session());
app.use(express.static(__dirname + '/public'));
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
});

La funzione app.configure viene chiamata all’inizializzazione del server e il suo


scopo è quello di impostare correttamente express. Le prime due righe all’interno
della funzione di callback servono ad aggiungere queste parti di libreria al web server
in modo che possano essere eseguite. La terza riga viene utilizzata per avere accesso
ad alcuni file presenti nel server ma per i quali non si vogliono gestire manualmente
le richieste. Lo ho utilizzato per potere accedere ai file CSS dalle varie pagine
HTML. Le ultime due righe servono per far sapere al web server che le pagine che
dovrà restituire non sono in formato HTML, ma in Jade e che quindi dovrà
generarsi i file HTML quando richiesti a partire dai template presenti nella cartella
views.

function authenticate(name, pass, result) {


console.log('authenticating %s:%s', name, pass);
User.findOne({ 'username': name }, function (err, user) {
if (user) {
console.log("user found");
if (pass == user.password)
return result(null, user);
else
return result(new Error("Wrong Password"));
}
return result(new Error("User not found"));
});
}

Questa è una funzione di utility che viene utilizzata per effettuare la query nel
database e verificare se un utente con quell’username e quella password è presente.

- 20 -
Viene chiamata alla ricezione dei dati che l’utente ha inserito e, in caso non esista
viene generato un errore che spiega il motivo per cui il login è fallito. Per motivi di
debug viene anche scritto nella console un messaggio di log in cui si possono vedere
i campi inseriti dall’utente.

app.get("/", function (req, res) {


if (req.session.user) {
res.render("home",{user_nome: req.session.user.nome,
user_cognome:req.session.user.cognome});
} else {
res.redirect("login");
}
});
app.get("/login", function (req, res) {
if (!req.session.user) {
res.render("login");
} else {
res.redirect("/");
}
});
app.post("/login", function (req, res) {
authenticate(req.body.username, req.body.password, function (err, user) {
if (user) {
req.session.regenerate(function () {
req.session.user = user;
res.redirect('/');
});
} else {
res.render('error',{error : err.message});
}
});
});
app.get('/logout', function (req, res) {
req.session.destroy(function () {
res.redirect('/');
});
});

In questa serie di app.get e app.post vengono gestite le richieste che il server può
ricevere, appunto tramite i metodi get e post.

Nella prima ‘route’ se l’utente non è già loggato e quindi la variabile di sessione user
non è impostata, viene fatto un redirect sulla pagina di login. Allo stesso modo se
l’utente richiede la pagina di login ma era già loggato viene rimandato alla homepage.
Si può notare come il sistema gestisca le pagine scritte in Jade. Viene infatti chiamata
la funzione render che si occupa di generare e inviare il file HTML corrispondente,

- 21 -
prendendo in considerazione anche i campi passati come parametro in formato
JSON; Ad esempio nel render della homepage viene passato
{user_nome: req.session.user.nome, user_cognome:req.session.user.cognome}

e verra’ utilizzato all’interno della pagina per fare apparire sullo schermo il nome e il
cognome dell’utente che ha fatto l’accesso, se presenti nel database.

Altre parti significative del codice sono quella della pagina /logout, che non viene
realmente visualizzata ma appena ci si arriva viene cancellata la variabile di sessione,
rendendo di fatto il login obbligatorio e viene fatto un redirect alla pagina di login.

Importante è anche la gestione dei dati inviati dall’utente, nella pagina /login e
tramite il metodo post. Viene chiamata la funzione authenticate passando una
funzione di callback. In caso il parametro user sia impostato, l’autenticazione è
andata a buon fine e la sessione viene rigenerata, impostando la variabile user e
reindirizzando l’utente verso la sua homepage. In caso contrario viene visualizzata la
pagina di errore e tramite Jade viene stampato il motivo dell’errore.

http.createServer(app).listen(80);
console.log("server created on localhost:80");

Con queste ultime due linee di codice infine viene creato il server che starà in
ascolto sulla porta 80 per le eventuali richieste. Viene anche scritto nella console un
messaggio di log per assicurarsi che l’applicazione sia partita.

- 22 -
Sono parte del server anche i tre file home.jade, login.jade e error.jade.

Login.jade

doctype html
html
head
meta(charset='utf-8')
link(href='/css/semantic.css', rel='stylesheet')
link(href='http://fonts.googleapis.com/css?family=Source+Sans+Pro:400,700|Open+Sans
:300italic,400,300,700' ,rel="stylesheet", type="text/css")
script(src="http://cdnjs.cloudflare.com/ajax/libs/jquery/2.0.3/jquery.js")
script(src="http://cdnjs.cloudflare.com/ajax/libs/jquery.address/1.6/jquery.address
.js")
script(src='css/semantic.js')
title=Login
body
div(class="ui one column stackable center aligned page grid")
div(class="column seven wide")
div(class="ui seven wide blue column form segment")
form(class="ui form", name="login", method="post", action="/login")
p
lable(for="username") Username
input(type="text", name="username", placeholder="Insert Userame
Here")
p
lable(for="password") Password
input(type="password", name="password", placeholder="Insert
Password Here")
p
input(type="submit", class="ui primary button", value="Submit")

Home.jade

doctype html
html
head
meta(charset='utf-8')
link(href='/css/semantic.css', rel='stylesheet')
script(src="http://cdnjs.cloudflare.com/ajax/libs/jquery/2.0.3/jquery.js")

script(src="http://cdnjs.cloudflare.com/ajax/libs/jquery.address/1.6/jquery.address.js"
)

link(href='http://fonts.googleapis.com/css?family=Source+Sans+Pro:400,700|Open+Sans:300
italic,400,300,700' ,rel="stylesheet", type="text/css")
script(src='css/semantic.js')
title='Homepage - '+user_nome+' '+ user_cognome
body
div(class='ui one column stackable center aligned page grid')
div(class='column seven wide')
div(class='ui seven wide blue column form segment')
h1 Welcome #{user_nome} #{user_cognome}
a(class="ui primary button", href="logout") Logout

- 23 -
Error.jade

doctype html
html
head
meta(charset='utf-8')
link(href='/css/semantic.css', rel='stylesheet')

script(src="http://cdnjs.cloudflare.com/ajax/libs/jquery/2.0.3/jquery.js")

script(src="http://cdnjs.cloudflare.com/ajax/libs/jquery.address/1.6/jquery.a
ddress.js")

link(href='http://fonts.googleapis.com/css?family=Source+Sans+Pro:400,700|Ope
n+Sans:300italic,400,300,700' ,rel="stylesheet", type="text/css")
script(src='css/semantic.js')
title='Error'
body
div(class='ui one column stackable center aligned page grid')
div(class='column seven wide')
div(class='ui seven wide blue column form segment')
h1 #{error}
a(class="ui primary button", href="login") Try again

Per avviare il server bisogna innanzitutto aver installato mongodb e node, componenti
indispensabili, una volta installati bisogna, tramite il comando npm install, installare le
dipendenze che si andranno ad utilizzare, in questo caso express, mongoose e jade.

Una volta installate le dipendenze si è pronti per avviare il database e creare una
collection. Una volta che il database è pronto e gli utenti sono stati inseriti, basta portarsi
nella cartella contenente il file del server ed eseguire il comando node server.js.

- 24 -
4 Conclusioni

In questa tesina sono state analizzate alcune tecnologie che sono emerse negli ultimi
anni e che si presentano come delle ottime alternative a quelle classiche. È stato
realizzata inoltre un’applicazione che le utilizzasse e ne testasse le principali
funzionalità. Questo sistema non è ancora perfetto, manca la parte di sicurezza
durante la trasmissione dei dati, sia nel database che nella comunicazione client-
server infatti le password vengono salvate in chiaro. Questo passaggio non è stato
corretto in quanto non necessario agli scopi della sperimentazione.
Da persona che ha appena iniziato ad approcciarsi a queste tecnologie e che ha
approfondito soltanto una minuscola parte di questo mondo, devo dire che sembra
promettere bene, dimostrato anche dal numero di servizi web che ormai utilizzano
queste tecnologie.

Sono molte le potenzialità che ho riscontrato in questi sistemi.


Node.js per esempio permette di utilizzare lo stesso linguaggio (javascript) sia nella
programmazione del server che nella creazione di script che verranno eseguiti dal
client. Grazie alla gestione asincrona delle risorse supporta un numero di utenti
contemporanei molto maggiore delle “vecchie tecnologie” con un utilizzo di risorse
molto limitato. Infine non è necessario un ulteriore software per la gestione delle
richieste, come nel caso di Apache, ma viene tutto eseguito da Node.
Mongodb è un DBMS molto efficiente che lavora in maniera perfetta con Javascript
grazie al formato Json, ma che costringe a dover cambiare la propria logica se si è
abituati a database relazionali. Un esempio di questo si può trovare nell’assenza di
join, che vanno sostituite con più query una successiva all’altra.
Altro aspetto di Mongodb è che, grazie ai replica set oppure a sistemi di journaling
in caso si abbia un solo nodo, offre affidabilità nel mantenere i dati anche in caso di
malfunzionamenti.

- 25 -
Durante la realizzazione ho dovuto affrontare alcune difficoltà soprattutto dovute al
fatto che ho dovuto imparare ad utilizzare questi sistemi che funzionano in modo
diverso da quelli che ci sono stati insegnati a scuola con PHP e SQL. Queste
difficoltà sono state amplificate anche dall’elevato numero di moduli di node.js. È
stato veramente difficile capire come andassero fatte le cose visto in quanto ogni
sito internet visitato per raccogliere informazioni usava una combinazione diversa di
questi moduli.
Alla fine sono riuscito a completare il mio lavoro mettendo insieme e
sperimentando le molte informazioni trovate.

- 26 -
- 27 -
Bibliografia e Sitografia

 Javascipt
 http://amslaurea.unibo.it/4067/1/tessarini_jennifer_tesi.pdf
 Jade
 http://jade-lang.com/
 Node.js
 http://www.hostingtalk.it/lezione-1-node-js-introduzione_-c000000ge/
 http://www.christianpalazzo.org/breve-introduzione-node-js-e-sua-
configurazione-con-apache/
 http://forum.codecall.net/topic/74237-the-nodejs-part1-the-
basic/#entry651545
 NoSQL
 http://it.wikipedia.org/wiki/NoSQL
 http://tesi.cab.unipd.it/44825/1/tesi.pdf
 http://it.wikipedia.org/wiki/Teorema_CAP
 MongoDB
 http://www.tutorialspoint.com/mongodb/index.htm
 http://it.wikipedia.org/wiki/MongoDB

- 28 -

Potrebbero piacerti anche