[Tutorial Scala, Parte 1]
 

Il contenuto di questo post è rilasciato con licenza Creative Commons Attribution-Noncommercial-Share Alike 2.5

link alla licenza

Tutorial sul linguaggio di programmazione scala. Pratico nel senso che l'eccitazione per il calcolo del numero di fibonacci la lasciamo agli intenditori. Forse praticon-ico, nella bassezza dei suoi argomenti. Ma almeno si vede qualcosa.

scala tutorial 001 (pdf) (generale)
scala tutorial 002 (pdf) (generale)
scala tutorial 003 (pdf) (funzioni parzialmente applicate e metodi)
scala tutorial 004 (pdf) (campi pubblici e metodi di accesso)
scala tutorial 005 (pdf) (composizione di trait, concatenazione di invocazioni, un pelino di pattern matching)
scala tutorial 006 (pdf) (...un po' di roba già detta e ridetta...)

L'introduzione è mitica! Grazie PGI!

PGI, nel mio caso la pubblicazione di questo tutorial è dotata di un tempismo stupefacente: i primi del mese prossimo vado a un piccolo talk su Scala tenuto nella mia città organizzato in seno a un gruppo di recentissima formazione di giovani appassionati di programmazione.

Grazie, al solito :)

P.S.: non era meglio aprire il thread nella sottosezione "Corsi, tutorials e faq"?

Ho aggiunto la seconda parte

scala tutorial 002 (pdf)

Forse nel titolo sarebbe meglio dire "in parti" più che "parte 1", altrimenti devo aprire un milione di thread quando l'argomento è uno solo.

Circa la posizione, a mia memoria i tutorial si aprivano nella sezione generale per motivi di visibilità, per poi essere spostati nella sezione tutorial. Ma è sempre possibile che la prassi sia cambiata (o che mi sia venuta una botta d'alzheimer).

Ho letto anche la seconda parte. La prima parte mi aveva lasciato un po' perplesso, nel senso che avevo la sensazione che mi rimanessero troppi dubbi, invece poi, leggendo anche la seconda, ho visto che spesso torni anche su costrutti già visti per spiegarli più nel dettaglio e nel complesso ho trovato la lettura molto scorrevole e piacevole. Spero che scriverai ancora perché ci sono ancora molte cose rimaste un po' in sospeso.

Ah, e un'altra cosa: nella seconda parte, correggimi se sbaglio, alla fine i trait Stock, Scarico, Carico e le corrispondenti classi *Base non le hai usate vero?

M'hai fatto venire il dubbio che, in una botta di demenza senile, avessi messo delle classi aliene.

Terminale usa StockBase, CaricoBase e ScaricoBase che, a loro volta, usano rispettivamente Stock, Carico e Scarico.

val quantità = magazzino.esegui(new StockBase(prodotto))
...
magazzino.esegui(new CaricoBase(prodotto, BigDecimal(quantità)))
...
magazzino.esegui(new ScaricoBase(prodotto, BigDecimal(quantità)))

Mi fa piacere che si lasci leggere. Per gli argomenti, è del tutto casuale, nel senso che sono le caratteristiche dei programmi a determinare gli argomenti del tutorial. E' una sorta di tutorial inverso. Appena mi salta in mente un terzo programma papabile proseguo.

Hai ragione, non me ne ero accorto, non ho letto bene il codice del terminale perché immaginavo che lo avresti implementato in modo diverso (usando direttamente magazzino.quantita(...), magazzino.aggiungi(...) e magazzino.rimuovi(...)). Ora però mi viene una curiosità: hai utilizzato questo metodo contorto per motivi diversi dal far vedere qualcosa di più del linguaggio? Mi sfugge il motivo di questa scelta altrimenti...

Comunque grazie per tutti i tutorial che scrivi perché sono tutti molto utili e interessanti.

Concretamente l'approccio ha il solo scopo di mostrare trait, classi e interazioni tra queste due.

La forma usata ha tuttavia un suo senso.

Come hai notato, il fatto di avere il magazzino che esegue delle operazioni porta a includere nel magazzino i metodi che poi usano le operazioni. Che senso ha? Nessuno, a meno che le operazioni non inizino a diventare un po' più numerose e sostanziose. A quel punto entra in gioco la composizione nel senso che capita che quelle tante e grosse operazioni non siano altro che la combinazione di operazioni più piccole. Le operazioni più piccole sono definite come metodi dell'operando Magazzino, le combinazioni sono contenute negli operatori-funzione. Così ti ritrovi ad avere un magazzino con un contratto relativamente costante a fronte di un numero variabile di possibili interazioni (il principio open-closed).

Ad esempio, supponiamo di avere uno scarico ammissibile solo se lo stock non vada in negativo. Non è necessario cambiare la definizione di magazzino per ottenerlo, basta combinare i suoi metodi quantità e rimuovi:

Geniale, in pratica aumenta la modularità. Quando voglio aggiungere un'operazione posso scrivere una nuova classe invece di aggiungere codice a Magazzino. La stessa soluzione in Java non sarebbe così elegante.

In java è pressochè identico.

Il "vantaggio" è nei vari addolcimenti della sintassi, nell'esistenza di alcuni tipi predefiniti, come Function1, che evitano qualche interfaccia eccetera.

Insomma, confesso che la parte di Scala che a me piace è il fatto che sia un riassunto di Java con un paccone di nuove librerie. Altri probabilmente saranno più affascinati dai suoi aspetti funzionali.

mi iscrivo :sisi:

Hai ragione, anche se mi sembra che come esempio si adatti meglio a Scala. Ha un nome questo pattern?
Cosa intendi per "riassunto di Java"? Il poter fare le stesse cose con meno codice? Però ho trovato l'impatto iniziale un po' traumatico come leggibilità, anche se adesso un po' ci sto facendo l'occhio... Comunque effettivamente ciò che mi sta piacendo al momento è l'aspetto funzionale, ma anche l'eredità multipla di cui ho spesso sentito la mancanza in Java.

Il trauma in lettura l'ho avuto anche io, ce l'ho tuttora e credo che l'avrò anche in futuro perchè non riuscirò mai ad abituarmi all'idea che:

list:::list

o

x<:<y

abbia un senso.

Per riassunto di java intendo sì, il fatto di poter scrivere le stesse cose con meno codice nel senso di evitare quelle ripetizioni che in Java sono evidenti. Ad esempio la necessità di ripetere il nome dei tipi nell'inizializzazione delle variabili:

String x = new String()
var x = new String()

Il fatto che le dichiarazioni di campi siano sempre trasformate in una coppia accessore/mutatore:

var x: Int = 10

Sembra un campo ma non lo è: sono due metodi, un setter e un getter.

E stesse cose nel senso che è una lingua staticamente tipata che gira sulla piattaforma java, con le librerie di java.

Oggi il forum è più lento del solito.

Ho aggiunto la terza parte

scala tutorial parte 3 (pdf)

Esaurite le idee riguardo ai piccoli programmi e non volendo ammorbarvi con un grosso programma, ripiego biecamente sulle singole funzionalità. Nel caso in questione si parla delle mitiche "funzioni parzialmente applicate", che è il classico argomento da fluidodinamica finchè non gli si calano le braghe.

Grazie anche per la terza parte, l'ho letta ieri e l'ho trovata molto interessante.
Potresti spiegare come vanno visti questi due metodi? Nel senso che all'atto pratico non si accede alla variabile come un normale campo di Java? E come si aggiungono restrizioni al metodo set?

Poi avrei anche altre domande su cose che non mi sono chiare o non ho proprio capito ma non vorrei prenderti troppo tempo... Stavo pensando di prendere un libro di quelli consigliati sul sito di Scala, tu hai studiato su uno di quelli?

@wingman ed eventuali interessanti:
domani sera, alle 18:30 e sabato mattina, alle 9:30 a Padova ci sarà un talk su Scala tenuto da Mario Fusco (l'autore della libreria lambdaj), e coprirà principalmente gli aspetti legati al paradigma funzionale mettendolo a confronto con quello orientato agli oggetti (speriamo bene). Verra visto anche il supporto che Scala offre alla programmazione concorrente.
Per maggiori dettagli cercate il sito del gruppo "Programmers in padua" (gruppo di appassionati di recente formazione).

Io hoi deciso di affrontare prima il talk, a "mente scarica", visto che per me sarà duro l'impatto con la prospettiva funzionale; invece mi tengo i tutorial di PGI per dopo, come consolante antidolorofico :D

@EDIT:
PGI mi perdonerà se abuso del thread andando OT, però volevo segnalare a tutti questo tool: Kojo che può essere utile anche ai programmatori che approcciano Scala perchè fornisce un ambiebte REPL per questo linguaggio, dotato di syntax highlighting, code completition e rafinatezze vaie.

La questione getter/setter si è dimostrata abbastanza "lunga" da offrire l'opportunità per una quarta parte, aggiunta al primo post.

Grazie per le informazioni, purtroppo io non riuscirò a esserci causa impegni.
Kojo sembra molto carino, lo proverò sicuramente uno di questi giorni.
Grazie mille!

Sì, era già previsto ;)
Ora lo sposto.

Aggiunta la quinta parte.

scala tutorial 005 (pdf)

Ho avuto qualche problema nel trovare un programmino che avesse un senso, così ho iniziato un programmone, modulare, così da poter aggiungere pezzi.