Newsgroup: it.lavoro.informatica
Titolo: Per chi non è ancora passato a java...

...una ragione in più per farlo:
http://www.youtube.com/watch?v=Mt7zsortIXs&feature=player_embedded#
!
:-D


Per NON farlo, vorrai dire XD
-- 
Traveller, not tourist!
www.inter-rail.it

 
http://www.youtube.com/watch?v=Mt7zsortIXs&feature=player_embedded#
!
Sospendo il giudizio estetico sul video in sé.
Tuttavia mi chiedo: chi è che lo ha prodotto?
Ho letto che fa capo a JavaZone ma... possibile che questi investano 
così tanto per un video del genere?
Ciao,
Giulio
-- 

 Giulio
Come vedi, investono...

 Per NON farlo, vorrai dire XD
Perché? Tu non "passeresti" a quela lě? ;-)

 Perché? Tu non "passeresti" a quela lě? ;-)
-----------------------------------+l

 -----------------------------------+l
frase malposta, è 
tu non "passeresti" SU quella li? (senza accento) ;-)

 tu non "passeresti" SU quella li? (senza accento) ;-)
Vabbe' quando scrivo in fretta succede anche di peggio..:-P

 ma la tipa non è male. :-)
eh con gli italioti quello funziona sempre alla grande...e guai se non
si finisce a parlare di figa.. :)

 :-D
Bello ! E' fatto veramente bene. E anche i commenti non sono male :))


per parafrasare un famoso ragioniere
secondo me questo video è una cagata pazzesca.

 musica non è il mio genere), ma la tipa non è male. :-)
La tipa non è male, vero.
Anche la voce è decisamente buona.
Ma gli autori del brano hanno fatto un bellissimo lavoro: ben 
scimmiottato "Poker Face" di Lady Gaga, con l'idea di prendere una 
frazione di un tema e modificarlo "a run-time" :-). Bell'arrangiamento, 
bei suoni e buon video. Ribadisco: sarei curioso di sapere chi siano gli 
autori e quanto sia costato 'sto scherzetto...
...ah, dimenticavo: ovviamente da domani riprenderò a programmare in 
Java! :-)
Ciao,
Giulio
-- 

 :-D
si ma java e' lento e per scrivere hello world devi essere una specie
di marziano.
c# e' meglio.

 c# e' meglio.
IMHO C# è *uguale*.
Solo che ha
- un migliore sistema di gestione degli eventi
- un supporto più "avanzato" per certe cosette interessanti tipo le 
lambda expression
- i tipi dinamici
- LINQ
Per il resto mi pare che l'approccio sia simile.
Tutto rigorosamente IMVHO.
Ciao,
Giulio
-- 

 Tutto rigorosamente IMVHO.
Anche nel mio caso IMVHO, continuo a prediligere Python a entrambi.
Ah, Java e' (teoricamente) multipiattaforma, Python e' (realmente)
multipiattaforma, C# e' (realmente) monopiattaforma.
Greetings
JOKER Ltd.

 multipiattaforma, C# e' (realmente) monopiattaforma.
Usando Mono, no (ho fatto due stupidaggini sotto Ubuntu...)
-- 
Ciao!
Luca

 Anche nel mio caso IMVHO, continuo a prediligere Python a entrambi.
Quoto. :-)
Ciao,
Giulio
-- 

 Usando Mono, no (ho fatto due stupidaggini sotto Ubuntu...)
Be'... con Mono - progetto comunque a me molto caro - manca WPF (giusto 
per fare un esempio) che è veramente una potenza.
Ciao,
Giulio
-- 

 per fare un esempio) che è veramente una potenza.
Come ha detto 2 stupidaggini. Fare una applicazione complessa diventa
dura. E comunque Mono non so se vada su MacOsX ad esempio.
Java si, Python pure.
La differenza vera e' che C# lo metacompili come gli altri due ma
vuole le librerie di runtime (licenza poetica) annegate nel SO. Non
sono certo che si possa installare in una cartella .NET senza
interagire con il SO stesso (infatti ad esempio .NET 3.5 mi pare non
possa andare ad esempio su NT o Win2000. Ripeto mi sembra, non ho esp
in merito avendo abbandonato il mondo microsoft, spero per sempre, e
quindi la mia esperienza in .NET e' ferma al 2.0 e un progettino in
3.5). La VM Java o l'interprete Python ancora di piu' li metti dove
vuoi e basta che setti una variabile di ambiente (PYTHONPATH) per fare
piu' o meno tutto. Puoi anche avere senza rischi di librerie
concorrejnti piu' versioni contemporanee.
Con .NET so che si fa, ma come per mettere piu' versioni di IE, si
deve un (bel) po' smanettarci sopra.
Greetings
JOKER Ltd.

 concorrejnti piu' versioni contemporanee.
???? .net è un framework non è un linguaggio pyton è un
linguaggio, .net sfrutta un'infinità di servizi di SO che python o
Java non usano/non hanno. Sono cose molto molto diverse, se devi
sviluppare solo per windows è vantaggioso .net se no è escluso a
priori, non vedo l'utilità o meno dell'installazione su una directory
se non la comodità ma .net lo installa il SO da windows update e tutte
le versioni sono compatibili con le altre.

 le versioni sono compatibili con le altre.
Non sono certo che sia cosi' semplice come la descrivi. Dubito che su
SO un po' datati girino tutte le versioni
Greetings
JOKER Ltd.

 SO un po' datati girino tutte le versioni
Da XP in puoi installare tutto quel che vuoi, anzi solitamente è già
installato, fa parte del SO, o puoi dire all'installazione di
installare automaticamente quel che manca. Il problema setup è
completamente superato in windows da qualche anno, ci mancherebbe.

 SO un po' datati girino tutte le versioni
No, lui dice: sullo stesso SO puoi far girare piu' versioni del
framework. A parte il fatto che, fino al 3.5, conveniva avere 2 e, al
limite, 1.1, che il 3.5 e' un superset di 2, francamente mi interessa
poco avere una roba che gira sotto Windows98 (e, ahime', sotto Windows
2000), dato che a 'sto punto XP data 2003...
-- 
Ciao!
Luca

 destinazione, piu' tutte le librerie che ti servono, no?
non penso, nonostante sia fuori da python da quei due milioni di anni. 
Penso ti basti py.exe e robe cosě, che ti pacchettizano in un exe / app 
il tutto.
  ngw
-- 
Nicholas Wieland (ngw)
Zooppa CTO
911 Western Avenue, Suite 420
Seattle, WA  98104  US

  ngw
-- 
Ciao!
Luca

 completamente superato in windows da qualche anno, ci mancherebbe.
Si? L'ultima volta che ho priovato qualche mnese fa mi ha inizato a
dire:
"Maaaaaaaa la versione di .NET e' vecchia"
Ok cerca, scarica, installa
"Maaaaaaaa il programmillo per installare (non mi ritorna in mente il
nome, si chiama rimozione in psicanalisi) e' vecchio devi installare
il nuovo"
Ok cerca, scarica, installa
"Maaaaaaaa il programma e' zippato in formato $%@# e ti serve
l'applicativo apposta"
Un pio colpo di Python alla nuca ha posto fine a tutte le sue
sofferenze :)
Greetings
JOKER Ltd.

 2000), dato che a 'sto punto XP data 2003...
98 non lo considero,ma ci sono fior di aziende con server fermi a NT 4
e Win2k.
Greetings
JOKER Ltd.

 il tutto.
py2exe (non py.exe) serve a compilare in un eseguibile WINDOWS ONLY il
codice. Ma con un semplice interprete python (che si trova
probabilmente persino per il tostapane) fai irare quel che vuoi. Uico
limite: se usi una libreria grafica alternativa (all'orribile TkInter)
come PyGtk o PyQT devi avere GTK o QT installati oppure installarli.
Con WxPython ti porti dietro il tutto e lo installi al deploy
dell'applicazione.
Non dimentichiamoci che la setssa roba che scrivi in 30 files da 3000
linee in C# le fai con 5 files da 300 righe di Python.
"Python is a programming language battery included."
Greetings
JOKER Ltd.

 linee in C# le fai con 5 files da 300 righe di Python.
E non dimentichiamoci neanche che sarebbe sempre meglio metterci un
"Secondo Me" avanti a sparate simili.

 linee in C# le fai con 5 files da 300 righe di Python.
Pur apprezzando io Python (e non poco) so anche che questo non e'
assolutamente vero (lavoro anche in C#).
-- 
Ciao!
Luca

 e Win2k.
Dunque dunque: Win2K smazza il 2.0 di sicuro (forse anche il 3.5, ma
non sono sicuro). Detto questo, io oggi avrei MOLTA paura a mettere le
mani su un server NT4...
-- 
Ciao!
Luca

 leone sia il 
VB.NET
.
Immagino nella RI o comunque nella tua area geografica di riferimento
dipenda da tante cose, ma a livello mondiale la parte del leone la fa
certamente c#.
Un po di fatti:
- 
http://blogs.oreilly.com/cgi-bin/mt/mt-search.cgi?IncludeBlogs=57&search=%22State+of+the+Computer+Book+Market%22
(grafico più recente sui linguaggi: 
http://radar.oreilly.com/languages.png
)
- Google trends: 
http://www.google.com/trends?q=C%23,VB.NET
- Google trends ristretto alla RI:
http://www.google.com/trends?q=C%23%2CVB.NET&ctab=0&geo=it&date=all&sort=0
- SO tag sono 10 a 1 per c#: 
http://stackoverflow.com/tags
Per non parlare di mercato del lavoro, sia nel RU che in Turchia che
in India c# è molto ma molto più richiesto di VB.Net (tra 1 e 2 ordini
di grandezza).
--
ale
http://ale.riolo.co.uk

 "Secondo Me" avanti a sparate simili.
Ok diciamo che ho esagerato un pelino, ma davevro poco.
Di recente ho dovuto fare un lavoro con Python, un client clone di
Skype con altre features. Mi sono occupato solo di frontend, il
backend era twisted. Alla fine della fiera, avendo dovuto (per
imbecillita' di committente e di cliente finale) riscriverci a manina
i widgets (in pratica su macchine XP/SEVEN volevanola "grafica" Mac,ma
questo lo abbiamo saputo solo a lavoro iniziato), eppure il prodotto
finito (ho i sorgenti ancora, li tengo come un caro ricordo
dell'imbecillita' umana, prima di sentire flames, il cliente lo sa e
non ha problemi che li tenga per rimirarli in segreto,  purche' non li
diffonda :P ) non supera i 20 files da mediamente 300/350 righe
ciascuno. Solo il codice che avrebbe creato VS di suo per le semplici
maschere sarebbe stato il quadruplo.
Greetings
JOKER Ltd.

 mani su un server NT4...
Io pure ma per altri motivi ( a parte la mi aallergia al mondo ms, di
certo sarebbe vetusto quindi piendo di polvere, germi, scarafaggi) :)
Scherzi a parte, quelli sono oggetti che DEVONO restare come sono
finoo alla morte. Cambiare un virgola significa scatenare su di se
maledizioni che al confronto Tutankamon e' un corentto portafortuna.
Greetings
JOKER Ltd.

 di grandezza).
Stavolta sono d'accordissimo con Ale. E anche qui in italia ormai di
annunci per 
VB.NET
 (pronunciato sermbra uno con la evve moscia che
dica rubinetto) se ne vedono pochi.
Greetings
JOKER Ltd.

 maschere sarebbe stato il quadruplo.
Io invece recentemente ho scritto un painter di workflow, niente di
eccezionale s'intende, ma drag and drop dei blocchetti, editazione
testi e le linee e collegamenti disegnate al volo in modo coerente.
L'ho disegnato in XAML graficamente e quante ? Forse 200 righe di
codice ?
Poi ho visto il codice di Cassini, per chi non lo sapesse Cassini è il
piccolo web server che si porta dietro visual studio per il test e
debug in locale, se non ricordo male da un Italiano. E' un server
completo, in grado di far girare tutte le applicazioni .net comprese
di componenti lato server, connessioni al DB, la sicurezza.. tutto. Il
codice sono appena 9 file, il più grosso è 1.000 righe :
http://blogs.msdn.com/cfs-file.ashx/__key/CommunityServer-Components-PostAttachments/00-00-54-81-31/cassiniv2_2D00_1.zip
E allora ? Tutto questo non prova ne' significa niente. Ne vuol dire
niente che i file che fa visual studio graficamente sono grossi : non
essendo editati a mano si saranno presi tutto lo spazio necessario,
chi se ne frega non ce lo mettiamo ?
Ma c'è di più : usando le lambda expression si accorcia notevolmente
il codice, ma è un vantaggio ? E' qualcosa di positivo ? Potremmo
sempre tornare al Clipper dove potevi abbreviare ogni comando, quello
si che era forte, si, come l'aceto.



beh io sempre mi sorprendo quando vedo implementazioni come questa:
http://pypi.python.org/pypi/flickrapi
non è niente di che, semplicmente una implementazione del client dei
servizi rest di flickr. tutta l'implementazione è un unico file di
meno di 900 righe, commenti e licenza compresi. siccome di
implementezioni ce n'è per tutti i programmatori, ti sfido a trovarne
una che non abbia un rapporto paragonabile a quello.
per quanto si stenti a crederlo con un linguaggio dinamico si può
arrivare a livelli di ermeticità codice di quei livelli. e si sa, il
codice non scritto è l'unico certamente esente da bug.

 codice non scritto è l'unico certamente esente da bug.
Imho la brevità non è un valore, anzi spesso è contro producente. La
chiarezza, la semplicità, la modularità ed il controllo intrinseco
degli errori lo sono per me.
PS: una volta programmavo in lisp. Con relativamente poche righe e
tante parentesi ci facevi moltissimo, sembrava quasi magico. Adesso
consiglio di usare tante "if" al posto del "case" in qualunque
linguaggio.

 L'ho disegnato in XAML graficamente e quante ?
[cut]
Ma lo sai mi farebbe davvero comodo poter avere un progetto del genere a 
cui fare riferimento? E' open-source?
Ciao e grazie,
Giulio
-- 

 quante API di flickr copre l'hai viso ??
facciamo tutte, comprese quelle future...? :P
forse sei tu che non ha visto bene cosa fa quel codice. se cerchi le
definizioni dei metodi e degli oggetti ovviamente non li trovi perché
da buon linguaggio dinamico può permettersi di definire tutto a
runtime.

 cui fare riferimento? E' open-source?
Sorry, è affogato in uno più grande e per il momento chiusissimo.

 runtime.
Ho capito ma quel codice è soltanto una "traduzione" che impacchetta
le chimate verso flickr, tu gli dici il metodo ed i parametri e lui li
passa a flickr, a parte dare un po' di supporto per l'upload
sostanzialmente non fa niente. E fatto così sarebbero poche righe
anche in c#, non controlla l'errore, non parsa i dati di ritorno non
contiene la definizione delle classi e dei metodi, non fa niente. Non
è un'implementazione del client è un adapter che si occupa del
collegamento ed autenticazione è un tubo con una mano di vernice.

 Sorry, è affogato in uno più grande e per il momento chiusissimo.
No problema.
Giusto una curiosità: l'hai implementato seguendo "strettamente" MVVM?


> Giusto una curiosità: l'hai implementato seguendo "strettamente" MVVM?
MVVM chiiii??? Guarda, mi chiamano Equi-Nozio non a caso :-)  Sul
serio, mi occupo di progetti troppo piccoli per avventurarmi
nell'utilizzo di pattern con il ben che minimo overhead, anche a costo
di sacrificare la fantastica testabilita dell'MVC.
E premesso che io l'ho fatto in silverlight, ti dico come ho fatto che
facciamo prima :
Ho disegnato l'interfaccia in XAML prima in Expression che si fa
presto e poi l'ho rifinito a mano perchè il codice che genera mi fa un
po' schifo.
C'ho attaccato sotto il codice in c#, istanziazione, zoom, drag
dell'oggetto ecc.. Poi il difficile è stato scrivere la stramaledetta
routine che decide dove fa passare le linee di collegamento tra i
rombi e i rettangoli ad esempio, ho cercato ovunque ma alla fine mi
sono scritto una sequela di "if" per decidere dove spezzare la riga se
l'oggetto è sopra, se è sotto, se però passa un piccione e piove
ecc... Il tutto gestito direttamente nel codice dell'oggetto ad
eventi.
Poi ho definito delle classi che ricalcano il grafo del Workflow e che
mi serviranno poi anche per "eseguirlo" in un secondo tempo. Fatto
questo ho scritto una routine che scorre il grafo a video ne crea una
sua rappresentazione ad oggetti. O serializzato il tutto ed ho
ottenuto un xml che passo allegramente avanti ed indietro alla pagina
sul salva o sul leggi. Lato server reinstanzio il grafo di oggetti e
lo salvo sul DB sia in forma xml che in forma "padre figlio".



Anche perchè la conta delle righe non mi sembra una grande pratica. A 
me personalmente interessa molto di più l'espressività del linguaggio, 
per dire.


 contiene la definizione delle classi e dei metodi, non fa niente.
guarda il fatto che tu non li veda nel sorgente non vuol dire che a
runtime non esistano :-)

 facciamo prima :
[cut]
Capito.
Comunque, se avessi un moto di filantropia, ti dico fin da ora che a me 
farebbe parecchio comodo vedere come hai implementato il layer più alto 
(in particolare lo XAML). ;-)


 si che era forte, si, come l'aceto.
Le Lambda sono presenti in ogni linguaggio (Python incluso e da
parecchi anni). Abbreviare un comando e' diverso da fare le cose con
poche righe, avere dizionari liste e tuple con cui puoi lavorare in
amniaera naturale e sopratutto, parole di Bruce Ecktel che
sottoscrivo: " Con Python non penso a come scrivere il codice per fare
qualcosa ma a cosa deve fare ilprogramma e il codice viene da se".
Ecco di cosa parlo. Solo per chiarire, che mi sembra stia nascendo un
equivoco di base.
C# e' quello che Java non e' mai stato capace di essere. Diciam Java
WannaBe C# (senza riuscirci). Cio' non toglie che preferisco 1000
volet la semplicita' di Python, il fatto che sia portabile (la
situazione solo client Win sta cambiando, lentamente a sta cambiando,
quindi dire tanto dovra' girare sempre e solo sotto windows, non e'
piu' un paradiga valido), la concisione (un'applicativo scritto da un
mo amico in python. Doveva calcolare la disposizione ottimizzata di
carico di un transpallet. Ovvero su uno stesso transpallet devono
caricare merce per piu aziende  distinte, che deve esere quindi
raggruppata in maniera che tutta la merce di una azienda sia
raggruppata in uno stesso punto e per di piu' che il pallet sia
stipato al massimo della capienza, sai puo' voler dire usare un camion
in meno. Orbene, gli algoritmi di calcolo sono noti si tratta di circa
70 funzioni piu' o meno di una riga ciascuna. Quindi ogni funzione (o
metodo) due righe (def funzione:  e la riga di calcolo). Totale circa
140 righe. Pe metterci la visualizzazione in pianta, in porospettiva e
in prospettiva esplosa e' arrivato a scriverne in tutto (incluse le
140 di cui sopra) 230 scarse).
Greetings
JOKER Ltd.

 linguaggio.
Strano, la stessa cosa che ha pensato bene di fare Guido Van Rossum
per Python. E mi sa pure da parecchio.
La leggibilita' di Python e' proverbiale. Certo se VUOI programmare
male ci riesci, ma ti ci devi impegnare.
E' un linguaggio quasi discorsivo. Anche se non lo conosci leggi un
listato e capisci cosa fa.
Greetings
JOKER Ltd.

 qualcosa ma a cosa deve fare ilprogramma e il codice viene da se".
Straquoto!
Ciao,
Giulio
-- 

 listato e capisci cosa fa.
Asp. a me python piace come sintassi, contesto che il listato sia
sighificativamente più corto a partità di funzioni. Cioè :  se è più
corto è perchè o certe cose non le fai o perchè scrivi del codice
"molto" dinamico e "molto" compatto.
Poi c'è il discorso che imho non è adatto ne a gestire la complessità
ne a mantenere la disciplina necessaria in uno sviluppo professionale,
ma queste sono mie opinioni.

questo non è necessario? :-)
Ma non è necessario neppure in c# ! Cioè, io posso fare una classe che
fa esattamente quello che fa quell'interfaccia, solo che invece di
avere un oggetto di ritorno avrò una collection, ma non cambia niente,
solo la sintassi.
Il fatto che tu possa scrivere  data =
flickr.photos_getInfo(photo_id='1234'), senza aver definito il metodo
photos_getInfo è equivalente alla sintassi : data =
self.__flickr_call(method='flickr.photos.getInfo',    photo_id='123',
format='rest')  dove il metodo viene chiamato come stringa che puoi
benissimo scrivere anche in c#.
Nessuno ti dice che devi dichiararli i metodi e gli oggetti, anzi
quelle 900 righe di codice è più o meno quello che avrei scritto io
in .net per farmi un'interfaccia, non avendo tempo non avrei mai
dichiarato tutti gli oggetti ed i metodi, ma il risultato è quel che
è  : un troiao. (sempre secondo Equinozio che non è il masismo esperto
di python)

 benissimo scrivere anche in c#.
scusa, ma a te pare davvero che siano equivalenti?

 scusa, ma a te pare davvero che siano equivalenti?
Si. Il dinamismo o meno di un linguaggio è solo sintassi (notare che i
due metodi li ho presi dal tuo codice), è più elegante ma è solo un
formalismo. Tanto è vero che in c# è scrito ironPython, linguaggio
Pyton che genera codice .net e per definizione lo stesso codice lo
puoi scrivere anche in c# o perfino in 
vb.net
. Oh, non c'è niente di
nuovo sotto il sole, Python è solo un linguaggio non un paradigma.
Poi in Python puoi benissimo scrivere una interfaccia verso flicrk
equivalente a quella c#, con metodi e classi definite, ed il risultato
sono meno errori imho e maggiore qualità, l'intellisense ed il
controllo.

 In che senso?
CCon l'IDE di VS non vedi il codice con cui si disegnano i widget. E
senza IDE non riesci manco a modificarlo.
Greetings
JOEKR Ltd.

> formalismo. Tanto è vero che in c# è scrito ironPython,
No esiste IronPython implementazione della sintassi Python per .NET.
Non genera codice python e quindi non e' portabile. IMHO un oggetto
inutile.; Se volgio programmare in Python uso Python. Se DEVO lavorare
in .NET uso C# che e' la scelta migliore in assoluto per
quell'ambiente.
Greetings
JOKER Ltd.

 ma queste sono mie opinioni.
Personali, rispettabili, e IMHO errate.
Permette di mantenere il codice pulito, leggibile, auto documentato.
Tant'e' che professionalmente e' usatissimo, soratutto in Google,
Yahoo, Canonical etc. E non e' che stiamo parlando di aziendine da 3
persone.
Greetings
JOKER Ltd.

 per dire.
In poche righe tanta chiarezza. Posto due cazzate:
Versione C# del metodo Fibonacci:
static int Fibonacci (int x)
{
   Console.WriteLine ("x = {0}", x);
   if (x <= 1)
   {
      return 1;
   }
   return Fibonacci (x-1) + Fibonacci (x-2);
}
static void Main( )
{
   Console.WriteLine ("Fibonacci no. = {0}", Fibonacci (5));
   Console.ReadKey();
}
Ora quella Python:
def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)
Quale e' piu' Leggibile/Mantenibile/Espressiva?
Pregherei di essere obbiettivi e non di parte. Chiaro che a chi lavora
solo in C# la prima e' piu' all'occhio, guardatele pero' astraendo le
conoscenze, come un neofita che si approccia senza conoscere nessuno
dei due linguaggi.
Greetings
JOKER Ltd.

 in .NET uso C# che e' la scelta migliore in assoluto per quell'ambiente.
Lo pensavo anche io, ma dal 2010 hanno incluso la possibilità di
eseguire codice Python chiamato da dentro c# o 
vb.net
, questo permette
di scrivere una appplicazione 
vb.net
 che permette di essere
"scriptabile" in python, un po' come excel è "scriptabile" in
vbscript, e la cosa è per me molto interessante.

 senza IDE non riesci manco a modificarlo.
A parte che puoi vederlo e modificarlo, è solo complesso ma non
impossibile, con XAML le cose sono completamente cambiate.

 persone.
Si infatti, poi si scende sui gusti personali. Anche se ci tengo a
sottolineare che per progetti piccoli o script anche secondo me è un
linguaggio veloce ed efficente, ma che diventa ingestibile quando i
progetti diventano complessi. Fatte le debite proporzioni è un po'
come vbscritp, che è ottimo per fare script e macro ma che diventa
difficile da gestie quando a scrivere il codice sono molte persone che
non sanno "tutto" e il loro livello di preparazione non è medio-alto.
Ovvio che se il progetto lo spezzi usando altre tecniche, ad esempio
se organizzi tutto a servizi rest o webervice, interfacce stupide e
logica nel DB, python va benissimo.
Nell'esempio portato da rootkit poi è palese che se uso
l'implementazione c# non ho qusi bisogno di altra documentazione e
posso usare tutti i servizi flick senza generare errori, anche se sono
una monkey alle prime armi, invece se uso l'implementazione python ho
bisogno di studiare e testare ogni singolo servizio.

 solo in C# la prima e' piu' all'occhio, guardatele pero' astraendo le
Obbiettivamente il codice in  c# fa molto di più ! Dove sono le print
in python  e dov'è la chiamata della funzione  ?
Eccola in c#
static int Fibonacci (int x)
{
   if (x <= 1)
   {
      return 1;
   }
   return Fibonacci (x-1) + Fibonacci (x-2);
}
sarà brutta per le graffe, neanche a me piacciono, allora eccola in
vb.net
 :
Function Fibonacci (ByVal n as integer )
  if  n < 2 Then
      Return n
  Else
      Return Fibonacci (n - 1) + Fibonacci (n - 2)
  End if
End Function
ed in Python:
def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)
a me sembrano praticamente  uguali tranne le graffe che però è solo
questione di gusti.

 questione di gusti.
premesso che non conosco python, quoto tutto solo per chiedere se sono 
solo io che vedo un errore nella prima ed una ottimizzazione possibile 
nella terza? non sono scritte tutte allo stesso modo...
S., curioso

 formalismo.
questa stride. e mica poco.

 impossibile, con XAML le cose sono completamente cambiate.
Cio' che dici e' vero, ma... Posso essere sincero?
A me XAML non piace manco un po'....
-- 
Ciao!
Luca

 }
Permetti se la compatto un po'?
static int Fibonacci (int x)
{
   Console.WriteLine ("x = {0}", x);
   return (x <= 1) ? 1 : Fibonacci (x-1) + Fibonacci (x-2);
}
Detto questo, sono comunaue abbastanza equivalenti. Anche perche', se
non leggo male, nella versione Python ti sei dimenticato di scrivere il
valore a console.
Comunque, volendo essere pignoli e scassapalle fino in fondo, una delle
regole d'oro della vecchia programmazione strutturata diceva che entry
point e exit point devono esser univoci; per cui, per quanto
paradossale, e' meglio la mia versione... :-D
PS. Il tuo esempio non e' buono, perche' la funzione python puo' essere
scritta paro paro in C#. Mica necessario usare le graffe, quando lo
statement e' unico...
-- 
Ciao!
Luca


Ok ma quante righe di codice ti ha tirato fuori che TU non sai manco
come le ha fatte?
Okkio, non dico che se usi che so Boa Constructor o Eric in Python e
le WxWidget o le PyGtk non ti vengano fuori cose un po' piu' cariche
di un python code liscio, ma comunque sempre roba leggibile
facilmente, dove puoi mettere le manine. C'e' chi usa Glade per
disegnare l'interfaccia e poi prende un buon editor (o IDE se
particoalrmente ricco di features com WinGIDE ad esempio) per scrivere
la sola parte di gestione degli eventi.
Greetings
JOKER Ltd.

 vbscript, e la cosa è per me molto interessante.
Beh hanno fatto una bella cosa davvero. E non lo ddico con 
ironia.ma
sono contento per chi deve lavorare in C# e si puo' scriptare le cose
con Python semplificandosi la vita.
Io a Python mi ero avvicinato per via della sintassi incasinata di
Bash e Perl. Poi ho scoperto che fior di linguaggio sia e ci ho
iniziato a fare cose, Oggi lavoro in una delel azinede (sempre piu'
numerose anche se in itaGlia come sempre siamo dietro anni luce anche
qui) che lo adottano come linguaggio.
Greetings
JOKER Ltd.

 facilmente, dove puoi mettere le manine. 
Lo puoi fare anche con XAML. Il problema e' che, contrariamente a
WinForms, devi sapere dove andare a mettere le mani...
-- 
Ciao!
Luca

 S., curioso
Sono due esempi presi al volo da internet. Il fato che sia stata
scritta anche in 
VB.NET
 e' venuto a gratis nel taglia e incolla
(paragonavo C# e Python, VB non lo considero manco).
Non avevo tempo di scriverle io e mi sono affidato al buon cuore di
chi lo ha fatto. Per le prime due manco potevo provarle (non ho
macchine win qui).
Greetings
JOKER Ltd.

 Versione C# del metodo Fibonacci:
in 2 righe (anche se ovviamente non piace a R#):
Func<long, long> f = null;
f = x => x <= 1 ? x : f(x - 1) + f(x - 2);
Per controllare:
    [TestFixture]
    public class Fixture
    {
        [Test]
        public void Test()
        {
            Func<long, long> f = GetFibonacci();
            Assert.AreEqual(0, f(0));
            Assert.AreEqual(1, f(1));
            Assert.AreEqual(1, f(2));
            Assert.AreEqual(2, f(3));
            Assert.AreEqual(3, f(4));
            Assert.AreEqual(5, f(5));
            Assert.AreEqual(8, f(6));
            Assert.AreEqual(13, f(7));
            Assert.AreEqual(21, f(8));
            Assert.AreEqual(34, f(9));
            Assert.AreEqual(55, f(10));
            Assert.AreEqual(89, f(11));
            Assert.AreEqual(144, f(12));
        }
        private Func<long, long> GetFibonacci()
        {
            Func<long, long> f = null;
            return f = x => x <= 1 ? x : f(x - 1) + f(x - 2);
        }
    }
Tra l'altro si trovano in giro versioni molto più furbe da diversi
punti di vista ;)
--
ale
http://ale.riolo.co.uk

 questa stride. e mica poco.
E perchè ? Come vuoi che faccia python a realizzare il linguaggio
dinamico ? Ogni oggetto lo rappresenterà internamente come una
collection nome valore dinamica e una lista di puntatori a funzioni
anch'essa dinamica, niente di fanstastico lo puoi realizzare anche in
un linguaggio dichiarativo, solo che ovviamente non puoi scrivere
oggetto.funzione ma oggetto.lanciafunzione ("sdfsdfsd", parametri)
oppure oggetto.colore = rosso è identico a oggetto.settaproprietà
( "colore", "rosso") E' la stessa cosa che fai quando usi la
reflection e quindi usi oggetti che non conosci a runtime in .net, la
sintassi è brutta ma puoi fare le stesse identiche cose, solo che in
un linguaggio dinamico è l'interprete che si occupa della conversione
della sintassi e sembra tutto più bello. Internamente poi le
"primitive" sono sempre le stesse :  liste, funzioni, puntatori a
funzione, allocazioni di memoria.

 e' dinamica. E' roba .NET.
Che cavolo è una roba dinamica ??? Che cambia se usi una virtual
machine o un'altra ? Puoi anche usare la vm java con Jython, che
cambia ? A parte le librerie ovvio, ma il risultato è sempre il
medesimo programma.

 statement e' unico...
def fib(n)
  n < 2 ? n : fib(n-1) + fib(n-2)
end
Al di la di righelli e bei momenti in bagno pero', sarebbe forse il 
caso di notare che è piuttosto inutile valutare un linguaggio in base a 
Fibonacci, ma forse su progetti un po' più grossi, che certamente in 
Python non mancano.
Un esempio che facevo su un'altro gruppo, esiste un progetto / 
framework per scrivere client e server aync per .net ? (Forse F# ?)
Ecco, Twisted Matrix, per esempio, è un bel vantaggio che io invidio 
abbastanza a python, perchè è molto produttivo e non perdo in 
performance.
  ngw
-- 
Nicholas Wieland (ngw)
Zooppa CTO
911 Western Avenue, Suite 420
Seattle, WA  98104  US

 static ..
Ovviamente, se in un'intervista tu mi usassi static in una situazione del 
genere, ti chiederei subito quand'è che ha senso e quando non ;)
-- 
ale
http://ale.riolo.co.uk
 


tutta questa arrampicata sugli specchi per dimostrare che è uguale, anzi
no :-)
chiariamo un po' di punti: 
- si possono definire signature di metodi e proprietà a runtime in un
linguaggio non tipizzato dinamicamente? no.
- ci sono tecniche alternative in questi linguaggi? ovvio che si.
- un linguaggio dinamico è più flessibile, produttivo e meno verboso se
devo, come in quel caso, implementare decine di metodi che fanno compiti
uguali ma con parametri diversi? ovvio che si.
- quale tecnica è più elegante? de gustibus...
venire da un linguaggio come c# o java è chiaro possa lasciare perplesso
vedere che dei metodi esistono a runtime ma la cui signature non è
cablata da nessuna parte, in quei linguaggi è una cosa che non esiste.
perplessi si, ma mica rimbambiti: non venire a raccontarmi che in quel
caso la tecnica non ti nasconde la complessità della generalizzazione e
sarebbe equivalente a usare direttamente la chiamata generalizzata. 
quanto all'eleganza, io sono javista e mi riferisco a java. ecco, in
java dopo che si è arrivati a dei livelli di formalismi da fantascienza
si è cominciato averne le palle piene :-) e infatti sempre più si vanno
affermando tecniche nei framework che escono dai binari dei pattern
tradizionali e della oop (un problema simile, ad esempio, in java lo
affronterei con interfacce, proxy e annotazioni, non certo con
ereditarietà/polimorfismo...). insomma, il concetto di eleganza si
avvicina più alla deregulation dei linguaggi dinamici piuttosto che al
rigore dei pattern tradizionali.

 a Fibonacci, ma forse su progetti un po' più grossi, 
Condivido totalmente. In effetti, questo voleva essere il senso del mio
post. A proposito, non sapevo che in Python ci fosse quell'espressione,
che non e' ne C# ne C++, ma presa paro paro dalla Bibbia (Kernighan &
Ritchie - The C programming language).
Oltre a tutto, credi, se io ho un rammarico e' proprio quello di non
poter usare Python a livello produttivo, visto il mio ambito
applicativo. Questo, non ostante a Python io critichi alcune cose: ad
esempio, mi manca un bel ciclo for 'a la C', e non amo molto l'idea
dell'indentazione come rilevante nella programmazione.
-- 
Ciao!
Luca

 f = x => x <= 1 ? x : f(x - 1) + f(x - 2);
In effetti le lambda non mi convincono, perche' tutto si puo' dire
tranne che una roba del genere sia immediatamente leggibile.
-- 
Ciao!
Luca

 dell'indentazione come rilevante nella programmazione.
Mah, in realtà Python di costrutti ne ha parecchi a quel livello, dai 
generatori alle list comprehension, poi sui gusti sulla sintassi non 
entro, ognuno ha i suoi.


 codice non scritto è l'unico certamente esente da bug.
Non capisco tanto questa affermazione. L'ermeticità non è un valore 
positivo in programmazione. Forse intendevi "codice conciso"?
Per quanto riguarda Java (che é sicuramente un linguaggio verboso) 
condivido fin là la tua analisi. E' vero che una classe qualsiasi supera 
le 100 righe di codice (normalmente), ma per la gran parte è costituita 
dai soliti getter/setter e menate varie, che francamente essendo 
autogenerati sono praticamente sempre esenti da bug.
Un'ultima nota: su JVM si possono avere metodi generati a runtime, ad 
esempio con Javassist. E' una praticamente sempre più diffusa, 
soprattutto a livello di sviluppo framework (anche fatti in casa).

 questo.
OK, non hai capito. Te lo ridico in modo semplice.
Indovina dove e' comparso per la prima volta?
Gli altri si sono adeguati.
-- 
Ciao!
Luca

 positivo in programmazione. Forse intendevi "codice conciso"?
diciamo che di quel codice "ammiro" il grado di generalizzazione
mantenendo comunque le signature dei singoli metodi, senza quindi
replicazione di codice. anche con java ultimamente ho cominciato ad
apprezzare e applicare tecniche che puntano a questo obiettivo (dovrei
citare un noto frequentatore di it.comp.java e un progetto, lambico, da
cui ho tratto ispirazione).

 OK, non hai capito. Te lo ridico in modo semplice.
LOL
-- 
ale
http://ale.riolo.co.uk
 

 cablata da nessuna parte, in quei linguaggi è una cosa che non esiste.
Adesso basta, se c'è una cosa che mi da fastidio è la supponenza alla
nwg del "ti lascia perplesso" perchè non capisci.
Visto che non capisco se dici che quel codice porta le signature di
tutti i metodi di flickr  a run-time, invece di accettare qualunque
idiozia e trasformarla nella chiamata generica che ti ho indicato sei
pregato di farmi vedere come fa.
Perchè per me è implementata la routine __getattr__  che viene
chiamata tutte le volte che una proprietà non viene trovata, dopo di
che lei va su flickr, chiede i paramentri e mette in cache il metodo
per non rifare la trafila la seconda volta che viene chiamata.
Quindi a run-time non esiste un bel niente, se non un tubo che accetta
tutto e che ogni volta (la prima volta)  va a controllare se e come il
metodo deve essere chiamato, il che è ESATTAMENTE equivalente alla
chiamata generica a funzione con un minimo di controllo e cache, il
che è esattamente la stessa schifezza che avrei scritto io senza
aggiungere niente di niente.
Ma visto che io non sono esperto, anche se il codice credo acora di
saperlo leggere dichiaro pubblicamente di essere a rischio di
cantonate micidiali non avendo nemmeno il compilatore..
Quindi, per colmare la mia ingoranza, se te mi vorrai rispondere sei
pregato di farlo con i riferimenti del codice e spiegando come
dovrebbe fare a creare tutti i metodi con le signature corrette senza
tanti appelli "a te non capisci perchè usi i dichiarativi".
Grazie.

 framework per scrivere client e server aync per .net ? (Forse F# ?)
WCF, fa parte del framework a partire dalla 3.5 e fa più o meno di
tutto.
http://msdn.microsoft.com/en-us/library/ms734701.aspx
http://blogs.msdn.com/b/wenlong/archive/2009/02/09/scale-wcf-application-better-with-asynchronous-programming.aspx

 nwg del "ti lascia perplesso" perchè non capisci.
Oh, la quota mensile di insulti gratuiti. Oh, te che capisci, magari 
riesci anche a scrivere un nickname di 3 lettere correttamente.
Non entro nella discussione per la tua risaputa incapacità di ammettere 
quando hai torto (marcio), ma solo il fatto di confondere 
metaprogrammazione e reflection basterebbe per farti trottare un 3 mesi 
abbondanti ;)
  nwg


 Grazie.
prego.

 cui ho tratto ispirazione).
Anche io avevo dato la disponibilità a collaborare per quel progetto, 
stavo facendo il porting per CDI. Stai ancora collaborando per caso? La 
situazione mi sembra ferma...

 di fare quello che ho scritto.
Hai ragione, nel senso che non credo che la manipolazione del bytecode 
faccia parte della reflection.
Però, in sostanza, in Java è possibile fare quello che dici. E' 
possibile creare classi a runtime e poi invocarle tramite reflection. E' 
anche possibile modificare una classe esistente (facendo però bene  i 
conti con il classloader).
Quello che non credo sia possibile fare è aggiungere metodi o proprietà 
ad un oggetto. Ma potrei sbagliarmi...

 ad un oggetto. Ma potrei sbagliarmi...
Anzi, se è possibile modificare una classe deve essere possibile quanto 
sopra. Ci vedo un mare di casini però...

Il 29/08/10 18.48, Cicap ha scritto:

sinceramente è arrivata l'estate, poi con un pargolo (anzi pargola) in 
arrivo, insomma a parte tirar giù i sorgenti e guardarli non ho avuto 
modo di fare altro...

 A proposito, non sapevo che in Python ci fosse quell'espressione,
E sapevi bene: l'operatore ternario in Python non c'è :-)
(Almeno non con quella sintassi).

 end
Sfrutto impropriamente il tuo messaggio per aggiungere una soluzione 
Perl6, col quale per generare la lista (infinita) di tutti i numeri di 
Fibonacci basterebbe:
@all_fib = 0, 1, * + * ... *;
Nemmeno in Haskell (né in altri linguaggi funzionali puri) si puň 
scrivere in maniera cosě espressiva.
Python permette qualcosa di simile, ma in maniera IMHO molto piů complicata.
Java e C# semplicemente se lo sognano.
P.S.
La generazione della lista, ancorché infinita, č immediata e non occupa 
memoria, grazie alla lazy evaluation.

 Python non mancano.
Ok, era solo per dare una idea della compattezza che pero' rimane
leggibile. Si possono compattare anche altri linguaggi, ma poi perdi
in leggibilita'. Se vuoi qualche esempio di roba complessa ti scarichi
OpenERP ad esempio. Qui non posso postare un applicativo completo, mi
plonkano a vita se lo faccio :)
Greetings
JOKER Ltd.



Nei linguaggi dinamici tipicamente la metaprogrammazione, cioè la 
generazione programmatica di classi e oggetti a runtime, è 
sconsigliata, a meno che non sia assolutamente necessario a livello 
funzionale usarla.
Per dire, in Rails, la metà dei plugin aprono classi del core e 
aggiungono roba, e lo fanno in quanto AR usa la metaprogrammazione per 
essere modulare ed estendibile, quindi ha perfettamente senso usare la 
metaprogrammazione in quel caso.
http://www.pragprog.com/titles/ppmetr/metaprogramming-ruby
 per più 
informazioni.
E' una caratteristica mutuata a grandi linee dalle macro di Lisp, che 
sono credo oggettivamente una meraviglia, in quell'ambiente usatissima, 
e particolarmente interessante proprio perchè avviene a compile time.
Per la cronaca, la metaprogrammazione di Python è più potente e 
completa di quella di Ruby.
  ngw


 memoria, grazie alla lazy evaluation.
IMVHO il P.S. è la parte più significativa :)
BTW, in C# si riesce a fare funzionalmente la stessa cosa, ma 
espressivamente è tutto un altro mondo ;)
-- 
ale
http://ale.riolo.co.uk
 

 abbondanti ;)
Come al solito, non sa, crede di sapere e spara... e sbaglia.
La metapragrammazione è la capacità di modificare il codice, ma nel
particolare caso in cui modifichi te stesso con il tuo stesso
linguaggio si chiama reflection.
Che faccio ? Segno ? Poi facciamo tutto un conto con le stock e
myspace ? Ma quante cose ti devo insegnare a gratis ??
Link per gli scettici :
http://en.wikipedia.org/wiki/Reflection_(computer_science)
http://en.wikipedia.org/wiki/Metaprogramming
"The ability of a programming language to be its own metalanguage is
called reflection or reflexivity."
Ma bastava saperne qualcosa di informatica, non è che ci volesse molto.