Ed ecco il link alla presentazione: Non-conventional Android programming

Se siete interessati a questo nuovo linguaggio di programmazione di cui si parla molto nell’ultimo periodo ve ne consiglio vivamente la visione

Se non sapete cosa sia Scala e volete approfondire l’argomento vi consiglio due link in italiano:

• http://scala.ugolandini.com/page0/book.html: Dove potete trovare un libro gratuito ma in corso di lavorazione scritto da Ugo Landini.
• http://roma.javaday.it/javaday2009/presentazioni/DellAversana-Scala.pdf: La presentazione tenuta la JavaDay 2009 a Roma  e quda Raffaele Dell’Aversana

Il primo problema con cui ci troviamo a combattere è far partire 2 istanze di JBoss sullo stesso computer. Per risolvere ciò è necessario creare delle copie identiche della cartella [jboss-X]/server/all e chiamarle rispettivamente node1, node2.
Queste cartelle saranno tutte identiche e rappresentaranno il “workspace” della nodo.
Per eseguire il primo nodo basta scrivere:

> sh run.sh -c node1

Dove la parola che segue “-c” indica la configurazione da utilizzare per l’avvio.
Ora il primo nodo partirà sulla porta 8080.

Se andiamo ad avviare il secondo nodo cambiando solo node1 con node2 non funzionerà perchè andrà ad occupare la stessa porta. Per evitare ciò andiamo ad aggiungere una opzione al comando che diventerà:

> sh run.sh -c node2 -Djboss.service.binding.set=ports-01 -Djboss.messaging.ServerPeerID=1

l’opzione della virtual machine jboss.service.binding.set indica che questa configurazione dovrà partire sulla porta 8180.

Ora possiamo accedere ai due nodi agli indirizzi:

http://localhost:8080
http://localhost:8180

Ma come possiamo sapere se tutto è andato a buon fine? Per fare questo ho creato 2 semplici jsp:

set.jsp:

id di sessione: <%=request.getSession().getId()%>
<br />
<%request.getSession().setAttribute("test", "test ok");%>


get.jsp:

id di sessione: <%=request.getSession().getId()%>
<br />
Parametro: <%=request.getSession().getAttribute("test").toString()%>

E nel web.xml subito dopo il tag display-name o comunque all’interno del tag web-app inseriamo:

<distributable />

Questo dirà al nostro application server che questa applicazione è distribuita.

Entrambe le pagine jsp create in precedenza stampano a video l’id della sessione.
La pagina set.jsp imposta un valore nella sessione, mentre la pagina get.jsp lo legge, quindi se accediamo agli indirizzi:

http://localhost:8080/[nome_webapp]/set.jsp

http://localhost:8180/[nome_webapp]/get.jsp

Verificheremo che l’id della sessione siano identici e che in get.jsp venga stampato il messaggio: “tutto ok!”.

Se il test è andato bene vuol dire che la sessione è stata replicata con successo.

Per il momento questo è tutto. Se avete bisogno di aiuti, chiarimenti e simili commentate pure.

Primo Talk (18:00-19:00 ca)

OBJECT ORIENTED JAVASCRIPT CON PROTOTYPE

Javascript viene sempre consiederato un linguaggio di serie B in cui
è impossibile seguire le buone regole della programmazione ad oggetti.
Ma non è così! In questa presentazione scopriremo come questo sia un
linguaggio in continua evoluzione e come sia possibile sviluppare
seguendo i paradigmi della programmazione ad oggetti. Scopriremo tool
e librerie che ci permetteranno di sviluppare creando batterie di
test, oggetti mock e inserire istruzioni di log nel nostro codice.
Durante questa presentazione illustreremo anche la libreria Prototype
che ci sarà di supporto durante gli esempi.

Secondo Talk (19:00-20:00 ca)

YAGTWO: Yet Another GWT Overview

La programmazione web sta facendo passi da gigante e oggi l’utente si
aspetta che l’esperienza di utilizzo si avvicini sempre di più a
quella a cui è abituato nei classici applicativi desktop.
Il mondo degli sviluppatori ha risposto inventanto una nuova sigla:
RIA, cioè Rich Internet Application.
Google non è stata a guardare e ha fornito la sua risposta a questa
esigenza donando alla community Google Web Toolkit.
Questo nuovo framework permette di sviluppare in Java tutta
l’interfaccia utente per poi ottenere un codice javascript che
funzionerà su qualsiasi browser web senza l’installazione di plugin
aggiuntivi.
In questa presentazione vedremo:

• perchè sviluppare applicazioni RIA
• perchè usare GWT
• come GWT utilizza AJAX per comunicare con il server
• le ottimizzazione che avremo utilizzando GWT
• come uscire dal browser con Google Gear e Mozilla Prism
• e non solo…

Alla fine della presentazione sarà disponibile anche il codice
sorgente degli esempi.

Per altre informazioni: http://www.jugevents.org/jugevents/event/15294

Enterprise Social Network

The Hitchhiker’s Guide to testable code

Se volete lasciare commenti fatelo qui.

Grazie

Ad esempio la seguente classe viola questa regola:

class WordDocument {
private String title;
…
WordDocument(HtmlDocument htmlDocument){
this.title = htmlDocument.getTitle();
}
…
}

Mentre il seguente esempio la rispetta:

class WordDocument {
private String title;
…
WordDocument(String title){
this.title = title;
}
…
}

Perchè WordDocument deve conoscere HtmlDocument? Il vantaggio potrebbe essere quello di convertire facilmente un documento Word in uno Html, ma non è questo il caso perchè l’unica informazione che realmente serve è il titolo del documento. Gli svantaggi invece sono tanti:

• posso costruire un documento Word solo a partire da un documento html, qualcuno potrebbe suggerire l’inserimento di due costruttori nella classe, ma in tal caso assegnerei una responsabilità impropria a WordDocument, una soluzione potrebbe essere l’utilizzo del pattern Factory.
• non è chiaro all’utilizzatore della mia classe di cosa veramente abbia bisogno un documento word per essere inizializzato.
• la complessità nella creazione di test unitari in isolamento aumenta perchè abbiamo a che con un altro oggetto di cui potremmo non conoscere il comportamento e per avere un test in isolamento dovremmo ricorrere a oggetti mock, ammesso che HtmlDocument sia una interfaccia.
• il livello di accoppiamento nel codice aumenta e tutti noi sappiamo che non è cosa buona: vero?

Qualcuno potrebbe obiettare che questo esempio non è attendibile perchè troppo semplice. Ad esempio per la costruzione di un WordDocument potrei avere bisogno di altre informazioni:

class WordDocument {
private String title;
private String subtitle;
private String authorName;
private String authorSurname;
private String description;
private  int pageNumber;
…
WordDocument(String title, String subtitle, String authorName, String authorSurname String description, int pageNumber){
this.title = title;
this.subtitle = subtitle;
this.authorName = authorName;
this.authorSurname = authorSurame;
this.description = description;
this.pagenumber = pagenumber;
}
…
}

E’ facile notare che il costruttore è cresciuto non poco e utilizzare una istanza di HtmlDocument avrebbe semplificato notevolmente il codice.
Una soluzione consigliata da Craig Larman nel libro “Applicare UML e pattern” è l’utilizzo delle “classi descrizione” che trai vari vantaggi hanno quello di ridurre informazioni ridondanti o ripetute, infatti il costruttore simile a quello di WordDocument potrebbe essere presente in HtmlDocument, quindi:

class DocumentInfo {
private String title;
private String subtitle;
private String authorName;
private String authorSurname;
private String description;
private  int pageNumber;
…
DocumentInfo(String title, String subtitle, String authorName, String authorSurname String description, int pageNumber){
this.title = title;
this.subtitle = subtitle;
this.authorName = authorName;
this.authorSurname = authorSurame;
this.description = description;
this.pagenumber = pagenumber;
}
…
}

e WordDocument diventa:

class WordDocument {
private DocumentInfo documentInfo;
WordDocument(DocumentInfo documentInfo){
this.documentInfo = documentInfo;
}
}

Ora sono quasi soddisfatto, ma la legge di Demetra è ancora violata dall’utilizzo di authorName e authorSurname per descrivere le informazioni relative all’autore del documento. Questo proprio non va perchè stiamo rappresentando con dei semplici attributi una classe concettuale, cioè la classe Author:

class DocumentInfo {
…
DocumentInfo(String title, String subtitle, Author author, String description, int pageNumber){
this.title = title;
this.subtitle = subtitle;
this.author = author;
this.description = description;
this.pagenumber = pagenumber;
}
…
}

In questo caso la creazione di una classe porta al rispetto della legge di Demetra perchè al documento non interessa conoscere il nome e cognome dell’autore ma l’entità autore. Questo avviene perchè se nel mondo reale non pensiamo a una determinata classe concettuale X come a un numero o a un testo, allora probabilmente X è una classe concettuale, non un attributo (sempre grazie a Larman per questa linea guida).

E se ancora non avete capito bene la legge di Demetra pensate a questo:

“Se in un negozio comprate qualcosa e dovete pagare €20. Date al commesso €20 o gli date il portafogli e gli dite di prendere €20?”

Bibliografia:

• Clean Code Talks – Dependency Injection di Misko Havery
• Applied UML and Patterns di Craig Larman
  

Il primo di questi problemi lo possiamo risolvere con Blackbird, un simpatico script js ed un css che una volta inseriti nella nostra pagina web ci daranno la possibilità di visualizzare una accativante console dove inserire i nostri messaggi di log tramite i classici metodi log.debug(…), log.warn(…), per capirci proprio come se stessimo usando il nostro amato log4j

Altro poblema molto comune è invece il debug. Qui non posso che consigliare uno dei migliori plugin per Firefox che la mente umana abbia mai partorito: Firebug.
Oltre a permettere l’inserimento di breakpoint nel codice javascript tramite questo plugin è anche possibile ispezionare visivamente il codice di una pagina html, editare in tempo reale i CSS e molte altre funzionalità utilissime nello sviluppo di applicativi web.

(p.s.: Questo sito parla per lo più di programmazione Java, ma è anche vero che spesso ci troviamo a lavorare con Javascript e quindi, ogni tanto, mi sembra anche giusto parlarne)

La partecipazione è totalmente gratuita. Il calendario sembra interessante, anche perchè oltre ad ascoltare si potrà anche mettere in pratica tramite dei laboratori.