Newsgroup: it.lavoro.informatica
Titolo: Funzionale ed Impertativo

Premessa : per me esistono due tipi di linguaggi, il funzionale e

l'imperativo. Non è vero ? Voi ne usate altri ? In caso parliamone.



I miei 2 cents sul perché l'imperativo/dichiarativo è meglio



La stragrande maggioranza dei programmatori sono delle capre. Talmente

capre che non sanno neppure gestire l'errore, neppure le transazioni,

niente. Mettono le aliquote IVA hard-coded, le righe bolle in array

(che non so cosa voglia dire ma l'ho letto qui pochi giorni fa) ,

fanno errori banali, non hanno idea di cosa comporta leggere da DB

invece che dalla memoria, non sanno cosa è la sessione ne hanno ben

chiaro il concetto state-less del web. Ma a dire il vero manco il web

server sanno come funziona.



Già spiegargli il procedurale fatto bene è difficile. Con gli oggetti

fanno già  un casino, o fanno l'oggettone monolitico che fa tutto

anche quello che niente ha a che fare con lui oppure fanno galassie di

oggettini minuscoli polverizzando talmente tanto il codice che se

tocchi qualcosa c'è il rischio che caschi tutto l'universo.



Quindi, meno gli fa fare il linguaggio e meglio è. Dichiarazione delle

variabili e comandi semplici e lunghi,  e pazienza se dovremo

rinunciare alle magiche ed eleganti scorciatoie dei funzionali.



Per questo gli imperativi/dichiarativi sono meglio : sono più facili

da capire, sono progettati per rendere tutto esplicito.







( scrivo solo per applicazioni di tipo gestionale / finanziario / web

application di vario genere)
















 capre che non sanno neppure gestire l'errore, neppure le transazioni



Tempi stretti, programmazione "agile" e gestione delle eccezioni solo

dopo che l'eccezione c'č stata, ecco cos'č.



Shift


 application di vario genere)



Nel settore "finanziario" (quantitative finance) e bancario, i

linguaggi funzionali sono già discretamente presenti (Barcleys, Jane

Street, un pò di istituti in Svizzera vicino a dove vivo io (confine

con la Germania), etc.) e sono in costante crescendo (linguaggi

proprietari, derivati di APL come J e soluzioni atipiche a parte). Ci

sono Ocaml e Haskell, si usa R (fantastico linguaggio davvero), Python

è in ascesa, i soliti C++ e Java che non di rado oramai forniscono il

backend e si occupano del feed dei data.



Come dicevo vari posts fa, è un gran bel periodo per l'informatica

della programmazione e dello sviluppo, oserei definirlo quasi

progressista :)


 dopo che l'eccezione c'è stata, ecco cos'è.



Questo accade anche perchè ancora oggi nel 2012, pochi partono

imparando/insegnando ad altri le cose giuste.



- Hello, World!

- Version Control

- Unit Testing

- tutto il restante, in maniera iterativa.



Qualsiasi sia il linguaggio, la piattaforma e gli obiettivi a cui si

punta, la strada giusta una è.


 backend e si occupano del feed dei data.



Ci sarebbe anche Erlang (
http://www.erlang.org/
)


 Secondo te perchè accade questo?



Perché c'è bisogno di software, e non ti credere chi scrive software

per il quantitative finance in Haskell si metterebbe a scrivere una

gestione ordini a fornitore. E non credere neppure che lo saprebbe

fare.



Semplicemente sono ambiti diversi. C'è anche chi scrive software per

le previsioni metereologiche, ma la massa scrive software che fa input

e manipolazioni dei dati scalari o documenti e lo fa pure male.



Tutto quello a cui ti riferisci per me è nicchia. E tra l'altro non mi

attira neppure un po, mi interessa più l'usabilità dell'interfaccia

dell'efficienza del codice.










 - tutto il restante, in maniera iterativa.



Capo: "hai finito ?"

Prog: "no, ora ho il version control"

Capo: "ma stampa Hello World ?"

Prog: "si ma..."

Capo: "allora metti in distribuzione"

Prog: "ma l'unit testing...??"

Capo: "se si lamenta qualcuno"





Shift




 Prog: "no, ora ho il version control"



"non lavorare per un cretino" l'avevo dimenticato? Provvedo subito:



- Non lavorare per un cretino



:)


 Barcleys



Un bravo a me stesso, anni da correntista con loro e manco mi ricordo

come si scrive.

(was: "BarclAys")



Si immagino per analisi distribuite di una certa entità (su fgpa poi?)

ma non m'è venuto in mente perchè non conosco nessuno che l'usi in

quell'ambito di persona, mentre quelli che ho riportato sono tutti

"contatti diretti".


 dell'efficienza del codice.



Ho capito, ma quello che per te è nicchia e non t'attira non diventa

automaticamente "moda". Chiariti su questo, chiusa la discussione

ovviamente.




Hai presente SQL? Pure lui è dichiarativo.

Hai mai visto query complesse che ad un certo punto non ritornano quello che 

"tu vorresti"?

Quanto è bello da debuggare?

Per dire che la programmazione dichiarativa è effettivamente utile solo se 

la logica che sta sopra e che governa il tutto è chiara, altrimenti è un 

inferno.

Diciamo che ti obbliga a risolvere in modo pulito il problema da un punto di 

vista logico in modo che poi "l'implementazione facile" fatta in modo 

dichiarativo diventa chiara pure quella come conseguenza.






 ovviamente.



Ma neppure bisogna dare troppa importanza ad un linguaggio, imho ad

esempio Ruby e Python hanno successo perché sono nuovi o perché che un

bel framework (RoR) ma non perché sono migliori sintatticamente.



O almeno non sono così migliori da farci le Ruby night.



E visto che esiste RoR e Python MS ha fatto MVC e Razor per i template

e F#.



Ma sono mode, ora ci sono quelli che sono nuovi, il migliore magari

resterà e prenderà il posto di un precedente, ma non migliorerà di

niente la qualità del codice. Per quello servono paradigmi nuovi,

strumenti nuovi.





Che poi, in ambienti particolari questi linguaggi trovino la loro

killer application e diventino importanti nessuno lo mette in dubbio.










 questo caso specifico, vedi più sotto...)



Pero' mi tocca quotare. Succede a volte che prendo la 'prima strada' sapendo che la sto prendendo ma che la vita mi diventa molto più semplice in fase di debug. Poi, volendo, si potrebbe passare alla seconda, ma allora si contravviene alla prima regola dell'informatica:

"se funziona quel che basta / non toccare che si guasta!" 



PS. Python a me non riesce a piacere. Mi tocca, ma io resto un C-ista in pectore (o un C++ ista di prima maniera, quando i template non esistevano).



-- 

Ciao!

Luca


 "10" }

{ value -> 0, line -> [ ... ], name -> "alpha", price -> 15.19, qt ->

"10" }

{ value -> 0, line -> [ ... ], name -> "alpha", price -> 15.19, qt ->

10 }

{ value -> 151.9, line -> [ ... ], name -> "alpha", price -> 15.19, qt

-> 10 }



e siamo solo alla prima iterazione, continua fino alla fine.

Lo stato della seconda:



{ lines -> [ ...] }

{ lines -> [ ...], value -> 2083.45 }



Quale ti sembra più "naturale"?




Fin che va tutto bene la seconda... :-)




 print value



facciamo un caso reale. Prendiamo f come un array di stringhe da

parsare posizionali con prima il nome, poi il prezzo e poi la quantià

ed includiamoci la gestione dell'errore .



te lo scrivo in pseudo-basic c# inventato :



decimal valore



foreach  linea as string in f



  string nome

  decimal prezzo

  decimal quantita



  try



     nome = left( linea, 50)

     prezzo = substr( linea, 51, 60)

     quantita = right ( linea, 9)

    valore  = prezzo * quantità



catch (xxx)

   print "c'è un errore alla linea  : "  + linea + " impossibile

continuare"

   return





end for





Ok, adesso scrivilo con il tuo linguaggio, sono genuinamente curioso.





Ci rinuncio. A beneficio degli archivi e di chi leggerà in modo che

non si faccia idee sballate:



- E' colui che parla solo la sua lingua madre ad essere limitato in

tante cose, non i poliglotti a cui vorrebbe spiegare il valore delle

lingue che non conosce -> Imparate tutti i linguaggi che vi capitano a

tiro.



- Ruby, Python, Java, J o F# non sono "nuovi": sono nati quando sono

nati. Python è del '91, Ruby pure. No aspetta, quella è n'altra

ruby... Ruby è del '93, Java del '95 e J del '90, F# del 2005

(discende da ML, 1973 signore & signori). "Ma io intendevo nuovi per

*me*, che non li conosco e ne sento parlare solo dall'altro dì"... e

allora scrivilo, "sono nuovi per me", che chi li usa dal tempo che fu

non può certo aggiornare il curriculum in base ad un concetto

soggettivo del tempo!



- sintassi, semantica, "migliori sintatticamente" e variazioni sul

tema -> Programming Language Pragmatics, Third Edition - Michael L.

Scott



- Si, le Ruby nights e tripli sensi [in]volotari annessi ha fatto

ridere un pò anche me.



- F# usa la type inference, Python il dynamic typing. Se qualcuno alla

Microsoft ha pensato dopo secoli di offrire il primo in risposta al

secondo per seguire la famigerata "moda di non dichiarare le

variabili"... Non so, fate voi -> let there = "be *common sense*"



- Sebbene la "M" in MVC stia per "Model", non lasciatevi ingannare:

(ahimè) _non_ stiamo parlando di modelle e di moda ->

http://c2.com/cgi/wiki?ModelViewController




- I paradigmi ce li avete, e in abbondanza -> usateli, cacchio.



- Gli "ambienti particolari" non sono roba per maniaci, ma posti dove

può accadere di trovare gente molto in gamba, paghe sopra la media e

problemi interessanti da risolvere -> warning: sei tu che devi cercare

gli ambienti interessanti. Dopo un tot di tempo, può darsi che anche

loro inizino a cercare te.



- Che ho dimenticato? Ah si: non fatevi dire cosa è meglio, cosa è

peggio, cosa dovreste usare e cosa dovreste evitare. Scopritelo da

soli studiando e praticando. Volete mettere la soddisfazione? ->

recurse: this post


 *me*, che non li conosco e ne sento parlare solo dall'altro dì"... e



Beh, certo, per me, intendo sempre per me e per google :



http://www.google.com/trends/?q=Python+programming&ctab=0&geo=us&date=all&sort=0




e ti dico anche perché, lo usava Google per l'App Engine



( a proposito, chi sa che fine ha fatto ? Sarà morto come tanti altri

prodotti Google o prospera ? Bah )



e perché lo usava ? A dire il vero la soluzione migliore sarebbe stata

java come con Android ma sai.. le licenze...






 java come con Android ma sai.. le licenze...



ma java c'è su gae.





Sei genuinamente curioso di vedere un ciclo e un match di una regexp?

Per tutto il resto, hai mai provato a studiare seriamente un

linguaggio funzionale?

Perche' a me pare di no, anzi, mi pare che qualunque paradigma venga

sempre ridotto al "conosciuto" per renderlo piu' masticabile.



  ngw








 Sei genuinamente curioso di vedere un ciclo e un match di una regexp?



Dio, a volte potrebbe pure servire ("perche' 'sta roba non va?").



Che poi, IMHO non esiste nulla di più ostico (in termini di vicinanza al modo di pensare) delle regexp. Pero' probabilmente sono io che non ho ancora avuto la mia epifania.



-- 

Ciao!

Luca






Ok, ma sto esempio in versione funzionale si potrebbe vedere o è un

problema?





-- 



questo articolo e` stato inviato via web dal servizio gratuito 

http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it







 vicina alla macchina



Purtroppo pesa il fatto che per anni si è stati abituati a pensare 'vicini alla macchina', per cui tornare indietro a volte costa fatica.



(*). A giudicare dal nick e da qualche citazione, non sei proprio di primo pelo nemmeno tu... ;-)



-- 

Ciao!

Luca


 sempre ridotto al "conosciuto" per renderlo piu' masticabile.



a me pare che l'esempio in funzionale ancora non s'è visto


 ma java c'è su gae.



ops, è vero. Lo hanno aggiunto dopo.



ho visto che hanno messo anche in MySql all'alba dell'autunno del

2011, era l'ora !


 2011, era l'ora !



bah, personalmente di mysql non ne sentivo la mancanza (e a onor del

vero nemmeno di nessun altro relazionale).




 vero nemmeno di nessun altro relazionale).



vai, dopo il funzionale/imperativo riapriamo un po' di diatriba SQL /

NO SQL che è un po' che manca. Facciamo dopo il 1° Maggio che ora sono

tutti in ferie.



ritiro quello fra parentesi, fai come se non l'avessi mai scritto...





Io non sono esattamente sicuro che il nostro modo di pensare sia

adattissimo a fare il parsing di chunk di stringhe giganti eh :p

Comunque c'e' il libro della O'Reilly sulle Regexp che le rende

masticabili (appena aggiornato, tra l'altro). Una volta capite sono

utili proprio per evitare di usare il tuo cervello per cazzate come il

parsing delle stringhe, che sinceramente, che sia ruby, python, c# o

lolcats non mi sembra granche' come problema.



  ngw




 Fin che va tutto bene la seconda... :-)



Va va.


 parsing delle stringhe, che sinceramente, che sia ruby, python, c# o



- Le Regexp sono complesse, inaffidabili ed inutilizzabili se non in

casi semplici o da parte di persone molto esperte.



- L'esempio del parsing non l'ho scelto io.



- Prima di dire che sono "cazzate" bisogna saperle fare, e bene.  Poi,

ma proprio dopo, si può dire che sono "cazzate".



Altrimenti si sbagliano i decimali come quelli delle poste qualche

tempo fa.



PS : e dopo tutti questi inviti a studiare il codice non si vede....

forse non è così una "cazzata".








 ovviamente il mio va anche con un file da 50Mb e 5 milioni di righe.



fammi capire queste "caratteristiche" un secondo, che io queste mode

Microsoft moderne non le ho mai toccate: tu hai una lista di stringhe

senza un separatore ne niente, ma soltanto la posizione, che se non

capisco male dal 51 al 60 carattere dovrebbe essere un decimale, e gli

ultimi 9 caratteri dovrebbero essere la quantita'?



  ngw


 ovviamente il mio va anche con un file da 50Mb e 5 milioni di righe.



Non vedo il mio post, se compare un post doppio chiedo scuso.

Fammi capire bene queste caratteristiche, che io 'ste mode Microsoft

moderne non le seguo e non le conosco.

Te hai delle stringhe senza separatore, ma di cui sai soltanto la

posizione degli elementi? E i dati che ti interessano sono il decimale

dal 51esimo al 60esimo carattere e l'intero degli ultimi 9 caratteri?

Corretto?



  ngw


 ultimi 9 caratteri dovrebbero essere la quantita'?



si chiama posizionale, c'è da qualche anno e non c'entra proprio

niente con MS. Lo usano però in tanti il posizionale. Ma proprio tanti

eh.



Torniamo a noi, si, fai che è divisa così più o meno, non ha

importanza il dettaglio.




 wrote:


Ma il mio era già codice reale non pseudo-codice. La mia soluzione

equivalente alla tua è:



try:

    value = sum([int(qt) * dec(price) for name,qt,price in f])

except ValueError:

    print 'error on line: ', name,qt,price



posso scriverla anche come



value = 0

try:

    for l in f:

        name, qt, price = l.strip().split()

        price, qt = money(price), int(qt)

        value += price * qt

except IOError as errno:

    print errno

except ValueError:

    print l



ma non è quella che ho "letto" quando ho visto il probema.



p.s. il semplice esempio viene da 
http://www.dabeaz.com/chicago/preparation.html
,

stavo prendendo idee su concetti avanzati per tenere un mini-corso su

lazy evaluation e generators a cavallo con functional programming con

i colleghi quando tornerò in sede.






Interessante!



Finalmente uno competente che scrive codice su cui discutere.



Una cosa però :  come lo gestisci il parsing ? Il tuo esempio non lo

fa.












 (*). A giudicare dal nick e da qualche citazione, non sei proprio di primo pelo nemmeno tu... ;-)



Ma volessimo fare che adesso sono io l'unico giuvinastro

"proggressista" qui?! (ovviamente scherzo :)



Io quando vedo stringhe vedo



awk '{sum += $2 * $3}; END { print sum }' fname



:)


     print l



questa è equivalente ma è anche un ciclo uguale uguale al mio, non

vedo nessuna differenza se non nelle istruzioni scritte diversamente,

aiutami se sbaglio.



Perchè fai così, perchè? Dopo averlo letto non avevo il coraggio di

chiedere e tu ora mi fai così?



Perchè??


 Perchè??



Voi vivete proprio in un alto mondo. Che dire, buon per voi. Forse.









Ahem. Tagliando la testa al toro, se il file è come quello del link di

prima:



----------------------8<-------------------------

AA 100 32.20

IBM 50 91.10

CAT 150 83.44

MSFT 200 51.23

GE 95 40.37

MSFT 50 65.10

IBM 100 70.44

----------------------8<-------------------------



try:

    with open(fn) as f:

        ls = [l.strip().split() for l in f]

    v = sum([int(q) * m(p) for n,q,p in ls])

except ValueError:

    print 'err:', n,q,p

except IOError as e:

    print e

else:

    print v



Non far caso ai bindings monosillabi, è la noia che mi rende sintetico.


 ----------------------8<-------------------------



ok, anche a me è venuto a noia.



Ma il tuo codice non fa quello che fa il mio. Non ci va neppure

vicino. Ma va bene così. Diciamo che basta dopo tutti questi post

basta.















Giusto per capire, sei in vena di flame? Non ho moltissima voglia, ma

visto l'atteggiamento da sbruffoncello posso darci una pensata. Del

resto stai facendo cast a cazzo su una stringa e li stai chiamando

"check sui tipi", dovrebbe essere piuttosto veloce.



  ngw


 visto l'atteggiamento da sbruffoncello posso darci una pensata. Del



no, basta. Non ne ho proprio voglia.



Il "un altro mondo" era riferito al fatto che a quanto pare "vi"

sorprendete per un flusso dati posizionale.



















Perche' nella sua idiozia ha almeno avuto la decenza di mettere un

delimitatore.

[\w]+([0-9.]{9})([\d]{9}), fatta in 7 secondi da programmatore esperto

come qualunque sistemista junior di questo pianeta quale sono.

Prenditela e usatela nel tuo linguaggio favorito.



  ngw



Io ti ho fatto una domanda e basta. E nessuno si e' stupito, quello

che stupisce e' la soluzione, che e' codice di merda anche se

inventato.



  ngw



Sorry avevo letto di fretta male e non so come pensavo ti riferissi ad

Equinozio sull'età. Io vado per i 35 ma ho già accumulato notevoli

guai con i "conpiuterz" ;)


 vicino.



Per mia somma fortuna e merito, aggiungo. Non ti consiglio di studiare

perchè hai già il classico atteggiamento di chi volge al calare, e

chissà da quanti anni poi.



Adieu


 [\w]+([0-9.]{9})([\d]{9}), fatta in 7 secondi da programmatore esperto



Bella quella riga, che cosa fa lo sai ? Che attinenza ha con il codice

predente lo puoi spiegare ?  Come vorresti utilizzarla e per quale

scopo ce lo dici ?  Che non è equivalente al parsing del linguaggio lo

capisci ? O lo hai capito ? Che i delimitatori non ci sono e non per

mia decenza ma perché spesso non presenti in  standard internazionale

lo intuisci ? Che è importante evitare di offendere non lo hai ancora

imparato ?





bonanotte e buon 25.


 delimitatore.



Idiozia d'esempio dal link, voglio sperare intendessi.


 imparato ?



ovvia, birrettina e popcorn che lo spettacolo entra nel vivo... :p






 diverso.



Ma tu hai mai scritto software del tipo che diceva equinozio, tipo

contabilità? E magari riusando e colloquiando con altri pezzi di

software preesistenti ed intoccabili? Il tutto in un ambiente software

preassegnato?

Altrimenti mi sembra un tantinello fuori posto affermare che basta

scrivere in modo diverso, o basta usare Haskell o F#, con tutta la

simpatia che ho per loro.

Nel momento in cui mi dirai che es. Barclays fa *tutto* in Haskell,

compresa contabilità, transazioni, portale internet, quadrature

notturne, ecc. ecc., allora le cose cambieranno, ma non prima.



ps: le espressioni regolari funzionano abbastanza benino anche senza

delimitatori...


 simpatia che ho per loro.



per quanto riguarda f# il fatto di prenderlo in considerazione implica

che sei nella clr, ergo se lo ritieni opportuno lo puoi usare senza

dover rendere conto ad altri pezzi di codice preesistenti e

intoccabili.

ma in senso generale, se si parte dal presupposto che si lavora come

ultime ruote del carro su progetti dove è già tutto deciso da altri

allora diventa inutile qualsiasi disquisizione tecnologica, in quei

casi si fa quello che dice il caporale e basta.


 chissà da quanti anni poi.



Calare cosa ?



Quel codice non fa quello che fa il mio : non fa il parsing

posizionale. L'idea era semplicemente di paragonare due sintassi su un

caso reale. E pure facile perché invece di scrivere il numero di riga

ho estratto la riga con errore (che ovviamente è sbagliato).



Ma a quanto pare, non so per quale cavolo di motivo, ma cose semplici

e tranquille come due listati uno sopra ed uno sotto che facciano le

stesse cose non si possono fare, tutti ad incazzarsi ed a

prendersela.



Pure per imparare qualcosa (per dire io certamente). Invece tutti a

dire che ce l'avete più lungo e a dare dell'idiota. OK SI SONO UN

INCAPACE SUL VIALE DEL TRAMONTO. (sai quanto me ne frega di queste

gare, non mi interessa minimamente essere il più bravo della classe)
























 inventato.



Si, non è codice, c'è scritto. Serviva solo per ragionare.



Guarda te lo aggiorno :





Long riga = 0

decimal valore

string errore  =""

foreach  linea as string in f

  string nome

  decimal prezzo

  decimal quantita



  riga ++

  nome =  left( linea, 50)



  Se not Decimal.TryParse(substr( linea, 51, 60)  , prezzo )  allora

errore = "campo prezzo formattato male"

  Se not Decimal.TryParse(  right ( linea, 9)    , quantita )  allora

errore = errore  + "campo quantità formattato male"



  Se  Errore != "" allora

	print "c'è un errore alla linea  : "  + riga + " " + Errore

	return



      valore  = prezzo * quantità

end for




 bonanotte e buon 25.



see, statt'bbuon guagliò.



Io ho stappato la cola e mi sono dato al post flemmatico e grottesco,

spero apprezzerete.


 "moda" e scempiaggini e argomenti che non hai mai visto con il



Guarda, se c'è una sfida io ho già perso.



Perché te conosci un altro modo di fare la stessa cosa ed io no. Sul

"non si è ancora visto il codice" devi capire che tra me e nwg va

sempre a finire così, non era certo rivolto a te.



io ho scritto quella merda (si perchè di merda si tratta) per vedere

se riuscivamo a paragonare le soluzioni ma neppure sintatticamente, ma

solo per vedere se e quanto era più chiaro un modo di scrivere che non

conosco. Dato che per quanto ne so io (e sicuramente sbaglio) i

funzionale è tanto bello fino a che siamo negli esempi, ma quando

scendiamo nel particolare le cose si possono complicare notevolmente.

Non a fare ma a leggere.



Tutto qui.



PS:  mi dispiace se i miei toni con nwg hanno infiammato troppo la

discussione.






 "A'cazzaroooooooo....".



PS :



1 ) Cazzaro lo dai a qualcun'altro.

2 ) Nwg a quanto mi risulta è molto più giovane di me

3 ) Ho ancora le fatture, e non mi pagavano poco




 notturne, ecc. ecc., allora le cose cambieranno, ma non prima.



ispas, rifletti un attimo: perchè *dovrei dirtelo*? Hai forse tu uno

scopo diverso dal mio nel parlare di questi argomenti? Perchè io non

ho mai parlato di "fare tutto" (link alle mie chiare ed inequivocabili

parole nel caso), è l'esatto contrario: ho speso posts parlando di

sapere *quello e quest'altro*, di conoscere "il vecchio" e "il

nuovo" (non inteso "alla Equinozio", ovviamente) per trovare nuovi

sbocchi lavorativi, di chiedersi "conosco la programmazione

imperativa, cosa mi offorno altrove nel caso?", di valutare perchè il

mondo non è statico ma si muove in certe direzioni (altrimenti siamo

sempre in balia di chi ci dice cosa usare e perchè), di pensare con la

propria testa per fare le scelte che più ci gratificano, sono

produttive e perchè no, ci "esaltano" (in senso positivo: il lavoro

non deve essere solo devo usare questo per campare o nulla, cavolo

esiste anche alzare il sedere e cercare l'alternativa al gregge

qualche volta, eh), etc.



Dimmi tu, ti sembra che ho fatto (male) il predicatore fallito o ho

solo forse ribadito concetti e visioni che conosciamo da decenni ma

che per qualche assurdo motivo molti si ostinano a non cogliere (in

tutti i sensi, soprattutto come opportunità oltre che come

conoscenza).



Tutto è partito dal lamentarsi sulle offerte di lavoro (un problema

politico-sociale del paese Italia anzitutto, ho ben nota la

situazione) o il mercato di incompetenti in cui si è "costretti" ad

operare. Io ho solo provato ad alzare la voce fuori dal coro per dire:



"hey gente, c'è anche altro la fuori, eh. soprattutto se potete

muovermi/spostarvi e credete un minimo in voi stessi. è un bel

periodo, c'è un sacco di scelta e ci sono molti ambienti in cui gli

incompetenti vengono fatti fuori o non rientrano proprio perchè non

hanno le carte in regola per partecipare. guardatevi intorno,

insomma."



Prendo atto che la cosa non interessa, ne' a fini esortativi di

discussione ne' a fini tecnici e forse manco per curiosità. Poco male,

va benissimo così.


 wrote:


Solito, a piu' riprese sfoderi il classico atteggiamento da "che cazzo

ne sapete voi giovani, che io ci ho l'esperienza", spari scemenze a

piu' non posso con la solita sicumera, e poi quando la gente ti

risponde a tono nasino all'insu' e vittimismo.

Non attacca, mi spiace. Prova con qualcun'altro.



  ngw



Ritiro il "cazzaro" e me ne pento sorry.



Per il resto, quando ti capiterà di chiedere a qualcuno "diciamo che

facciamo X, tu come lo fai?" ti consiglio di usare un formato minimo

come vedi questi così avrai meno fraintendimenti:

http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=3



 server sanno come funziona.



una cosa a cui ho sempre pensato. A scuola facevamo programmazione, ma gli 

unici che ci azzeccavano un po' eravamo io e un altro: tutti gli altri in 

classe non ci capivano un fico secco. E non parlo di chi andava male anche 

in tutte le altre materie, ma parlo anche dei 'secchioni' .

Non sara' che programmare (non scrivere qualche riga di codice e riuscire a 

compilare senza errori !) e' difficile ? personalmente ... l'ho sempre 

pensato.



my 2 cents



Andrea 






 "contatti diretti".



Ci fanno parecchia roba per TLC, l'ha inventato Ericsson.

Poi ci hanno fatto un po' di tutto, ci sono anche framework web e DB no 

SQL


 va benissimo così.



Dato che il periodo è "bello" per la scelta dei linguaggi, ma è

indubitabilmente pure brutto per altri aspetti più terra terra,

capisco che tanta gente ha difficoltà a sbrigliare la fantasia dopo

giornate di ordinario lavoro pesanti come macigni (magari tutte col

PHP... :-))

Quindi  l'esortazione è giustissima, ma non devi prendertela se a

volte prevale la stanchezza e la disillusione.



Quello lo so, senza entrare nel suo uso in concorrenza spinta (perchè

uso altro) ho anche discreta esperienza nella programmazione. Chiedevo

di ulteriori dettagli perchè ho intravisto l'uso di architetture su

fpga (
http://www.fpgadeveloper.com/
) ma non conosco nessuno che ci

lavori su al momento.


 casi si fa quello che dice il caporale e basta.



:-)) Bè, sai, se vai, che so, in una banca, neppure tanto grande, non

è che ti fanno riscrivere tutto il loro software daccapo appena entri

nella loro sede.

Quindi dobbiamo chiarirci di quale entità di progetti parliamo. Su

certe scale di norma fai pezzi, più o meno grandi, ma sempre pezzi che

si devono incastrare in architetture molto più grandi ed intangibili.




 al momento.



c'è questo progetto 
http://www.rabbitmq.com/
 che è di fatto il 

riferimento per quanto riguarda amqp e trova impiego in una grande 

quantità di ambiti anche molto critici come ad esempio lo stack cloud 

eucalyptus versione open di amazon ec2 (e forse addirittura in 

quest'ultimo stesso).




> Ritiro il "cazzaro" e me ne pento sorry.



thk, ed interessante il link.


 application di vario genere)



Quando ho scritto codice e' quasi sempre stato per sistemi real time

(talvolta hard real time, altre soft real time) con brevi divagazioni

verso web application e simili



Ciao,

Marco



-- 



questo articolo e` stato inviato via web dal servizio gratuito 

http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it







 girottolando nel web:
http://smyck.net/2012/04/22/why-erlang/




L'ho letto esattamente ieri, che fatti. Però non ricordo come ci sono

arrivato, forse HackerNews.




Allora, se si tratta "solo" di scrivere codice in modo migliore, a parità di 

strumenti, ci si può arrivare... :-)




 strumenti, ci si può arrivare... :-)



Come dico sempre, m'accontento di poco. Purchè me lo diano però :) .




Mi tocca dir di si.

Spesso il debug chiarisce allo stesso autore del codice la logica reale con 

cui il suo sw sta funzionando e che è un po' diversa, nei dettagli, da 

quella che aveva in mente e che ha cercato di implementare, praticamente una 

sorta di step ritardato dell'analisi.

Però son sicuro se dico che si è in tanti a peccare... :-D




 girottolando nel web:
http://smyck.net/2012/04/22/why-erlang/




CouchDB e Riak sono in Erlang.



  ngw



Si, sebbene abbia letto sempre con piacere il blog di Kantz non ho mai

usato ne' guardato il codice di CouchDB. Penso che comprerò quel libro

"Seven databases in seven weeks" o giù di li visto l'altro giorno, al

netto di PostgreSQL e Redis non conosco gli altri che tratta (CouchDB

compreso) e non mi va di rimanere ulteriormente indietro su un

argomento che è hot (per meglio dire, hot da anni oramai).



Riguardo Erlang, mi riferivo ad altro ovvero a certe soluzioni fpga

che hanno la VM di Erlang a bordo e ti permettono quindi di saltare

completamente il tuo stack abituale - sebbene usate da tempo altrove,

solo negli ultimi due anni hanno preso decisamente più piede.

Chiaramente non è che te le ritrovi dietro l'angolo sui ng, chiedevo

giusto per lanciare la cosa, si sa mai che.


 PS. Python a me non riesce a piacere. Mi tocca, ma io resto un C-ista in pectore (o un C++ ista di prima maniera, quando i template non esistevano).



Come mai (e per cosa lo usi se posso chiedere)?



Riguardo C++ e templates, dovendo C++ essere un "male" necessario che

ci tocca (e ci ho speso su diversi anni volente o nolente) preferisco

comunque lavorare con i templates che con il suo object model. Ma

forse è la mia predilizione per l'aspetto dichiarativo/funzionale (mi

è capitato di lavorare in teams dove qualcuno chiedeva di confinarne

l'uso a parti ben determinate perchè "I can't f****** wrap my head

around that stuff" - tempi bui davvero oh :)


 chiama più debug, ma reverse engineering sei daccordo? ;)



Ma i test "automatici" qualcuno li dovrà pur scrivere, no? E quindi

spostiamo la verifica dal debug del codice ad un eventuale livello più

alto di descrizione dei test, od addirittura dei requisiti.

In alcuni ambiti questo è abbastanza agevole, in quanto i requisiti

stessi sono espressi in maniera formale. In altri ambiti, come i

famigerati gestionali, è molto più difficile, a mio parere.




 Come mai (e per cosa lo usi se posso chiedere)?



Il come mai è semplice e, va detto, MOLTO POCO tecnico. Mi piace. Mi ci trovo bene, è un tipo di sintassi e di costruzione che sento mio, e mi consente di essere maledettamente veloce (non ostante il male che se ne dice).



Come l'ho usato? elaborazione immagini, ahimè tanto tempo fa, e nella variante C# di recente a scrivere supervisori di impianto.



-- 

Ciao!

Luca


 nella loro sede.



torno a ribadire, è inutile ragionare di questi argomenti dal punto di

vista di chi le decisioni non le può prendere. se uno entra in una

banca come ultimo sviluppatore è ovvio che non tocchi a lui scegliere

come fare le cose e che quindi dovrà fare sempre e comunque quello che

gli viene detto di fare. non tutti lavoriamo nelle banche, o almeno io

non ci ho mai lavorato, si spera che almeno una volta nella vita ci si

sia trovati nella condizione di fare una scelta tecnologica di questo

tipo fosse anche per un progetto personale. e se non fosse mai

capitato almeno fare lo sforzo di mettersi in quei panni. altrimenti

di che si parla?




 famigerati gestionali, è molto più difficile, a mio parere.



Io ragiono al contrario: tanto più i requisiti cambiano e sono

ballerini, tanto più ho bisogno dei tests e della loro evoluzione di

pari passo con il codice.


 pari passo con il codice.



La struttura di MS per farli in automatico è incredibile : , tira su

la macchina virtuale, ci rilascia gli script ed il software,

automatizza il test e poi ti dice come è andato, magari anche in

ambienti eterogenei.



Bello, ma per il software che faccio io sarebbe impossibile.

Preferisco avere una struttura che renda la maggior parte dei test

inutile.



Inserimento, cancellazione e modifica dei dati non c'è bisogno di

testarla, una volta fatta deve andare per sempre.



Le elaborazioni devono essere a prova di errore, ovvero contenere al

loro interno una sorta di sefl-test che eviti gli errori più grossi.



Tutto, ma proprio tutto deve essere dichiarato e verificato a compile-

time. Niente di dinamico o indeterminato se non strettamente

necessario. In questo modo, una modifica alla base dati o ad una

classe evidenzia subito incongruenze o incompatibilità.



Poi ognuno cerca e trova il proprio metodo di lavoro, dipende da

linguaggio, da cosa si fa, da quanto ed un base a cosa ti pagano.




 pari passo con il codice.



Se i requisiti sono ballerini hai bisogno di un buon sistema di 

tracciabilità oltre che dei  test.


 classe evidenzia subito incongruenze o incompatibilità.



non voglio entrare nel merito dei requisiti del software che fai tu,

ma da quello che scrivi mi pare tu ululi alla luna... che vuol dire

"Tutto, ma proprio tutto deve essere dichiarato e verificato a compile-

time"? non usi variabili ma solo costanti? i metodi non hanno

parametri? le classi non hanno stati?

e poi dici: "Le elaborazioni devono essere a prova di errore, ovvero

contenere al loro interno una sorta di sefl-test che eviti gli errori

più grossi". a parte stai dicendo che le tue procedure contengono dei

controlli formali e per questo ti do atto che non sei proprio un

cialtrone :) ma la domanda è cos'è che garantisce che l'elaborazione

sia *effettivamente* a prova di errore se non, appunto, dei test che

coprono tutte le casistiche conteplate dai controlli? giusto per

capire, eh...










 si devono incastrare in architetture molto più grandi ed intangibili.



Non siamo in condizioni di trasparenza tale da poter tirare cifre con

molta precisione, tenendo poi presente che ci sono sempre state non

poche realtà che non ci tengono affatto a dichiarare cosa usano e

dove. Io più di qualche idea me la sono fatta negli ambienti che ho

visitato e dai resoconti altrui, e l'entità dei progetti è molto molto

varia. Ed oltretutto, come detto su non è nemmeno il caso di parlare

sempre di "progetto" nell'accezione monolitica, perchè più è complesso

e interessante il dominio e più sarà inevitabile affiancare il

mainstream all'esotico, il generalista allo specialistico e via

dicendo. Raccogliere delle info è piuttosto facile oramai, magari più

in ambiti come il web o la finanza/trading** che non la robotica (se

non hai/trovi contatti, ovviamente), volendo parlare di cifre nella

mia diretta esperienza andiamo dai tools e applicazioni anche

veramente minimali, a codebase specializzate su cui lavora magari un

singolo individuo (static analisys per altri linguaggi, ad esempio), a

progetti di media 70-80k SLOC fino alle codebase più ampie incontrate

che si attestano sui 200k SLOC. Ma più che le crifre, ripeto, è

interessante sapere il come il dove e il perchè. Se hai anche qualche

centinaio di migliaia di C++* che fa da infrastruttura/collector di

data e via dicendo e poi il number crunching che costituisce il core

del sistema è altrove, tanto possiamo parlare delle due entità

separatamente e ragionare su cosa rappresenta cosa (chi vorrebbe

lavorare all'infrastruttura quando è il core la parte eccitante e per

cui verrà "ricordato" il progetto?) e tanto possiamo guardare

all'insieme (e fare altre buone dovute considerazioni).



* a voler stare larghi e generici, che spesso nemmeno l'infrastruttura

stessa è monolinguaggio/monopiattaforma



** 
http://adtmag.com/articles/2011/07/29/why-hft-programmers-earn-top-salaries.aspx


    primo risultato a caso, tanto per.



Non conoscendo il mondo dei gestionali, immagino sia lo stesso

concetto di tracciabilità che si intende in logistica, giusto?



No intendo tracciabilità dei requisiti rispetto al sistema realizzato



http://en.wikipedia.org/wiki/Requirements_traceability



 capire, eh...



{P} C {Q}



... ovviamente era una battuta (nei gestionali intendo, altrove...)



Fantastico, tu pensa che il mio cervello ha fatto questo giro:

gestionale -> soldini -> "tracciabilità" (n.b. "alla governo Monti",

per giunta, che mi stanno avvelenando amici e parenti con sta cosa) ->

ma quindi del money? del prodotto venduto? mi sono detto.



Fortuna che una settimana ed è vacanza per un pò...



Riflettendoci per un attimo su, credo che siamo molto lontani dal

mondo dei gestionali in termini di spesa e fattibilità della cosa - o

c'è qualcuno che applica con successo metodi formali al tal proposito?

Intendo dire, (soprattutto per il piccolo sviluppatore) immagino si la

definizione di usa cases ma sinceramente non quella di test cases

completi, almeno non nei termini più rigidi e in uso nelle teorie

classiche di SE. Sbaglio?


 classiche di SE. Sbaglio?



Dipende anche da qual'e' il costo/rischio  finale di non gestire i 

requisiti.  Se ad esempio operi in un contesto dove sei ad alto rischio 

di contestazione ( a prescindere dalla dimensione) adottare queste 

strategie di SE (che chiaramente hanno un loro costo) riduce questo rischio.


 capire, eh...



lo garantisce la sua semplicità, l'atomicità dei passaggi, l'impiego

di istruzioni chiare e senza margine di errore. Per dire le regex

vanno benissimo per verificare una email ma non ci parserei o

verificherei certo una stringa piena di euro.



I test automatici io non sono mai riuscito ad usarli, a parte quelli

di regressione dove si creano interi scenari di dati, gli unit test

quelli della singola funzionalità non li capisco proprio, non capisco

cosa dovrei testare ovvero cosa non dovrebbe funzionare, ma confesso

di essere ignorante e forse non ne ho mai visti di fatti bene.













E operare in settori del genere (rischio elevato) nel campo dei

gestionali, che tu sappia è più o meno comune per i piccoli

sviluppatori italiani?


 di essere ignorante e forse non ne ho mai visti di fatti bene.



Questo potrebbe essere argomento di un altro thread: "problemi di

natura algoritmica e CRUD: e voi?".


 sviluppatori italiani?



Non conosco bene il settore dei gestionali; per la mia esperienza  manca 

spesso anche nelle grosse realtà il concetto di gestione del rischio.


 di essere ignorante e forse non ne ho mai visti di fatti bene.



dovrebbero testare che "la singola funzionalita'" sia implementata

correttamente e che non ci siano bug, semplice. Ed inoltre servono per

controllare che le future modifiche/estensioni del software non

rovinino qualcosa che prima funzionava. Ed inoltre ti aiutano ad

isolare e scovare bug e problemi. Ed inoltre ti aiutano a comprendere

come funziona il software se sei nuovo al progetto o ad una sua parte.

Ed inoltre ti spingono a vedere il software che scrivi dalla parte

dell' utilizzatore e non del creatore, per cui tendi a scrivere codice

piu' semplice da utilizzare. Ed infine ti possono anche aiutare a

scriverlo e diventare una tecnica di sviluppo se scrivi prima i test e

poi il codice da testare con il test driven development...

Ah equiVozio, avevo appena finito di dire in un altro thread che

oramai queste idee sono note pure ai muri e tu mi salti su

immediatamente per smentirmi? :) Ma allora lo fai apposta :)

Poi e' ovvio che anche degli unit test se ne puo' fare una fissazione

e una malattia, trasformadoli da strumento utile se usato con buon

senso a "culto inutile o addirittura dannoso".. ma questo tipo di

degenerazione e' ovviamente possibile per ogni tipo di tecnica..


 natura algoritmica e CRUD: e voi?".



Aprilo. Può essere interessante.




 immediatamente per smentirmi? :) Ma allora lo fai apposta :)



si si, tutto bello e tutta ok la teoria la conosco. Solo che la

pratica continua a sfuggirmi, ma non ne faccio un dramma.




 free evaluation o essere lazy



mmm.. in che senso non puo' essere lazy?


 pratica continua a sfuggirmi, ma non ne faccio un dramma.



beh magari semplicemente perche' non ti e' mai capitato di lavorarci

sopra ma hai solo sentito delle parole..

Non e' sicuramente un dramma, ma e' un peccato non aver aver un

"apprezzamento" per una tecnica cosi' utile e cosi' diffusa.. poi

magari uno sceglie comunque di non usarla ma almeno fa una scelta

ragionata..



Fa deferred execution e solo relativa a specifici meccanismi, con lazy

evaluation si intende altro e da molto tempo (penso dagli anni '70 ma

non ne sono sicuro, forse prima). La documentazione MS è precisa al

riguardo, gli entusiasti in giro che dai blogs "LINQ is Lazy!" non

altrettanto. Anche in C# puoi fare parzialmente del lazy (es. Lazy(T)

spiegato da Petricek, uno dei tipi dietro F#), idem ad esempio Python

(es. itertools) ma questo non li qualifica come "lazy".


 di essere ignorante e forse non ne ho mai visti di fatti bene.



eppure secondo me ci sei quasi. gli unit test ad esempio si basano sul

principio di eseguire la singola unità di codice (la funzione o il

metodo di una classe) in ambiente noto, collaboratori noti, con dati

di input noti e verificando che il risultato sia quello desiderato,

success o failure che sia. stop. praticamente lo stesso tuo concetto

di "self-test" però ricondotto ad una condizione di fattibilità,

perché se a priori non sai quali sono i dati di input difficilmente

(salvo elementari e imho inutili casi) puoi scrivere un test di

verifica correttezza dell'oputput.




 verifica correttezza dell'oputput.



boh, fammi un esempio reale, magari in un altro 3d e discutiamone di

test.






 riguardo



Ma anche no:   :)

http://msdn.microsoft.com/en-us/library/bb943859.aspx


http://msmvps.com/blogs/jon_skeet/archive/2010/03/25/just-how-lazy-are-you.aspx




ora, a me le questioni "terminologiche" e di lana caprina interessano

meno di zero, pero' mi pare che l' affermazione "Linq non puo' essere

lazy" mi sembra un po' "avventurosa".. per come la vedo io al momento

quando Linq usa tecniche come yeld return si puo' a buon diritto

definire lazy, ma se mi puoi spiegare perche' questo non e' vero sono

tutto orecchi..


 sopra ma hai solo sentito delle parole..



è la prima cosa che ho scritto. Sarei felice di vederla applicata su

un progetto "serio", ma non mi è mai capitata.


 tutto orecchi..



Postando links trovati alla bisogna e senza averli letti non dimostri

nulla se non che... non li hai letti.



"I don't believe lazy is a useful term, basically. It's like "strong

typing" - you get some sort of woolly feeling about how something will

behave if it's lazy, but chances are you'll need something more

precise anyway.



For the purposes of LINQ to Objects-style operators which return

IEnumerable<T> or any interface derived from it (including

IOrderedEnumerable<T>), I propose the following definitions:"



E il buon Skeet prosegue infatti parlando *dell'implementazione* di

LINQ e disquisendo della definizione di lazy nell'ambito di quelle

precise operazioni.



"is Enumerable.Reverse lazy?" si chiede, e non "is LINQ lazy?" come

vedi.



In ultimo, *a te* certe questioni non interesseranno, perchè si è

capito che parli e butti links giusto per flammare (e ti vien pure

male, come vedi). Ad altri, interessano eccome. Infatti in chiusura:



"Why does this matter?



Is this just another example of my pedantry and desire for precision?

Not really." e prosegue.



Lasciale perdere certe questioni, meglio se torni ai flames che ti

vengon meglio.


 test.



beh oltre un certo limite la consulenza si paga... :p



comunque:



public testCheckGoodPin() throws Exception {

   assertTrue(instanceToTest.checkPin(goodPin));

}

public testCheckBadPin() throws Exception {

   assertFalse(instanceToTest.checkPin(badPin));

}

public testCheckNullPin() throws Exception {

   assertFalse(instanceToTest.checkPin(null));

}

public testCheckHugePin() throws Exception {

   assertFalse(instanceToTest.checkPin(hugePin));

}

# continua con altri casi




 mignolo...



Proprio per niente, la regexp che ho postato fa esattamente quello che

hai chiesto, e come detto l'ho fatta in un niente.

Il fatto che per qualche motivo per te le espressioni regolari siano

"inaffidabili" non significa che lo siano davvero, sono uno strumento

come un altro per fare il parsing delle stringhe, molto piu' duttile

di metodi/funzioni specifici come quelle che hai usato tu. Ad esempio,

anziche' usare left/right/substr sullo stesso input una regexp ti

permette di fare un singolo passaggio generico, e con un controllo sul

formato che non richiede cast vari ed assortiti nel caso la stringa

non sia nel formato voluto (e scartando la prima parte della stringa a

prescindere, piuttosto che assegnandola ad una variabile, ma quello mi

sembra un typo).

Poi, se mi dici che la sintassi e' ostica e serve mettersi un po' di

buona lena per impararle e' un altro conto e posso anche essere

d'accordo, ma nel 2012 mettersi a discutere delle regexp anche no.

Quella che poi tu chiami gestione dell'errore e' un semplice catch

all, che puo' essere implementato in qualunque linguaggio e che non e'

certo compito dell'espressione regolare, che appunto fa solo il

parsing della stringa e niente piu'.

Nel tuo pseudo-codice i test non servono casomai perche' e' talmente

semplice che e' difficile sbagliare, e per il fatto che e' una

funzione pura, ma non vedo altre motivazioni reali. Ad esempio nel tuo

caso potresti voler distinguere un type mismatch da un errore di

parsing, cosa che ha perfettamente senso nel momento in cui l'output

deve essere differente in caso di eccezioni differenti.



  ngw


 capito che parli e butti links giusto per flammare



flammare? buttare link? Io ti ho fatto una domanda "serenissima"

perche' ho letto un 'affermazione che in base a quel pochino che so mi

sembrava un po' "buttata li'"...e con nessuno spirito di polemica o di

presa in giro (credimi , quando voglio prendere per il culo qualcuno

si vede, eccome :), perche' mi davi l impressione di una persona

valida e ragionevole da cui magari si puo' imparare qualcosa.. e al

tuo cattedratico "la documentazione ms e' precisa al riguardo" ti ho

mostrato due link che provano l'esatto contrario... Putroppo mi tocca

constatare che sei un' edizione meno astiosa e disgustosa del

"professorino malato", ma la sostanza e' quella :)


 che va piu' a genio..



Puerile quest'ultimo disperato tentativo di far passare _me_ per _te_,

davvero.



Non perdiamo altro tempo inutilmente. Se mai volessi capirne di strict

e lazy programming, della differenza tra i limitati meccanismi lazy in

Python/C#/LINQ o che altro e i linguaggi come Miranda, Haskell e

Clean, hai da studiare. Consigli:



http://mitpress.mit.edu/catalog/item/default.asp?tid=5109&ttype=2


http://mitpress.mit.edu/catalog/item/default.asp?ttype=2&tid=4310


oltre ai soliti Programming Language Pragmatics e testi di base del

genere



Oltretutto, il tuo goffo tentativo di parlare di argomenti di cui

ignoravi l'esistenza fino a prima di questi stessi posts è ancora più

evidente se mi riporti un post di Jon Skeet (esperto di C# e Java),

quando avresti dovuto semmai citarmi Don Syme, Petricek e compagnia

(tanto per restare in ambito Microsoft da cui siamo partiti) che su

questi argomenti ci stanno spendendo una carriera in sia in produzione

che in ricerca e che ne discutono continuamente essendo i resident-

experts di casa MS. Visto che ci sei, leggi anche i loro libri che ti

fa bene:



Real World Functional Programming: With Examples in F# and C#

Expert F#

...



Non so se l'hai capito, ma io in questo settore attualmente ci lavoro

- benvenga la discussione, ma se ogni volta mi parti con l'ormai

telefonato post attaccabrighe senza contenuto, con me non vai lontano.


 con me non vai lontano.



non ti preoccupare, ci ho messo un po', ma che con te "non si va

lontano" si e' capito benissimo :)


 "lontana".



Il discorso è norevolmente interessante. Stavo pensando che, per quel

che mi risulta, ad oggi i principali sistemi operativi sono scritti in

C-C++, comprese le loro "appendici", tipo drivers di periferica (non

mi risulta però che ci siano drivers scritti in Haskell o Ocaml o

Lisp, non perchè non ne siano potenzialmente capaci, ma tanto è).

Questi linguaggi, per dirne una, usano un loro sistema di allocazione

delle variabili in memoria. Consegue che, se vuoi interagire con

queste funzionalità di sistema (es. col driver di una specifica

webcam) devi necessariamente, obbligatoriamente adeguarti a quel tipo

di allocazione. Cosa banale se ti interfacci ancora da C/C++, oppure

C#, magari Delphi, Pascal, VB... Ma molto più complicata se lo fai da

Lisp od Ocaml (questo lo so per certo, visto che mi sto cimentando nel

chiamare funzioni stile C da Ocaml, e viceversa), perchè questi hanno

una gestione delle variabili in memoria molto differente. Quindi se

l'architettura di riferimento (s.o., drivers, applicazioni

fondamentali come il dbms) è costruita in un certo modo (es. su

standard C-C++) è ben difficile che ci sia vera convenienza  a

scrivere software importanti usando differenti standard. Cioè

un'attenta analisi non potrebbe che confermare quello che uno può

sentire "a naso".

Ciò mi fa venire la domanda: qualcuno si è posto l'obiettivo di

scrivere un intero s.o. in Haskell, Ocaml, Lisp? O magari un intero

dbms, un CAD, un wordprocessor.






 classe evidenzia subito incongruenze o incompatibilità.



Allora devi iniziare ad usare Ada, che tra i linguaggi (più o meno)

tradizionali è uno di quelli più efficaci nel trovare bug in

compilazione. Dopo puoi passare ad un brillante funzionale, tipo

Haskell, Ocaml, F#, che sono strettamente tipizzati (ma con inferenza

automatica del tipo, ovvero, nonostante la stretta tipizzazione, al

90% non dichiari le variabili, al contrario di altri linguaggi).




 di che si parla?



Magari si può parlare del fatto che si può essere produttivi, ed anche

molto, muovendosi agilmente e senza disagio particolare in sistemi in

ampia parte predeterminati, nel senso suddetto.


 90% non dichiari le variabili, al contrario di altri linguaggi).



no, è imho negativo che non debba essere dichiarato subito il tipo

della variabile. Bene che il programmatore dichiari quel che ha

intenzione di fare prima di farlo, ed un modo è fargli scrivere il

tipo delle variabili.


 tipo delle variabili.



Francamente dichiarare quello che è automaticamente deducibile mi

sembra spreco di tempo (comunque se vuoi puoi sempre dichiarare

esplicitamente i tipi, mica è vietato).

In quei linguaggi la dichiarazione è implicita nella definizione e

corpo della funzione. Se non sei convinto, posso solo invitarti a fare

qualche prova per es. con F#.




 qualche prova per es. con F#.



Provato e scritto applicazioncina con python, carino, è molto

divertente scrivere codice con la sua sintassi ma non ho trovato

nessun vantaggio rispetto ad altri linguaggi. Per quanto riguarda

invece il software professionale per me i programmatori, me compreso,

meno libertà hanno a parità di possibilità e meglio è.




 dbms, un CAD, un wordprocessor.



Se il netto di quello che vuoi dir è che è più facile far dialogare

tra loro linguaggi di discendenza Algol e Fortran che non provenienti

da rami diversi, questo è vero quanto scontato. Non solo tecnicamente

ma soprattutto per via del mare di soldi che sono stati investiti in

quella direzione in decenni di sviluppo - lo stesso non si può dire

per l'altra parte.

La programmazione è un'attività *sociale* prima ancora che tecnologica/

creativa/scientifica/_placeholder.

Piuttosto che chiedersi astrattamente chi si pone quale obiettivo e in

quale linguaggio, prova ad osservare la realtà "sociale" dello

sviluppo software. Io ci ho trovato più risposte di quel che pensavo

davvero.



Queto è type inference (Haskell)



f :: Integer -> Integer -> Integer

f x y = x + y



prompt> f 2 3

5

prompt> f 2 3.0

No instance for (Fractional Integer)

      arising from the literal `3.0'

    Possible fix: add an instance declaration for (Fractional Integer)

    In the second argument of `f', namely `3.0'

    In the expression: f 2 3.0

    In an equation for `it': it = f 2 3.0



f x y = x + y



prompt> f 2 3

5

prompt> f 2.0 3.0

5.0



Questo è dynamic typing (Python):



def f(x, y): return x + y



prompt> f(2, 3)

5

prompt> f(2, 3.0)

5.0

prompt> f("o", "k")

'ok'

prompt> f(2, "string")

TypeError: unsupported operand type(s) for +: 'int' and 'str'





Posso sapere come sei saltato dalla type inference di F# a Python? In

comune hanno giusto che è sintatticamente legale scrivere "var = 9" in

entrambi, la semantica associata è completamente differente.



Parlare di Python e poi far seguire "Per quanto riguarda invece il

software professionale per me i programmatori" che significherebbe di

preciso?


 entrambi



... stavo ancora pensando in Haskell, in F# è:



let var = 9






Equinozio come me lavora in ambiente MS, in C# si può usare sia var per la 

type inference che dynamic per il dynamic typing.

Ovviamente si riferiva all'uso di dynamic quando parlava di pericolisità per 

lo sviluppatore.






 "cpascoshi" ha scritto nel messaggionews:a75a7f88-1a8f-4b2b...@u11g2000vbm.googlegroups.com...


Non ho capito, dato un invito a provare un linguaggio della famiglia

ML dotato di type inference, si risponde di aver provato Python e il

motivo di questo sarebbe perchè si conoscono le keywords "var" e

"dynamic" in C#?




Parlavi di semantica e var e dynamic quella c'hanno di semantica, con la 

seconda che c'azzecca un'h con la prima e che è come, detto, una bomba ad 

orologeria.

Il rif. a Python fatto io l'ho letto come generico e non in risposta alla 

presunta non distinzione tra il senso di var e quello di dynamic.




 "cpascoshi" ha scritto nel messaggionews:1903f533-64da-4ef5...@y3g2000vbn.googlegroups.com...


O-k. Ora però, visto che l'invito di ispas era provare un linguaggio

di tipo ML che usa la type inference (e relativa sorprendente risposta

"Python"), possiamo tornare a parlare di questo e non dell'eventuale

esperienza con la limitata keyword "var" di C#?



Al solito, l'invito penso fosse per scoprire qualcosa di nuovo e non

ricondurre sempre tutto a quello che già si sa (mi si corregga se

sbaglio).



p.s. No, le parziali features di C# al riguardo non sono sufficienti

per poter dire di aver usato type inference e dynamic typing nel

disegnare programmi e algoritmi - del resto, se uno mi chiede di fare

un pò d'esperienza di oop, io gli consiglio l'object model di C# e non

le type classes di Haskell (che appunto ti aiutano solo parzialmente a

mettere in pratica le idee portanti dell'OO).


 esperienza con la limitata keyword "var" di C#?



Cioè praticamente ci stai rimproverando per essere usciti OT rispetto

al 3d ?



Credo sia la prima volta che lo vedo fare in ili, ma ben venga !





Ma lol no di certo (anche perchè nun me pare proprio!), piuttosto

stavo dicendo al tuo avvocato che la citazione di C# non è che

aggiungesse granchè alla direzione presa dal ramo in questione, ci

distrae piuttosto dal vero obiettivo :).






:-) Guarda che i post mica sono da parsare e compilare.... :-)

Ripeto che visto il thread e il numero di messaggi inviati, il discorso che 

ho fatto ci stava tranquillamente, e che il riferimento a python era 

ovviamente da intendersi a livello generale e non giusto come risposta di 

aver provato la type inference.

Ma se vuoi compilare i singoli post, togli qualche flag per non ottimizzare 

troppo, ok? :-D






 :-) Guarda che i post mica sono da parsare e compilare.... :-)



Si ma almeno abbiate pietà della logica :)