Newsgroup: it.comp.java
Titolo: Questioni d'eleganza

Ciao,
scrivendo il codice mi vengono spesso parecchi dubbi sulla sua
eleganza e sulla relatività che può avere questa proprietà. Un esempio
può essere: come è meglio gestire le eccezioni? Direttamente nel catch
dopo il try, oppure inviandole alla classe chiamante fino al main?
Secondo voi quali possono essere i punti che riassumono il concetto di
eleganza di un codice sorgente? Infondo è poi tanto elegante
utilizzare molte interfacce e classi annidate a discapito della
leggibilità del codice?

 leggibilità del codice?
l'eleganza nel codice, a mio avviso, si identifica in questi punti:
- individuare correttamente il problema implementativo
- individuare la soluzione più semplice e immediata a quel problema
che l'utilizzo di molte interfacce e classi annidiate sia elegante non è 
scritto da nessuna parte, è elegante quando l'utilizzo di queste 
tecniche risolve in modo semplice e diretto un problema. e qui si 
risolve anche la questione della leggibilità, perchè una soluzione 
corretta il programmatore la capisce mentre quella non corretta no.


la gestione degli errori non e' tanto questione di eleganza ma di
correttezza del codice.
La regola e' piuttosto semplice : si gestiscono gli errori li dove hai
gli strumenti per correggere
l'errore o notificare chi sta usando l'applicazione del problema.
Questo poi di fatto significa che
nella maggior parte dei casi le eccezioni vengono rilanciate ai
livelli superiori.
L'eleganza del codice per quanto riguarda le eccezioni ha casomai a
che fare su QUALI eccezioni lanciare.
Cioe' l 'eleganza ha a che fare con la  struttura del codice non con
quello che fa.
Ed e' un attributo fondamentale per due motivi, uno puramente emotivo
e cioe' che e' piacevole e appagante
scrivere codice elegante, e questo aumenta la tua passione e il
piacere che provi nel tuo lavoro, e uno prettamente
pratico cioe' che noi scriviamo codice ad oggetti per un motivo molto
semplice: perche ' sia facilmente estendibile e
modificabile. Il codice elegante facilita proprio queste operazioni.
Se vuoi leggere qualcosa di autorevole in proposito:
http://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=sr_1_1?ie=UTF8&s=books&qid=1228825994&sr=1-1
http://www.amazon.com/Beautiful-Code-Leading-Programmers-Practice/dp/0596510047/ref=sr_1_1?ie=UTF8&s=books&qid=1228825881&sr=1-1
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&s=books&qid=1228825850&sr=1-1
http://www.amazon.com/Practice-Programming-Addison-Wesley-Professional-Computing/dp/020161586X/ref=sr_1_1?ie=UTF8&s=books&qid=1228825957&sr=1-1
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_2?ie=UTF8&s=books&qid=1228825850&sr=1-2
http://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Technology/dp/0201485672/ref=sr_1_1?ie=UTF8&s=books&qid=1228825869&sr=1-1

Secondo me il problema non è tanto formulato in termini di "codice
elegante" quanto di "codice leggibile".
L'eleganza è un discorso ti carattere estetico e si può discutere
all'infinito se sia più elegante scrivere
"if (condizione) comando"
oppure
"condizione ? comando : altro comando".
Quale dei due sia più facile da leggere e capire è invece ovvio.
Per quanto mi riguarda io cerco di identificare più possibile l'eleganza
del codice con la sua leggibilità. E questo per motivi prettamente pratici.
Alla fine in azienda il codice va sempre scritto pensando che
qualcun'altro lo leggerà avendo pochissimo tempo per risolvere un
qualche bug o implementare qualche nuova funzione. Non gli importerà
nulla se il codice è bello. Vorrà semplicemente capire il più
velocemente possibile come funziona e completare il suo task.
Ricordo una volta avevo visto un concorso di codice elegante, i
programmatori avevano creato programmi che facevano le cose più
disparate. Il vincitore era stato uno che aveva programmato un programma
che scriveva stringhe palindrome, e tutto il programma sorgente, era
scritto in modo che ogni riga fosse anche un palindromo. Il tutto era
stato giustificato al centro per cui il risultato era maniacalmente
elegante. Però completamente illeggibile.
Ciao,
-- 
Giulio
http://www.wikijava.org/

 leggibilità del codice?
"Eleganza" è un concetto soggettivo e poco pratico per caratterizzare il 
codice, è molto più utile parlare del codice in termini di complessità, 
riutilizzabilità, o estensibilità.
In ogni caso la tua domanda è troppo generica. La risposta può essere 
solo "Dipende".
La leggibilità del codice diminuisce con la complessità ma una certa 
complessità è comunque necessaria per garantire riutilizzabilità e 
estensibilità, ammesso che siano proprietà di interesse per la classe in 
questione.
A volte l'utilizzo delle interfaccie è richiesto per rendere il codice 
più estensibile e alle volte è utile per rendere il codice più semplice 
permettendo di disaccoppiare la classe client dall'implementazione della 
classe fornitrice.
Le inner classes aumentano la complessità del codice ma non 
dell'interfaccia, quindi finché la complessità rimane gestibile si 
possono tenere. Eventualmente si può usare il refactoring automatico 
degli IDE per trasformarle in classi normali.
-- 
Andrea Francia
http://andreafrancia.blogspot.com/2008/07/colinux-linux-dentro-windows.html