lunedì 3 aprile 2017

ScuolaXP 2017 - Com'è andata?


Anche quest'anno ho avuto l'onore di poter fare il docente a ScuolaXP, insieme a me ci sono stati come l'anno scorso Alberto Brandolini, Antonio Carpentieri, Andrea Francia e quest'anno si è unito a noi anche Giuseppe Carnevali.
Siamo ormai una bella squadra e ho percepito che il fatto di essere già rodati si sia visto durante la settimana.
Erano presenti 25 ragazzi, 11 professionisti e 14 studenti (record di partecipanti) tutti molto attenti e interessanti.
Abbiamo costituito 5 team eterogenei da 5 persone e poi abbiamo aperto le danze.
Un susseguirsi di nuovi problemi  e scenari sempre in cambiamento. Ad ogni giornata ho visto un progresso dei partecipanti sempre più immersi nella filosofia e nelle pratiche di eXtreme Programming.
Abbiamo messo in discussione molti concetti che ritenevano assodati e abbiamo aperto le porte per far entrare nuovi pensieri e nuovi approcci.
E' sempre bello vedere come anche i professionisti riescano a mettersi in discussione e come gli studenti siano spugne in grado di assorbire le novità con un entusiasmo e una passione notevoli.
In definitiva una grande edizione che personalmente mi ha regalato nuovo entusiasmo nel proseguire il mio lavoro quotidiano ed è stata una vera ricarica delle batterie.
Ogni persona, sia gli altri docenti che i partecipanti, ha saputo regalarmi qualcosa, uno spunto, una massima, una riflessione, una conoscenza.
ScuolaXP è anche un ottima occasione per fare network e spero di rimanere in contatto con i partecipanti anche in futuro.

Al prossimo anno!

PS: qui un link ad una sessione di domande e risposte in cui io ed Andrea ci confrontiamo sul tema "Pratiche agili: come cambia il modo di lavorare di un team"

sabato 25 marzo 2017

Workshop Sviluppo Applicazioni Web @upo 2017

In collaborazione con l'Università del Piemonte Orientale UPO (grazie alla Professor Enea Parimbelli), ho tenuto un workshop sullo sviluppo di applicazioni web.
Abbiamo visto come costruire una applicazione web in Java a partire da zero.
Dopo il setup iniziale di IntelliJ IDEA, gli studenti hanno scaricato le librerie di Jetty ed abbiamo iniziato a scrivere un main con il minimo necessario per avviare un sito.
Dopo un po' di teoria abbiamo messo in piedi l'html necessario per gestire una form per l'inserimento di indirizzi di una rubrica e per la visualizzazione della lista degli indirizzi salvati (su file, solo teoricamente abbiamo visto la persistenza su database). 
Un po' di refactoring per organizzare meglio il routing e rimuovere la duplicazione nel mostrare le viste.
Una giornata molto piacevole in cui spero di aver trasmesso, oltre a qualche conoscenza tecnica, anche un po' di entusiasmo per la professione dello sviluppatore software.
La scaletta della lezione che ho proposta è stata:

  • Web lato client
    • Il Browser
    • Html
    • Css (Bootstrap, Foundation)
    • Javascript (JQuery)
  • Protocollo HTTP
  • Web lato server
    • Application VS Web Server
  • Esercitazione
    • Java
    • Application Server Jetty
    • Database SQLite

domenica 2 ottobre 2016

Test Driven Development @unibo 2016

In collaborazione con l'Università di Bologna (grazie al Professor Paolo Ciancarini), terrò in queste due giornate un seminario, insieme a Roberto Grandi, sullo sviluppo agile e in particolare sul Test Driven Development (aka TDD).
Affronteremo prima la parte teorica dello sviluppo iterativo incrementale e del TDD e , nella seconda giornata, realizzeremo insieme agli studenti un'esercitazione pratica con un progetto reale nel quale potranno prendere confidenza con i rudimenti del TDD.
Gli obiettivi delle due giornate sono:

  • spiegare perchè vale la pena usare metodologie agili
  • contestualizzare l'uso del TDD
  • spiegare le regole del TDD
  • introdurre al concetto di refactoring
  • dare una breve infarinata di pair programming
  • far provare il ritmo del TDD attraverso la pratica
Alla fine del seminario gli studenti dovrebbero ottenere degli spunti e dei riferimenti per provare ad approfondire gli argomenti e le basi per poter applicare TDD nei loro progetti accademici.

venerdì 30 settembre 2016

PostgreSQL: come visualizzare i primi N record di ogni gruppo


Di recente mi è capitato di dover produrre un report dove si volevano, per ogni venditore inserito nei database aziendali, le prime 5 categorie merceologiche in cui vende più offerte.
Il problema di scrivere una query per selezionare i primi N elementi di un gruppo non è banale.
Semplificando al massimo il caso reale, si può vedere come se in gioco ci fosse un'unica tabella offers, dove ogni record è composto da:

  • id
  • venditore (seller)
  • categoria dell'offerta (category)
La richiesta non è facilmente esprimibile con una query ma, ho scoperto che da PostgreSQL 9.1 viene offerta una sintassi molto naif per realizzarla. 
Bisogna combinare due window function, ovvero due funzioni che permettono di fare calcoli su insiemi di righe:
  1. row_number(): fornisce il numero di riga in un certo insieme, partendo da 1
  2. select over partition: permette di selezionare qualcosa in una partizione di dati
La query che risponde all'esigenza di avere le prime 5 categorie di ogni venditore è:

select partitioned_by_seller.seller, partitioned_by_seller.category
from (
select row_number() over (partition by seller order by cnt desc) as rownumber, t.*
from (
select seller, category, count(*) as cnt
from offers
group by seller, category
) t) partitioned_by_seller
where partitioned_by_seller.rownumber <= 5
Sicuramente è un po' annidata e non di facile comprensione a una primissima lettura ma indiscutibilmente un modo molto potente per selezionare più record appartenenti a uno stesso gruppo in modo performante e compatto.

lunedì 26 settembre 2016

Guida: preparare un ambiente di sviluppo Ruby On Rails su Windows 10 tramite Docker

Viste le non poche difficoltà che ho avuto nel preparare un ambiente di sviluppo per una applicazione scritta con Ruby On Rails da una macchina Windows 10 sfruttando Docker, ho deciso di preparare questa guida sperando di far risparmiare un po' di tempo a qualche interessato ;)

L'idea è quella di sviluppare l'applicazione scrivendo il codice direttamente sul filesystem della macchina Windows 10. Volevo però avere avere l'application server in container in modo da poter sfruttare tutte le potenzialità di Ruby e sopratutto di Rails. Inoltre volevo che l'applicazione si appoggiasse su un database MySql anch'esso in un container Docker.

Come prima cosa bisogna installare Docker per Windows, il software è reperibile nel sito ufficiale di Docker, in particolare bisogna installare "Docker for Windows versione Stable".
Una volta scaricato bisognerà installarlo, al termine dell'installazione verrà proposto questo messaggio:
Hyper-V feature is not enabled.
Do you want to enable it for Docker to be able to work properly?
Your computer will restart automatically.
Note: VirtualBox will no longer work.
In poche parole per poter usare i container su Windows è necessario abilitare l'Hyper-V, questo può essere un problema se si utilizzano altri software di virtualizzazione come VirtualBox o VMware, tuttavia possiamo tranquillamente attivarlo e poi disabilitarlo quando dovremo usare uno di quei software.

Se tutto è andato a buon fine potrete vedere la versione di Docker installata, nel mio caso la 1.12.1
C:\Users\marco.fracassi>docker -v
Docker version 1.12.1, build 23cf638
Ora dobbiamo creare la cartella che ospiterà i file dell'applicazione che nel mio caso si chiamerà swrap.
Nella nuova cartella dovremo creare il file vuoto Gemfile.lock e il file Gemfile contenente il minimo indispensabile per lanciare una installazione di Rails, ovvero le seguenti righe;
source 'https://rubygems.org'
gem 'rails', '4.2.0' 
Ci serve poi il file che serve per produrre l'immagine che ospiterà l'applicazione web. Creiamo quindi il file Dockerfile_web con questo contenuto:
FROM ruby:latest
RUN apt-get update -qq && apt-get install -y build-essential nodejs
RUN mkdir /swrap
WORKDIR /swrap
ADD Gemfile /swrap/Gemfile
ADD Gemfile.lock /swrap/Gemfile.lock
RUN bundle install
ADD . /swrap
Sempre nella nuova cartella creiamo il file che serve per orchestrare i vari container coinvolti nel setup dell'ambiente di sviluppo: il file docker-compose.yml. In questo file vengono descritti i servizi, come essi devono essere fatti partire e le loro dipendenze:
version: '2'
services:
  database:
    image: mysql/mysql-server:latest
    # environment:
      #- MYSQL_ROOT_PASSWORD: p4ssw0rd    
  web:
    build:
      context: .
      dockerfile: Dockerfile_web
    command: bundle exec rails s -p 3000 -b '0.0.0.0'
    volumes:
      - .:/swrap
    ports:
      - "3000:3000"
    depends_on:
      - database
Siamo quasi pronti per avviare il container web ma prima dobbiamo attivare nella configurazione di Docker lo share del disco C per poter condividere parte del volume con i container:

Ora possiamo avviare il container web lanciando la sua bash e mappando il volume che ospiterà il codice:
docker run -it -v C:/privata/devs/swrap/:/swrap swrap_web bash
quindi si può creare l'applicazione forzandola ad usare un database MySql:
rails new . --force --database=mysql --skip-bundle 
si può quindi chiudere la bash.
Avremo dentro C:/privata/devs/swrap/ tutti i file creati. Andiamo ad editare il Gemfile scommentando la gemma therubyracer.
Infine modifichiamo la configurazione del database per usare il nostro dbms MySql, agendo nel file config\database.yml:
default: &default
  adapter: mysql2
  encoding: utf8
  pool: 5
  username: root
  password: root
  host: database
Una limitazione che non sono riuscito a superare è quella di usare l'utente root e la sua password di default root per connettere l'applicazione al database. Sembra che la versione Windows di docker-compose non si comporti bene con le variabili d'ambiente che infatti sono commentate nel docker-compose.yml che ho riportato in precedenza (sono benvenuti consigli su come superare questa limitazione).

Ebbene, è tutto pronto per avviare i container:
docker-compose up
possiamo quindi andare nel container web per creare il database, per collegarsi;
docker run -it -v C:/privata/devs/swrap/:/swrap swrap_web bash 
e una volta nella bash creiamo il database con:
rake db:create 
se dalla macchina Windows apriamo la url http://localhost:3000/  dovremmo vedere il risultato di cotanti sforzi:
Spero di essere stato utile e di non aver dimenticato qualche passaggio.
Il setup sembra ancora un po' macchinoso su Windows e le limitazioni che ho trovato rispetto ad un analogo setup sotto Linux non sono poche, spero che Docker rilasci a breve nuovi sviluppi.

sabato 4 giugno 2016

Workshop Sviluppo Applicazioni Web @unipv

In collaborazione con l'Università degli Studi di Pavia (grazie alla Professor Claudio Cusano), terrò in queste due giornate un workshop, insieme a Roberto Grandi, sullo sviluppo di applicazioni web.
Affronteremo una prima parte più teorica per vedere come una richiesta HTTP a partire da un browser arriva ad un application server e come questo seve le risorse richieste.
Nella prima giornata proveremo ad usare Java e Tomcat per scrivere e servire una Sevlet e una JSP.
Nella seconda giornata proveremo invece a vedere qualche pratica agile applicata allo sviluppo di applicazioni web.

Scarica le slide

venerdì 6 maggio 2016

Ha senso avere due test identici con dati diversi?


Al seminario sul TDD e il pair programming che ho tenuto all'Università dell'Insubria di Varese uno studente mi ha domandato:
"Ho fatto il test T1 del metodo X poi è saltato fuori che con dati di input diversi, nonostante il test fosse verde, il comportamento non era più coerente...Allora ho scritto il test T2 uguale al test T1 ma con dati diversi...Ha senso avere due test identici con dati diversi?"
Io ho provato a rispondere con un esempio banale in pseudolinguaggio:

test sum
result = sum 1, 6
assert result is 7

sum a, b
return 7

----------


test another sum
result = sum 2, 6
assert result is 8

sum a, b
return a + b

La mie domande al ragazzo sono state: "Ho fatto TDD?" e "Il secondo test è stato utile anche se uguale al primo?"... risposta "Certo!"

Bene: in una domanda tanto banale e nella mio esempio forse ancor più banale, si nascondono alcuni retroragionamenti:
- il primo test testa la somma, il secondo testa che il metodo sum sia generico
- il comportamento è (a volte) influenzato dai dati, il test mi documentano come si comporta con dati particolari (sum supporterà i numeri negativi? i numeri romani? ec...)
- bene avere i due test uguali a meno dei dati ma la duplicazione? Beh lì basta un po' di impegno e la duplicazione si toglie via che è un piacere ;)
- se non fosse stato un esempio ma fosse stata la vita reale "avrei mai scritto il primo test?".. La mia risposta è NO, quindi devo migliorare il mio TDD
Powered by Blogger.