Quanto è importante l'età per chi inizia? [Archivio] - Pagina 3

by_to_by

14-06-2008, 00:42

Sì e penso sinceramente che dipenda dal nervosismo, perchè ho avuto, anche se in altri ambiti, il problema di sentirmi "non in crescita", senza miglioramenti, e l'unico modo per risolverlo è stato allenare la tensione su me stesso.

Non ne parliamo proprio se, come nel tuo caso, stai portando avanti la programmazione a livello per ora solo di hobby: mai e poi mai mettersi sotto pressione per un hobby anche perchè, come minimo, dopo due mesi rischi di stufarti.

Un altro consiglio che mi sento comunque di darti e di non lasciarti alle spalle lacune: ogni volta che c'è qualcosa che non capisci a fondo non darlo per scontato, perchè più buchi collezioni e più il tuo sapere, alla fine, sarà qualcosa di simile a una forma di groviera.
Quando hai qualche dubbio, posta sul forum o cerca su altri manuali, o magari su google: se non capisci qualcosa, abbi il coraggio di fare un passo indietro e tornare "alla radice", anche se questo significa rileggere il capitolo 1 quando sei già arrivato al capitolo 29. Non è una vergogna, anzi, io lo faccio spessissimo ;)

è incredibile, ma hai scritto la mia storia praticamente. fino a questa mattina ho dovuto riprendere in mano un capitolo vecchio perchè avevo dubbi... però non so.. sai cosa è? è come se ho paura di imparare, di leggere il testo di un esercizio perchè penso (tanto non lo saprò fare). poi leggo di ragazzi che fanno programmi a un ritmo da paura e sono giovanissimi (un esempio del quale ho letto qua sul forum è un certo ctrl_alt_canc o una cosa del genere) e molti altri ragazzi come salvatore aranzulla. io vorrei tanto diventaare un grande programmatore, però a vedere che loro sono anni più giovani e hanno anni di esperienza in più di me mi sento una nullità.. è una sensazione da schifo

cdimauro

14-06-2008, 05:19

scusami eh, ma tutte queste cose dove le hai imparate? esperienza lavorativa o autodidatta? e tutti questi linguaggi che sai (programmare un gioco in assembly, ho sempre ritenuto delle leggende metropolitane che ci fossero persone che programmassero completamente in assembly visto che sembra un linguaggio alieno) dove li hai appresi? lavoro? autodidatta? corsi?
Autodidatta principalmente. Ma erano altri tempi: adesso non consiglierei di programmare in assembly al mio peggior nemico. :p
ohibò, pare che la casella email di cdimauro abbia trovato un nuovo mittente anonimo :asd:
:rotfl:
In certi ambiti è un must, e si va direttamente attraverso l'assembly. All'epoca mi sa che era per questioni puramente tecniche. :D
Prestazionali, per la precisione. Oggi l'assembly viene usato pochissimo, e... per fortuna. :p
un must? ma assembly è difficilissimo da imparare, imho
Dipende dall'architettura: quella Motorola 68000 era molto semplice, sebbene internamente fosse complessa (infatti il 68000 era un mostro di CPU quando è nato: ben 68000 transistor impaccati per un chip realizzato alla fine degli anni '70 era notevole).
dovrebbe inserire un counter auto-aggiornante in sign :O

:asd:
Andrebbe in overflow. :asd:
quello 68000 era il + semplice e lineare tra quelli che ho studiato...
anche se in effetti non è che ci voglia poi tanto dato che le altre architetture per cui ho scritto qualcosina sono l'x86 e la SPARC :p
Ovviamente non ho mai fato nulla al livello di quello di Cesare con quei linguaggi ;)
Sì, infatti. Anche se, comunque, dal 68020 in poi l'ISA è diventata abbastanza complessa (c'erano modalità d'indirizzamento "spaziali" e persino istruzioni per manipolare campi di bit), ma conservando sempre quell'eleganza e "ortonalità" che la rendevano di facile utilizzo.
non lo hai mai fatto perchè non ne hai avuto bisogno, lui invece si visto che lavorava per quell'azienda che sviluppava il gioco. comunque quello che mi chiedo è questo: per imparare linguaggi o tecniche nuove vi fanno dei corsi le aziende oppure fate tutto soli? perchè cdimauro ho visto che sa un sacco di linguaggi e programmare un gioco in assembly non è che sia una cosa facile. se adesso ad esempio dovessi farlo tu che non lo hai mai fatto, da dove partiresti?
Certamente non dall'assembly. Ripeto: erano altri tempi, e una macchina che funzionava a 7Mhz o la programmavi in assembly o le prestazioni scendevano in picchiata.

Oggi NON lo rifarei sicuramente (anche perché faccio altro :p), e preferirei un linguaggio di più alto livello.
non ci sono, sarà che sono stupido o sarà che non mi è chiaro come elabora i booleani python, ma comunque va bene. a me non mi è chiaro comunque return. a schermo non stampa niente e non so come passare il valore di ritorno ad una variabile o un'espressione
Occhio che i booleani in Python sono leggermente diversi (e molto più utili, a mio avviso) rispetto agli altri linguaggi.

Esempio:
>>> print 'pluto' and 'paperino'
paperino
>>> print 'pluto' or 'paperino'
pluto
>>> print '' or 'paperino'
paperino
>>> print '' and 'paperino'

Questo per gli operatori and e or, in particolare. Con quelli di confronto puoi andare tranquillo e restituiranno sempre il valore True o False (occhio alla prima lettera, che dev'essere maiuscola).

Altra cosa interessante, è il comportamento coi vari tipi di dato. Esempio:
>>> a = []
>>> if not a: print "Non c'e' niente qui!"
...
Non c'e' niente qui!
>>> a = ['Topolino']
>>> if a: print "Qualcosa c'e'..."
...
Qualcosa c'e'...
E con le stringhe:
>>> s = ''
>>> if not s: print "La stringa e' vuota!"
...
La stringa e' vuota!
>>> s = 'Topolino'
>>> if s: print "La stringa contiene qualcosa..."
...
La stringa contiene qualcosa...
è incredibile, ma hai scritto la mia storia praticamente. fino a questa mattina ho dovuto riprendere in mano un capitolo vecchio perchè avevo dubbi... però non so.. sai cosa è? è come se ho paura di imparare, di leggere il testo di un esercizio perchè penso (tanto non lo saprò fare). poi leggo di ragazzi che fanno programmi a un ritmo da paura e sono giovanissimi (un esempio del quale ho letto qua sul forum è un certo ctrl_alt_canc o una cosa del genere) e molti altri ragazzi come salvatore aranzulla. io vorrei tanto diventaare un grande programmatore, però a vedere che loro sono anni più giovani e hanno anni di esperienza in più di me mi sento una nullità.. è una sensazione da schifo
Zitto e lavora! :D

Dai che con un po' di smanettamento ed esperienza vedrai che anche per te si apriranno le porte della programmazione. ;)

71104

14-06-2008, 08:38

(un esempio del quale ho letto qua sul forum è un certo ctrl_alt_canc o una cosa del genere) ti riferisci a questo ctrl_alt_canc (http://ctrlaltcanccorp.altervista.org/)? pietà, è un poveretto :asd:

per carità, alcuni di quei programmetti sono molto utili, nulla da dire :D ma sono talmente semplici che piuttosto che scaricarli preferisco rifarmeli da solo ;)

e molti altri ragazzi come salvatore aranzulla. :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl:

e aggiungo: :rotfl:

by_to_by

14-06-2008, 11:27

Autodidatta principalmente. Ma erano altri tempi: adesso non consiglierei di programmare in assembly al mio peggior nemico

tutto da autodidatta? mamma mia.. sei un genio per me...

Occhio che i booleani in Python sono leggermente diversi (e molto più utili, a mio avviso) rispetto agli altri linguaggi.

Esempio:

>>> print 'pluto' and 'paperino'
paperino
>>> print 'pluto' or 'paperino'
pluto
>>> print '' or 'paperino'
paperino
>>> print '' and 'paperino'

Questo per gli operatori and e or, in particolare. Con quelli di confronto puoi andare tranquillo e restituiranno sempre il valore True o False (occhio alla prima lettera, che dev'essere maiuscola).

Altra cosa interessante, è il comportamento coi vari tipi di dato. Esempio:

>>> a = []
>>> if not a: print "Non c'e' niente qui!"
...
Non c'e' niente qui!
>>> a = ['Topolino']
>>> if a: print "Qualcosa c'e'..."
...
Qualcosa c'e'...

E con le stringhe:

>>> s = ''
>>> if not s: print "La stringa e' vuota!"
...
La stringa e' vuota!
>>> s = 'Topolino'
>>> if s: print "La stringa contiene qualcosa..."
...
La stringa contiene qualcosa...

1) Perchè ritorna quei risultati? (parlo dell'or e and)

2)confronto intendi ==? e perchè la prima lettera deve essere grande? inoltre perche and e or non restituiscono vero o falso?

ti riferisci a questo ctrl_alt_canc? pietà, è un poveretto

per carità, alcuni di quei programmetti sono molto utili, nulla da dire ma sono talmente semplici che piuttosto che scaricarli preferisco rifarmeli da solo

si a lui, a me sembrano difficili quei programmi...

e aggiungo:

perchè non è bravo aranzulla?

DanieleC88

14-06-2008, 11:36

2)confronto intendi ==? e perchè la prima lettera deve essere grande? inoltre perche and e or non restituiscono vero o falso?
Il confronto è quello, le lettere maiuscole suppongo siano imposte dalla sintassi di Python, and e or invece Cesare ha detto proprio che restituiscono sempre True o False. ;)
1) Perchè ritorna quei risultati? (parlo dell'or e and)
Questa è un po' più difficile da spiegare. Allora:
>>> print 'pluto' and 'paperino'
paperino
Qui Python ha un and: perché la valutazione dia True, è necessario che entrambe siano True. Siccome 'pluto' è una stringa non vuota, ha come valore True, e allora può stampare 'paperino'.
>>> print 'pluto' or 'paperino'
pluto
Stesso discorso di prima, con la differenza però che all'operatore or basta che una delle due espressioni sia vera: quindi valuta 'pluto', la trova vera (valida), la stampa.
>>> print '' or 'paperino'
paperino
Esattamente come l'ultimo esempio. Però stavolta la prima stringa è vuota, e viene valutata come False, quindi Python passa alla valutazione della seconda: la trova valida, la stampa.
>>> print '' and 'paperino'

Questa funziona come la prima, però l'operatore and ha bisogno che entrambe siano True: la stringa vuota '' viene valutata come False e la stampa non viene effettuata.

Se ho detto baggianate, invoco la pietà tua e di cdimauro! :D

by_to_by

14-06-2008, 11:39

Il confronto è quello, le lettere maiuscole suppongo siano imposte dalla sintassi di Python, and e or invece Cesare ha detto proprio che restituiscono sempre True o False. ;)

Questa è un po' più difficile da spiegare. Allora:
>>> print 'pluto' and 'paperino'
paperino
Qui Python ha un and: perché la valutazione dia True, è necessario che entrambe siano True. Siccome 'pluto' è una stringa non vuota, ha come valore True, e allora può stampare 'paperino'.
>>> print 'pluto' or 'paperino'
pluto
Stesso discorso di prima, con la differenza però che all'operatore or basta che una delle due espressioni sia vera: quindi valuta 'pluto', la trova vera (valida), la stampa.
>>> print '' or 'paperino'
paperino
Esattamente come l'ultimo esempio. Però stavolta la prima stringa è vuota, e viene valutata come False, quindi Python passa alla valutazione della seconda: la trova valida, la stampa.
>>> print '' and 'paperino'

Questa funziona come la prima, però l'operatore and ha bisogno che entrambe siano True: la stringa vuota '' viene valutata come False e la stampa non viene effettuata.

Se ho detto baggianate, invoco la pietà tua e di cdimauro! :D

hai ragione invece riflettendoci, sei un grande e pensare che nemmeno lo conosci python

DanieleC88

14-06-2008, 11:41

e pensare che nemmeno lo conosci python
A parte che ancora non ho la conferma di cdimauro, sono andato a logica, ma per il semplice motivo che un funzionamento simile di quegli operatori lo conosco a causa del C. Non c'è niente di trascendentale, tranquillo. ;)

by_to_by

14-06-2008, 11:44

credimi, è cosi. può essere solo così per logica..

comunque prima cdimauro ha detto che il confronto restituisce sempre ture o false e poi ha fatto gli esempi specifici per and e or

DanieleC88

14-06-2008, 11:52

Ah no scusa, lui parlava di quelli di confronto... be', se tu hai un numero x e vuoi valutare x == 10, questa ti darà sempre e solo True (se x è uguale a 10) o False (se è diverso).

DioBrando

14-06-2008, 12:03

:rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl: :rotfl:

e aggiungo: :rotfl:

La dico con la drammaticità degli spagnoli "Maaaaadre miaaa que pena!"
:asd:

Il problema non è dei ragazzini rampanti e smanettoni. Ci sono sempre stati anche se ora sn notevolmente facilitati.

Il problema è dei mass media che da ignoranti in materia osannano personaggi come "esperti in sicurezza" (che poi finiscono con l'autodefinirsi tali) per avere pubblicato due vulnerabilità di tipo XSS (Cross-Site Scripting per i neofiti) sul sito di Google e Poste.it, conosciutissimi per carità, ma grazie ad exploit già da tempo noti.
D'altra parte se si riesce ad avere un seguito di migliaia e migliaia di lettori al mese che ringraziano consigli che fanno parte di un qualsiasi utente appena smaliziato, evidentemente la conoscenza media in materia, in Italia, è drammaticamente bassa.

Prendere ad esempio persone del genere, se si vuole fare gli sviluppatori, non è una grande idea.

~FullSyst3m~

14-06-2008, 12:04

Ah no scusa, lui parlava di quelli di confronto... be', se tu hai un numero x e vuoi valutare x == 10, questa ti darà sempre e solo True (se x è uguale a 10) o False (se è diverso).

Infatti, poi mi sembra che qualche pagina fa glielo hanno già spiegato in modo più approfondito questo argomento

ammettiamo che x = 10 e y = 6

se fai 10%6 ti ritorna 4 convieni con me?

Ora python passa a valutare quel quattro e cioè fa:

4 == 0 quel == è da intendersi come l'uguale matematico diverso dal = singolo che è l'operatore di assegnamento!

Convieni con me che 4 == 0 è false?

ecco ora pyrhon ritorna il false e cioè:

return false

e per usare quel false come fai?

prendi dentro al tuo bel main una variabile div e fai:

div = divisibile(x,y)
ora quella variabile div contiene il valore false ritornato dalla funzione divisibile(x,y)

k0nt3

14-06-2008, 12:05

Occhio che i booleani in Python sono leggermente diversi (e molto più utili, a mio avviso) rispetto agli altri linguaggi.

Esempio:
>>> print 'pluto' and 'paperino'
paperino
>>> print 'pluto' or 'paperino'
pluto
>>> print '' or 'paperino'
paperino
>>> print '' and 'paperino'

Questo per gli operatori and e or, in particolare. Con quelli di confronto puoi andare tranquillo e restituiranno sempre il valore True o False (occhio alla prima lettera, che dev'essere maiuscola).

OMG :eek: ! che orrore.. 'pluto' or 'paperino' = 'pluto'? e perchè non 'giucas casella'?

DanieleC88

14-06-2008, 12:10

e perchè non 'giucas casella'?
Perché quello avviene solo quando lo dico io! :Prrr:

by_to_by

14-06-2008, 12:15

La dico con la drammaticità degli spagnoli "Maaaaadre miaaa que pena!"
:asd:

Il problema non è dei ragazzini rampanti e smanettoni. Ci sono sempre stati anche se ora sn notevolmente facilitati.

Il problema è dei mass media che da ignoranti in materia osannano personaggi come "esperti in sicurezza" (che poi finiscono con l'autodefinirsi tali) per avere pubblicato due vulnerabilità di tipo XSS (Cross-Site Scripting per i neofiti) sul sito di Google e Poste.it, conosciutissimi per carità, ma grazie ad exploit già da tempo noti.
D'altra parte se si riesce ad avere un seguito di migliaia e migliaia di lettori al mese che ringraziano consigli che fanno parte di un qualsiasi utente appena smaliziato, evidentemente la conoscenza media in materia, in Italia, è drammaticamente bassa.

Prendere ad esempio persone del genere, se si vuole fare gli sviluppatori, non è una grande idea.

tanto stupido non deve essere visto che ne ha trovate un sacco di queste vulnerabilità, anche nei siti come il muro.it, collabora con un sacco di riviste e ha pubblicato 3 libri. inoltre fa conferenze ed è andato in radio pure e forse in tv. gli hanno spostato il blog su non mi ricordo quale sito, prende un sacco di soldi ed è giovanissimo. vi sembra poco? anche a conoscere XSS non è facile trovare le vulnerabilità. oltretutto sa anche programmare con un pò di linguaggi e scrivi exploit a tempo record sui buchi che trova. a me non sembra poco scusate

~FullSyst3m~

14-06-2008, 12:28

sulla stessa homepage, sulla schermata del programma audio monitor, guardate come scrive input!:doh:

si presenta subito bene...:O

:asd:

marco.r

14-06-2008, 12:54

OMG :eek: ! che orrore.. 'pluto' or 'paperino' = 'pluto'? e perchè non 'giucas casella'?

perche' giucas casella non e' ne' pluto ne' paperino.
Mentre pluto E' pluto o paperino.

71104

14-06-2008, 13:21

perche' giucas casella non e' ne' pluto ne' paperino.
Mentre pluto E' pluto o paperino. :fagiano:

wingman87

14-06-2008, 13:28

perche' giucas casella non e' ne' pluto ne' paperino.
Mentre pluto E' pluto o paperino.
Ma quindi fa un random tra i due?

~FullSyst3m~

14-06-2008, 13:38

Ma quindi fa un random tra i due?

Yes :cool: (risposta idiota scherzosa)

No, 'pluto' e 'paperino' sono tutte e due vere, quindi dovendo scegliere o uno o l'altro, quando il pitone incontra 'pluto', essendo vero, ritorna 'pluto', che è la prima stringa vera che incontra (risposta seria). Capito?

DanieleC88

14-06-2008, 13:40

:wtf:

~FullSyst3m~

14-06-2008, 13:53

:wtf:

Che succede?? Confuso??

DanieleC88

14-06-2008, 13:55

Non credo sia random. :stordita:

~FullSyst3m~

14-06-2008, 13:59

Yes :cool: (risposta idiota scherzosa)

No, 'pluto' e 'paperino' sono tutte e due vere, quindi dovendo scegliere o uno o l'altro, quando il pitone incontra 'pluto', essendo vero, ritorna 'pluto', che è la prima stringa vera che incontra (risposta seria). Capito?

;)

DanieleC88

14-06-2008, 14:01

Ecco bravo, ora va meglio. :D

~FullSyst3m~

14-06-2008, 14:06

Ecco bravo, ora va meglio. :D

Non avevo capito se scherzavano o dicevano sul serio, cosi ho editato e scritto tutte e due le ramificazioni! :D

marco.r

14-06-2008, 15:20

:fagiano:
Non e' una questione banale :p.
"or" e' un concetto che vale non solo nelle proposizioni booleane e quindi non e' necessariamente detto che la risposta corretta a "paperino or pluto" sia solo "True". Anzi, se la domanda e' "quale e' il cane di Topolino" la risposta "paperino or pluto" non vuol dire "True".
In un linguaggio di programmazione, diventa un metodo molto pratico per dire "dammi il primo dei due (o piu', se il linguaggio lo consente) che e' valido".

~FullSyst3m~

14-06-2008, 16:07

Non e' una questione banale :p.
"or" e' un concetto che vale non solo nelle proposizioni booleane e quindi non e' necessariamente detto che la risposta corretta a "paperino or pluto" sia solo "True". Anzi, se la domanda e' "quale e' il cane di Topolino" la risposta "paperino or pluto" non vuol dire "True".
In un linguaggio di programmazione, diventa un metodo molto pratico per dire "dammi il primo dei due (o piu', se il linguaggio lo consente) che e' valido".

Infatti, come ho scritto io:

'pluto' e 'paperino' sono tutte e due vere, quindi dovendo scegliere o uno o l'altro, quando il pitone incontra 'pluto', essendo vero, ritorna 'pluto', che è la prima stringa vera che incontra

DioBrando

14-06-2008, 16:18

tanto stupido non deve essere visto che ne ha trovate un sacco di queste vulnerabilità, anche nei siti come il muro.it, collabora con un sacco di riviste e ha pubblicato 3 libri. inoltre fa conferenze ed è andato in radio pure e forse in tv. gli hanno spostato il blog su non mi ricordo quale sito, prende un sacco di soldi ed è giovanissimo. vi sembra poco? anche a conoscere XSS non è facile trovare le vulnerabilità. oltretutto sa anche programmare con un pò di linguaggi e scrivi exploit a tempo record sui buchi che trova. a me non sembra poco scusate

Io non ho detto sia stupido, tutt'altro.
Altrimenti non sarebbe riuscito a trasformare in business un'attività come quella di provare qualche exploit noto in siti di rilevanza nazionale/internazionale e poi essere idolatrato dagli organi di informazione sconvolti dal fatto che un teenager al giorno d'oggi possa fare queste cose.
Ho detto semplicemente che uno che passa come esperto di sicurezza informatica, programmatore ecc. ecc. una persona del genere è il sintomo di qualcosa che non funziona nella nostra società e cioè molto semplicemente che siamo indietro anni luci come cultura informatica.
Tra le riviste ce ne sono di tecniche che si occupino di sviluppo/tool/linguaggi di programmazione? E le conferenze davanti a quale pubblico?
Mi ricordo parecchio tempo fa' un articolo dove si era cercato di portarlo all'Università di Camerino ma poi davanti alla prospettiva di parlare davanti ad universitari/programmatori si era praticamente eclissato.

I 3 libri a cui ti riferisci, sono uno la collezione di articoli del blog (basta tradurre quello che trovi nella rete e ne scrivi quanti ne vuoi), uno la sicurezza di cui ho parlato nel post precedente e terzo, la perla, un libro per "scrivere pagine ASP": praticamente una collezione di azioni fatte con un ambiente RAD e con codice relativo pubblicato, ovvero ti disegno una tabella e poi ti faccio vedere il sorgente.
Difficile eh, ci vuole un fenomeno di programmatore :asd:

Prova a leggere qualche libro della serie Apress su ASP.NET poi mi sai dire quale sia un testo di possibile utilizzo e quale no.

La riprova del fatto che siamo veramente un caso unico è che non esiste alcuno altro Paese industrializzato nel G8 che annovera fenomeni del genere, dove uno X finisce a fare una trasmissione "Pirati" con Belen Rodriguez (zappando me lo sn beccato l'altro giorno). Pirati?! What??
Negli States ci sono i 16enni che violano siti governativi, o altri come DVDJon, di cui possiamo discutere dal punto di vista educativo cosa possano rappresentare ma sulle cui capacità sono spanne sopra gli Aranzulla di turno.
Ci sono poi blog simili remunerativi, anzi il fenomeno è partito dagli USA (istartedsomething per esempio) ma nessuno di questi si professano "esperti in materia di sicurezza informatica" perchè verrebbero derisi da sviluppatori, pentesters ecc. ecc.

Qui sono osannati anzi si dice "meno male che ci sono loro, la nuova linfa del futuro". Vabbè...tenetevi i wannabees (bee lo uso scientemente), che vi devo dire.
Io se dovessi consigliare delle persone come esempi e modelli da seguire, stilerei nomi che hanno fatto e stanno facendo la storia dell'Informatica, il che non significa dover essere per forza bravi come loro e raggiungere gli stessi traguardi, ma impegnarsi per provarci.

Poi fate come volete, i gusti son gusti...e chiudo la () perchè i 14enni wannabesomeone-programmatori-hacker-aggiungereapiacimento italiani mi fanno venire l'orticaria.

~FullSyst3m~

14-06-2008, 16:53

Io non ho detto sia stupido, tutt'altro.
Altrimenti non sarebbe riuscito a trasformare in business un'attività come quella di provare qualche exploit noto in siti di rilevanza nazionale/internazionale e poi essere idolatrato dagli organi di informazione sconvolti dal fatto che un teenager al giorno d'oggi possa fare queste cose.
Ho detto semplicemente che uno che passa come esperto di sicurezza informatica, programmatore ecc. ecc. una persona del genere è il sintomo di qualcosa che non funziona nella nostra società e cioè molto semplicemente che siamo indietro anni luci come cultura informatica.
Tra le riviste ce ne sono di tecniche che si occupino di sviluppo/tool/linguaggi di programmazione? E le conferenze davanti a quale pubblico?
Mi ricordo parecchio tempo fa' un articolo dove si era cercato di portarlo all'Università di Camerino ma poi davanti alla prospettiva di parlare davanti ad universitari/programmatori si era praticamente eclissato.

I 3 libri a cui ti riferisci, sono uno la collezione di articoli del blog (basta tradurre quello che trovi nella rete e ne scrivi quanti ne vuoi), uno la sicurezza di cui ho parlato nel post precedente e terzo, la perla, un libro per "scrivere pagine ASP": praticamente una collezione di azioni fatte con un ambiente RAD e con codice relativo pubblicato, ovvero ti disegno una tabella e poi ti faccio vedere il sorgente.
Difficile eh, ci vuole un fenomeno di programmatore :asd:

Prova a leggere qualche libro della serie Apress su ASP.NET poi mi sai dire quale sia un testo di possibile utilizzo e quale no.

La riprova del fatto che siamo veramente un caso unico è che non esiste alcuno altro Paese industrializzato nel G8 che annovera fenomeni del genere, dove uno X finisce a fare una trasmissione "Pirati" con Belen Rodriguez (zappando me lo sn beccato l'altro giorno). Pirati?! What??
Negli States ci sono i 16enni che violano siti governativi, o altri come DVDJon, di cui possiamo discutere dal punto di vista educativo cosa possano rappresentare ma sulle cui capacità sono spanne sopra gli Aranzulla di turno.
Ci sono poi blog simili remunerativi, anzi il fenomeno è partito dagli USA (istartedsomething per esempio) ma nessuno di questi si professano "esperti in materia di sicurezza informatica" perchè verrebbero derisi da sviluppatori, pentesters ecc. ecc.

Qui sono osannati anzi si dice "meno male che ci sono loro, la nuova linfa del futuro". Vabbè...tenetevi i wannabees (bee lo uso scientemente), che vi devo dire.
Io se dovessi consigliare delle persone come esempi e modelli da seguire, stilerei nomi che hanno fatto e stanno facendo la storia dell'Informatica, il che non significa dover essere per forza bravi come loro e raggiungere gli stessi traguardi, ma impegnarsi per provarci.

Poi fate come volete, i gusti son gusti...e chiudo la () perchè i 14enni wannabesomeone-programmatori-hacker-aggiungereapiacimento italiani mi fanno venire l'orticaria.

Il tuo discorso non fa una grinza e riguardo gli USA hai ragione, ci sono 16enni o anche meno che violano siti governativi e fanno cose di rilievo nel mondo informatico. Non dimentichiamo però i Russi (anche se la maggior parte delle volte si collegano a cose brutte dell'informatica come virus o pack belli pronti per fare violare siti e creare virus anche a chi non ha mai acceso un pc) e, non per ultimo, DVDJon, a mio parere un ragazzo prodigio, che ha cambiato il mondo informatico quando ha creato l'algoritmo per decriptare la protezione dei DVD. E avevo solo 15 anni e ancora oggi fa grandi cose, esempio: FairPlay

khelidan1980

14-06-2008, 16:56

oh non sottovalutiamo il ragazzo....sfido chiunque ad esser cosi lucido davanti ad una come la Belen!!! :sofico:

~FullSyst3m~

14-06-2008, 17:15

oh non sottovalutiamo il ragazzo....sfido chiunque ad esser cosi lucido davanti ad una come la Belen!!! :sofico:

Chi è la Belen?? :confused:

khelidan1980

14-06-2008, 17:26

Chi è la Belen?? :confused:

la tipa che ha fatto con il tipo del blog il servizio a Pirati!Una delle varie letterine,letteronze....ecc....;)

A prescindere ma sto tipo fa articoli del blog su come creare account hotmail!!E ha pure 392 commenti!!che poi sono tutti uno spasso da leggere

~FullSyst3m~

14-06-2008, 18:07

la tipa che ha fatto con il tipo del blog il servizio a Pirati!Una delle varie letterine,letteronze....ecc....;)

A prescindere ma sto tipo fa articoli del blog su come creare account hotmail!!E ha pure 392 commenti!!che poi sono tutti uno spasso da leggere

:sbavvv: Questa non la sapevo...

k0nt3

14-06-2008, 19:01

perche' giucas casella non e' ne' pluto ne' paperino.
Mentre pluto E' pluto o paperino.
da un'espressione booleana mi aspetto o 'vero' o 'falso'
siccome 'giucas casella' è considerato 'vero' sarebbe anche lui una risposta corretta
se invece non è un'espressione booleana è roba oscura che è meglio non usare mai perchè rende il codice illeggibile
Non e' una questione banale :p.
"or" e' un concetto che vale non solo nelle proposizioni booleane e quindi non e' necessariamente detto che la risposta corretta a "paperino or pluto" sia solo "True". Anzi, se la domanda e' "quale e' il cane di Topolino" la risposta "paperino or pluto" non vuol dire "True".
In un linguaggio di programmazione, diventa un metodo molto pratico per dire "dammi il primo dei due (o piu', se il linguaggio lo consente) che e' valido".
certo "or" vale per qualunque cosa, basta definirlo opportunamente. poi però quando la tua definizione la usano anche altre persone bisogna assicurarsi che sia una definizione sensata. inutile dire che in questo caso non lo è.
se vuoi che ti restituisca il primo dei due che è valido basta creare un metodo chiamato dammiIlPrimoDeiDueCheE'Valido, non vedo perchè chiamarlo "or"

infatti contro ogni semantica logica:
'b' == ('a' and 'b')
restituisce true
mentre:
'a' == ('a' and 'b')
restituisce false

~FullSyst3m~

14-06-2008, 19:12

da un'espressione booleana mi aspetto o 'vero' o 'falso'
siccome 'giucas casella' è considerato 'vero' sarebbe anche lui una risposta corretta
se invece non è un'espressione booleana è roba oscura che è meglio non usare mai perchè rende il codice illeggibile

certo "or" vale per qualunque cosa, basta definirlo opportunamente. poi però quando la tua definizione la usano anche altre persone bisogna assicurarsi che sia una definizione sensata. inutile dire che in questo caso non lo è.
se vuoi che ti restituisca il primo dei due che è valido basta creare un metodo chiamato dammiIlPrimoDeiDueCheE'Valido, non vedo perchè chiamarlo "or"

infatti contro ogni semantica logica:
'b' == ('a' and 'b')
restituisce true
mentre:
'a' == ('a' and 'b')
restituisce false

>>> "a" == "a" and "b"
'b'
>>> "b" == "a" and "b"
False

Come si spiega?

DanieleC88

14-06-2008, 19:15

>>> "a" == "a" and "b"
'b'
>>> "b" == "a" and "b"
False

Come si spiega?
Vengono valutati prima i confronti, se non usi parentesi per dare priorità agli and. ;)

~FullSyst3m~

14-06-2008, 19:16

Autodidatta principalmente. Ma erano altri tempi: adesso non consiglierei di programmare in assembly al mio peggior nemico. :p

:rotfl:

Prestazionali, per la precisione. Oggi l'assembly viene usato pochissimo, e... per fortuna. :p

Dipende dall'architettura: quella Motorola 68000 era molto semplice, sebbene internamente fosse complessa (infatti il 68000 era un mostro di CPU quando è nato: ben 68000 transistor impaccati per un chip realizzato alla fine degli anni '70 era notevole).

Andrebbe in overflow. :asd:

Sì, infatti. Anche se, comunque, dal 68020 in poi l'ISA è diventata abbastanza complessa (c'erano modalità d'indirizzamento "spaziali" e persino istruzioni per manipolare campi di bit), ma conservando sempre quell'eleganza e "ortonalità" che la rendevano di facile utilizzo.

Certamente non dall'assembly. Ripeto: erano altri tempi, e una macchina che funzionava a 7Mhz o la programmavi in assembly o le prestazioni scendevano in picchiata.

Oggi NON lo rifarei sicuramente (anche perché faccio altro :p), e preferirei un linguaggio di più alto livello.

Occhio che i booleani in Python sono leggermente diversi (e molto più utili, a mio avviso) rispetto agli altri linguaggi.

Esempio:
>>> print 'pluto' and 'paperino'
paperino
>>> print 'pluto' or 'paperino'
pluto
>>> print '' or 'paperino'
paperino
>>> print '' and 'paperino'

Questo per gli operatori and e or, in particolare. Con quelli di confronto puoi andare tranquillo e restituiranno sempre il valore True o False (occhio alla prima lettera, che dev'essere maiuscola).

Altra cosa interessante, è il comportamento coi vari tipi di dato. Esempio:
>>> a = []
>>> if not a: print "Non c'e' niente qui!"
...
Non c'e' niente qui!
>>> a = ['Topolino']
>>> if a: print "Qualcosa c'e'..."
...
Qualcosa c'e'...
E con le stringhe:
>>> s = ''
>>> if not s: print "La stringa e' vuota!"
...
La stringa e' vuota!
>>> s = 'Topolino'
>>> if s: print "La stringa contiene qualcosa..."
...
La stringa contiene qualcosa...

Zitto e lavora! :D

Dai che con un po' di smanettamento ed esperienza vedrai che anche per te si apriranno le porte della programmazione. ;)

Qulle scritte poco sopra (a = []; a = ['Topolino']) non erano pure stringhe? Oppure vengono considerate come liste?

71104

14-06-2008, 19:17

>>> "a" == "a" and "b"
'b'
>>> "b" == "a" and "b"
False

Come si spiega?
mancano le parentesi tonde e l'operatore == ha la precedenza sull'and.

71104

14-06-2008, 19:18

Vengono valutati prima i confronti, se non usi parentesi per dare priorità agli and. ;) mi hai fregato :O

~FullSyst3m~

14-06-2008, 19:19

Vengono valutati prima i confronti, se non usi parentesi per dare priorità agli and. ;)

C'avevo pensato pure io, ma non pensavo che avevo ragione. Non sapevo che i confronti venissero valutati per primi ;)

by_to_by

14-06-2008, 19:23

usare le parentesi come?

DanieleC88

14-06-2008, 19:23

mi hai fregato :O
La senilità. Eh, la senilità. :D

:Prrr:

DanieleC88

14-06-2008, 19:23

usare le parentesi come?
Attorno ad 'a' and 'b'. ;)

by_to_by

14-06-2008, 19:26

Attorno ad 'a' and 'b'. ;)

ora funziona, restituisce true. però perchè 'a' == 'a' and 'b' restituisce 'b' e non true?

comunque non sapevo che mettendo le parentesi non veniva valutato il confronto prima ma tutto l'insieme

DanieleC88

14-06-2008, 19:28

No, ad esempio in 'a' == ('a' and 'b') valuterebbe prima 'a' and 'b', e poi confronterebbe 'a' con il risultato del precedente confronto. ;)

by_to_by

14-06-2008, 19:30

No, ad esempio in 'a' == ('a' and 'b') valuterebbe prima 'a' and 'b', e poi confronterebbe 'a' con il risultato del precedente confronto.

nell'and senza parentesi restituisce 'b' qua invece restituisce true con le parentesi e come se non bastasse 'b' == ('b' and 'a') restituisce false e non capisco perchè e anche 'a' == ('a' and 'b') restituisce false

marco.r

14-06-2008, 20:44

da un'espressione booleana mi aspetto o 'vero' o 'falso'
siccome 'giucas casella' è considerato 'vero' sarebbe anche lui una risposta corretta.

Solo che non si tratta di una espressione booleana, in quanto "giucas casella" non e' ne' vero ne' falso.

se invece non è un'espressione booleana è roba oscura che è meglio non usare mai perchè rende il codice illeggibile

E' oscuro e illeggibile per chi non lo conosce. La semantica e' chiara e precisa.

certo "or" vale per qualunque cosa, basta definirlo opportunamente. poi però quando la tua definizione la usano anche altre persone bisogna assicurarsi che sia una definizione sensata. inutile dire che in questo caso non lo è.
se vuoi che ti restituisca il primo dei due che è valido basta creare un metodo chiamato dammiIlPrimoDeiDueCheE'Valido, non vedo perchè chiamarlo "or"

Questa definizione di or e' ragionevole, in quanto non e' arbitraria ma e' una generalizzazione che si comporta esattamente come previsto quando viene ristretta ai booleani. E tra l'altro e' in uso da almeno 40 anni in ambito informatico, per cui e' pure abbastanza "sedimentata".
Poi puo' non piacere, ma questo e' un altro discorso.

infatti contro ogni semantica logica:
'b' == ('a' and 'b')
restituisce true
mentre:
'a' == ('a' and 'b')
restituisce false
[/quote]
Contro ogni semantica logica non so, di sicuro non contro la sua .
La definizione di and e' alquanto precisa:

x and y

equivale a

if x:
y
else
False

Che appunto coincide con la definizione dell'or booleano qualora x e y lo siano.

DanieleC88

14-06-2008, 20:55

marco.r

14-06-2008, 21:02

nell'and senza parentesi restituisce 'b' qua invece restituisce true con le parentesi e come se non bastasse 'b' == ('b' and 'a') restituisce false e non capisco perchè e anche 'a' == ('a' and 'b') restituisce false
Ci sono due cose da considerare
* L'ordine delle operazioni
* Il significato di and quando non si usano valori booleani.

I passi eseguiti sono, nei tre casi che indichi, i seguenti:

'a' == 'a' and 'b'
('a' == 'a' ) and 'b'
True and 'b'
'b'

'a' == ('a' and 'b')
'a' == 'b'
False

'b' == ('b' and 'a')
'b' == 'a'
False

Come detto prima, basta tenere a mente cosa vogliono dire or e and nel caso di valori non booleani. Va pure detto che l'esempio portato e' un esempio di come non scrivere il codice e ne va evitato l'uso. Raramente serve piu' del "dammi il primo valore non nullo" (e forse neanche quello in python dato che l'operatore e' solo binario).

marco.r

14-06-2008, 21:10

A dire il vero no, quella è un'estensione nel significato dell'and. Il classico and lavora solo sui booleani, quindi o restituisce True o False. Insomma, è booleano solo se y è booleano; può essere utile, ma c'è chi può storcere il naso. :D

ciao ;)

Io semplicemente contesto quel "classico". Ad esempio non e' l'and classico per la lingua inglese ma semmai per l'algebra booleana che e' arrivata un bel po' dopo. Non e' l'and classico per i linguaggi di programmazione in generale ma per i linguaggi in stile C.
E stiamo parlando di una operazione non booleana in un linguaggio non C-like...

DanieleC88

14-06-2008, 21:23

Non è quello il punto: non c'entra la lingua, io parlo di logica in senso stretto, dove la congiunzione può darti uno solo tra due valori (http://it.wikipedia.org/wiki/Algebra_di_Boole#AND). Se poi si vuole fare in modo che l'operatore, in contesti diversi dalla logica booleana, assuma altri significati, è ok. Però secondo me crea abbastanza confusione, tutto qui. ;)

by_to_by

14-06-2008, 21:47

Ci sono due cose da considerare
* L'ordine delle operazioni
* Il significato di and quando non si usano valori booleani.

I passi eseguiti sono, nei tre casi che indichi, i seguenti:

'a' == 'a' and 'b'
('a' == 'a' ) and 'b'
True and 'b'
'b'

'a' == ('a' and 'b')
'a' == 'b'
False

'b' == ('b' and 'a')
'b' == 'a'
False

Come detto prima, basta tenere a mente cosa vogliono dire or e and nel caso di valori non booleani. Va pure detto che l'esempio portato e' un esempio di come non scrivere il codice e ne va evitato l'uso. Raramente serve piu' del "dammi il primo valore non nullo" (e forse neanche quello in python dato che l'operatore e' solo binario).

non ho capito questi due casi. inoltre questi non sono valori booleani? quali sono allora i valori booleani? quali sono le operazioni booleane?

if x:
y
else
False

che significa scusa? perchè x and y equivale a questo?

per il resto, non ho capito quasi nulla di quello che ha detto daniele

DanieleC88

14-06-2008, 22:11

quali sono allora i valori booleani?
Vero o falso.
quali sono le operazioni booleane?
Congiunzione (and), disgiunzione (or), negazione (not) e i loro composti. :)
che significa scusa? perchè x and y equivale a questo?
Se x è valutata come vera, restituisce y, altrimenti restituisce False. Se a sua volta y è booleana, restituisce True o False a seconda del suo contenuto, e si riduce ad un and.

cdimauro

14-06-2008, 22:12

tutto da autodidatta? mamma mia.. sei un genio per me...
E' che a 11 anni non avevo un c@zzo da fare, per cui dovevo passarmi il tempo in qualche modo (ma buona parte lo trascorrevo fuori casa :cool: ) :asd:
OMG :eek: ! che orrore.. 'pluto' or 'paperino' = 'pluto'? e perchè non 'giucas casella'?
"Tu non pensi quadridimensionalmente, Marty!". :O

Lascia perdere i costrutti a cui sei normalmente abituato: tuffatti nell'ottica con cui Python valuta le espressioni logiche, e vedrai che è semplicemente geniale questo approccio (ovviamente per un linguaggio dinamico). :cool:
Qulle scritte poco sopra (a = []; a = ['Topolino']) non erano pure stringhe? Oppure vengono considerate come liste?
Sì, sono liste.
Io semplicemente contesto quel "classico". Ad esempio non e' l'and classico per la lingua inglese ma semmai per l'algebra booleana che e' arrivata un bel po' dopo. Non e' l'and classico per i linguaggi di programmazione in generale ma per i linguaggi in stile C.
E stiamo parlando di una operazione non booleana in un linguaggio non C-like...
A parte tutto il resto, quoto quest'ultimo che è particolarmente significativo, e mi ricollego a quanto scritto prima: non sta scritto da nessuna parte che and e or (e pure not) debbano funzionare esclusivamente con la logica booleana a cui siamo abituati con ALTRI linguaggi.

Sono operatori logici, e in Python ciò avviene nell'accezione più generale del termine, appunto. :)

DanieleC88

14-06-2008, 22:23

Sono operatori logici, e in Python ciò avviene nell'accezione più generale del termine, appunto. :)
Yeah (http://it.wikipedia.org/wiki/Logica_matematica)! :D

Be', il fatto è che si introduce una sintassi non proprio "naturale": in un linguaggio di tutti i giorni, un print 'x' and 'y' diventerebbe stampa 'x' e 'y', ed uno sarebbe portato a pensare di leggere xy in output. Poi si accorge che i valori di verità o falsità vengono valutati secondo i loro corrispondenti booleani, e collegati con determinati operatori: si aspetterebbe allora un Vero in output. Poi prende Python e si accorge che gli stampa solo 'y'! :D

Nota: voglio solo dire che secondo me è fuorviante. Non vi incollerite perché insisto, mi raccomando. :D

marco.r

14-06-2008, 22:29

Nota: voglio solo dire che secondo me è fuorviante. Non vi incollerite perché insisto, mi raccomando. :D

No problem, difficilmente mi arrabbio quando si tratta di opinioni. Tra l'altro nel caso in questione sono d'accordo che possa essere fuorviante :p :D. Diverso quando si cerca di farle passare per verita' rivelate.

cdimauro

14-06-2008, 22:33

Yeah (http://it.wikipedia.org/wiki/Logica_matematica)! :D
Ehm... ok, e allora? :stordita:
Be', il fatto è che si introduce una sintassi non proprio "naturale": in un linguaggio di tutti i giorni, un print 'x' and 'y' diventerebbe stampa 'x' e 'y', ed uno sarebbe portato a pensare di leggere xy in output.
Questo si verifica con un qualunque altro linguaggio in cui questi operatori lavorano esclusivamente con valori booleani.

Esempio (in Pascal):
Writeln(x and y);
Cosa stampa secondo te? Il valore di x e poi quello di y? ;)
Poi si accorge che i valori di verità o falsità vengono valutati secondo i loro corrispondenti booleani, e collegati con determinati operatori: si aspetterebbe allora un Vero in output. Poi prende Python e si accorge che gli stampa solo 'y'! :D
Non è così. Quel che conta è il concetto di vero e falso.

In Python [], '', {}, 0, ecc. sono "falsi", mentre ['Pluto'], 'Pluto', {'Pluto' : 'Topolino'}, 12345 sono "veri".

Ma questo a livello concettuale appunto. Operativamente and e or... lavorano coi VALORI, non con il loro valore di verità.
Nota: voglio solo dire che secondo me è fuorviante. Non vi incollerite perché insisto, mi raccomando. :D
Ma non c'è motivo di incollerirsi: stiamo semplicemente discutendo. :)

^TiGeRShArK^

14-06-2008, 22:38

Nota: voglio solo dire che secondo me è fuorviante. Non vi incollerite perché insisto, mi raccomando. :D

anche secondo me è fuorviante :O
soprattutto per gli interi..
Ma perchè se io scrivo 5 and 2 mi stampa 2, mentre facendo un and bit a bit mi dovrebbe stampare zero? :mbe:
..tra l'altro 'sta cosa che io trovo particolarmente odiosa mi pare che sia comune anche ad altri linguaggi....

DanieleC88

14-06-2008, 22:48

Ehm... ok, e allora? :stordita:
Lo citavo per quanto riguarda quella che io intendevo come definizione "classica" di quegli operatori, che rientrano nel campo della logica, in particolare nell'algebra booleana.
Esempio (in Pascal):
Writeln(x and y);
Cosa stampa secondo te? Il valore di x e poi quello di y? ;)
No no, appunto: dicevo che già nella norma è un allontanarsi dal linguaggio "naturale" nel quale siamo abituati a pensare, quindi introdurre un ulteriore diverso funzionamento può causare confusione (ergo: non ce n'era il bisogno). ;)
Ma non c'è motivo di incollerirsi: stiamo semplicemente discutendo. :)
No infatti, ma è meglio specificare, a volte scattano i flame per cose banali. :D
Io sono qui da semplice "apprendista", quindi mi piace confrontarmi con chi ne sa più di me, c'è sempre da imparare.

DanieleC88

14-06-2008, 22:50

Ma perchè se io scrivo 5 and 2 mi stampa 2, mentre facendo un and bit a bit mi dovrebbe stampare zero? :mbe:
Perché si riduce alla stessa identica operazione su ogni bit dei due numeri? Strano sarebbe se ti restituisse 2... :p

^TiGeRShArK^

14-06-2008, 22:52

Perché si riduce alla stessa identica operazione su ogni bit dei due numeri? Strano sarebbe se ti restituisse 2... :p

infatti se leggi mi stampa 2 :asd:
mentre io mi aspetterei zero, perchè penso sempre all'and bit per bit...
Se a te stampa zero voglio la tua versione di python :O

:p

EDIT: ... in effetti non è proprio il massimo della chiarezza il mio post precedente.. :stordita:

DanieleC88

14-06-2008, 22:55

^TiGeRShArK^

14-06-2008, 23:00

doppio..

^TiGeRShArK^

14-06-2008, 23:01

marco.r

14-06-2008, 23:23

Nella fretta di risponderti il primo pezzo m'era sfuggito di mente, e comunque qui Python non ce l'ho proprio, quindi non è che l'ho provato... :p

In ogni caso la cosa strana è proprio che venga 2. :D

if 5:
2
else:
False

:p

Personalmente troverei piu' pericolosa la versione bit a bit, perche' va contro l'idea che la condizione e' vera se entrambi sono "non falsi"

if 5 and 2:
print True
else:
print False

stamperebbe False

cdimauro

14-06-2008, 23:27

anche secondo me è fuorviante :O
soprattutto per gli interi..
Ma perchè se io scrivo 5 and 2 mi stampa 2, mentre facendo un and bit a bit mi dovrebbe stampare zero? :mbe:
..tra l'altro 'sta cosa che io trovo particolarmente odiosa mi pare che sia comune anche ad altri linguaggi....
A tanti linguaggi.

Se prendiamo tutti quelli C-Like, abbiamo che gli operatori & e && (e | e ||) danno risultati diversi, appunto, come Python (i cui corrispondenti sono &, and, | e or).

Questo perché c'è differenza fra operatori binari (& e |) e operatori logici (&& e ||).

In Python semplicemente la "logica" è diversa, non essendo limitata esclusivamente a quella booleana. :cool:

Quindi 5 and 2 dà giustamente 2 perché l'operazione effettuata è quella logica, mentre 5 & 2 darà 0 perché è quella binaria. :)
Lo citavo per quanto riguarda quella che io intendevo come definizione "classica" di quegli operatori, che rientrano nel campo della logica, in particolare nell'algebra booleana.
Mai sentito parlare di logica ternaria (o, più in generale, di logica a più valori)? :cool:
No no, appunto: dicevo che già nella norma è un allontanarsi dal linguaggio "naturale" nel quale siamo abituati a pensare, quindi introdurre un ulteriore diverso funzionamento può causare confusione (ergo: non ce n'era il bisogno). ;)
Purtroppo qualche keyword per questi operatori si doveva usare, ed essendo and e or utilizzati ampiamente nella letteratura informatica, la scelta è ricaduta su questi.

Comunque è una scelta che ha una sua logica :p e, infatti, limitandoci al contesto prettamente informatico (per la quale è nata quest'esigenza) confusione non dovrebbe essercene.

Il problema nasce, come giustamente dicevi, quando si passa al contesto del linguaggio naturale, o per meglio dire della normale dialettica. Però, appunto, è un altro contesto. :p

Mumble. Mi sa che m'è venuto fuori un discorso un po' contorto. :stordita: :p
No infatti, ma è meglio specificare, a volte scattano i flame per cose banali. :D
Io sono qui da semplice "apprendista", quindi mi piace confrontarmi con chi ne sa più di me, c'è sempre da imparare.
Idem. I flame, lo sai, nascono con persone che su queste cose ci marciano.

Non è il caso dei presenti, mi pare. :cool:

DanieleC88

14-06-2008, 23:51

Infatti :D
te lo sto dicendo da un quarto d'ora :asd:

>>> 5 and 2
2

:p
Sì, ho capito, e infatti ti sto dicendo da un quarto d'ora che è proprio quella la cosa che trovo "strana"! :p
Personalmente troverei piu' pericolosa la versione bit a bit, perche' va contro l'idea che la condizione e' vera se entrambi sono "non falsi"
Ma infatti di solito si fa distinzione, come cdimauro ha fatto notare, tra operatori logici e aritmetici/bitwise.

E già che stiamo trattando di questo esempio, aggiungo che anche io agli inizi, non conoscendo il perché un'operazione del tipo "5 and 3" mi potesse dare 1 (ah, i vecchi tempi del VB), leggendo roba simile in codici altrui, sono rimasto spiazzato e disorientato: esattamente perché non rientrava nell'ottica che avevo appreso di "and". :)
Mai sentito parlare di logica ternaria (o, più in generale, di logica a più valori)? :cool:
Non ne sono sicuro a dire il vero, almeno non mi risulta. Poi magari può essere che l'abbia incontrata per caso, senza conoscerne il nome. :stordita:
Mumble. Mi sa che m'è venuto fuori un discorso un po' contorto. :stordita: :p
No vabbe', si capiva tranquillamente. ;)
In fin dei conti, usare un and di quel tipo o non usarlo è questione di gusti. E io, se non me l'aveste fatta conoscere, probabilmente non avrei mai incontrato quel tipo di valutazione, se un giorno mi fossi messo a scrivere qualcosa in Python, quindi per me sarebbe stata una cosa del tutto trasparente. :)

cdimauro

15-06-2008, 00:19

Non ne sono sicuro a dire il vero, almeno non mi risulta. Poi magari può essere che l'abbia incontrata per caso, senza conoscerne il nome. :stordita:
E' una logica per cui una proposizione può essere vera, falsa o... nessuna delle due. :D
No vabbe', si capiva tranquillamente. ;)
In fin dei conti, usare un and di quel tipo o non usarlo è questione di gusti. E io, se non me l'aveste fatta conoscere, probabilmente non avrei mai incontrato quel tipo di valutazione, se un giorno mi fossi messo a scrivere qualcosa in Python, quindi per me sarebbe stata una cosa del tutto trasparente. :)
Bene :)

DanieleC88

15-06-2008, 10:24

E' una logica per cui una proposizione può essere vera, falsa o... nessuna delle due. :D
Ah ecco, allora la sto usando proprio adesso per un progetto, ma il professore ha usato un diverso nome. :D

k0nt3

15-06-2008, 10:34

Comunque è una scelta che ha una sua logica :p e, infatti, limitandoci al contesto prettamente informatico (per la quale è nata quest'esigenza) confusione non dovrebbe essercene.

Il problema nasce, come giustamente dicevi, quando si passa al contesto del linguaggio naturale, o per meglio dire della normale dialettica. Però, appunto, è un altro contesto. :p

beh ma non eri te che dicevi che scrivere codice python è come scrivere frasi in inglese? :asd:
io faccio parte del mondo informatico ma lo trovo fuorviante

"Tu non pensi quadridimensionalmente, Marty!". :O

Lascia perdere i costrutti a cui sei normalmente abituato: tuffatti nell'ottica con cui Python valuta le espressioni logiche, e vedrai che è semplicemente geniale questo approccio (ovviamente per un linguaggio dinamico). :cool:

e meno male! la vita è già abbastanza complessa in tre dimensioni :Prrr:
mi sto sempre più convincendo che python è il C++ dei linguaggi dinamici :fagiano:
io se uso un linguaggio di alto livello non voglio scrivere codice sporco (come quello che risulterebbe dall'uso dei suddetti operatori) altrimenti non ne vale la pena

E' una logica per cui una proposizione può essere vera, falsa o... nessuna delle due.
ma infatti stavamo parlando di logica booleana, non di logica in generale :p
altrimenti vincerebbe sicuramente la logica fuzzy :O
prato == verde?
0.733333333333333333333333333333333333333333333331

marco.r

15-06-2008, 15:05

mi sto sempre più convincendo che python è il C++ dei linguaggi dinamici

Python non e' il solo. Lo stesso comportamento lo trovi in altri linguaggi dinamici come Ruby, Scheme, Common Lisp, JavaScript...
D'altra parte nel momento in cui ho un linguaggio dinamico ho solo due alternative: segnalo a runtime un errore per il fatto che non ho un valore booleano, o uso una estensione che vale anche per i non booleani. E dato che non crea particolari problemi questa seconda alternativa e' quella piu' usata.
Occhio che con "non crea problemi" non intendo dire che non si possa scrivere volutamente brutto codice come "b" == "a" and "b", ma che non porta ad un numero maggiore di errori accidentali.
Il motivo per cui ad esempio in Java considera "Vero" solo i booleani che valgono true e' dovuto anche al fatto che altrimenti si creano diverse occasioni in cui un errore puo' non venire individuato. Il classico esempio del C/C++ e' il pezzo di codice

if ( x = 10 )
{ }

dove molto spesso (seppur non sempre) quell' = voleva essere un == ma l'errore non viene rilevato perche' e' comunque un'espressione valida.
Il problema in python e' risolto in altro modo perche' l'assegnamento e' uno statement e non una espressione per cui non puo' stare in un controllo di un if. Non mi vengono in mente casi in cui una simile semantica crei problemi.

by_to_by

15-06-2008, 18:35

sono stato fuori tutto il giorno e ho letto adesso la discussione, ma non c'ho capito nulla. mi avete fatto confondere.

non capisco, è una cosa brutta usare and? perchè 5 and 2 dovrebbe ritornare 0? e l'and bit a bit cosa è?

No vabbe', si capiva tranquillamente.
In fin dei conti, usare un and di quel tipo o non usarlo è questione di gusti. E io, se non me l'aveste fatta conoscere, probabilmente non avrei mai incontrato quel tipo di valutazione, se un giorno mi fossi messo a scrivere qualcosa in Python, quindi per me sarebbe stata una cosa del tutto trasparente.

quindi tu non userai mai l'operatore and?

scrivere volutamente brutto codice come "b" == "a" and "b"

cosa ha di brutto questo codice?

cercate di spiegarmi perfavore

^TiGeRShArK^

15-06-2008, 18:44

sono stato fuori tutto il giorno e ho letto adesso la discussione, ma non c'ho capito nulla. mi avete fatto confondere.

non capisco, è una cosa brutta usare and? perchè 5 and 2 dovrebbe ritornare 0? e l'and bit a bit cosa è?

perchè in binario 5 è (a meno del bit + significativo del segno della notazione complemento a due che non mi ricordo mai se è alto o basso x i positivi) 101 mentre 2 è 010.
Quindi facendo 101 and 010 si ottiene 000.

quindi tu non userai mai l'operatore and?

Tra le stringhe sinceramente non ne vedo proprio l'utilità... :fagiano:

by_to_by

15-06-2008, 18:48

perchè in binario 5 è (a meno del bit + significativo del segno della notazione complemento a due che non mi ricordo mai se è alto o basso x i positivi) 101 mentre 2 è 010.
Quindi facendo 101 and 100 si ottiene 000.

Tra le stringhe sinceramente non ne vedo proprio l'utilità... :fagiano:

scusa, potresti spiegarti meglio? e perchè si ottiene 000 facendo 101 and 100?

e dove la vedi allora l'utilità dell'and? qua alcuni dicono che serve, altri che è inutile.. non ci sto capendo niente

if 5 and 2:
print True
else:
print False

perchè ritorna false? 5 e 2 sono entrambi veri

by_to_by

15-06-2008, 18:57

'a' == ('a' and 'b')
'a' == 'b'
False

'b' == ('b' and 'a')
'b' == 'a'
False

inoltre non capisco perchè ritornano false questi pezzi di codice. non ci sto capendo più niente.

spiegatemi perfavore altrimenti non posso andare avanti

^TiGeRShArK^

15-06-2008, 18:58

scusa, potresti spiegarti meglio? e perchè si ottiene 000 facendo 101 and 100?

Il complemento a due è la modalità comunente utilizzata per rappresentare i numeri sui pc:
http://it.wikipedia.org/wiki/Complemento_a_due

Per quanto riguarda l'and semplicemente la seconda volta che ho scritto la rappresentazione in binario di 2 mi si sono intrecciate le dita e ho scritto 100 al posto di 010 :fagiano:
ora l'ho corretto :p

e dove la vedi allora l'utilità dell'and? qua alcuni dicono che serve, altri che è inutile.. non ci sto capendo niente

l'and per i booleani è essenziale.
Serve per decidere quando entrambe le condizioni siano vere.
Qua si sta discutendo sull'inutilità di utilizzarlo per le stringhe.
A me non sembra possa avere un utilità....:boh:

perchè ritorna false? 5 e 2 sono entrambi veri
...veramente a me restituisce True python.. :fagiano:

^TiGeRShArK^

15-06-2008, 19:00

inoltre non capisco perchè ritornano false questi pezzi di codice. non ci sto capendo più niente.

spiegatemi perfavore altrimenti non posso andare avanti

'a' == ('a' and 'b') #il carattere 'a' è diverso da True che viene fuori dalle parentesi
'a' == 'b' #il carattere 'a' è ovviamente diverso dal carattere 'b'
False

'b' == ('b' and 'a') #il carattere 'b' è diverso da True che esce dalle parentesi
'b' == 'a' #il carattere 'b' è diverso dal carattere 'a'
False

by_to_by

15-06-2008, 19:10

Per quanto riguarda l'and semplicemente la seconda volta che ho scritto la rappresentazione in binario di 2 mi si sono intrecciate le dita e ho scritto 100 al posto di 010
ora l'ho corretto

non capisco lo stesso perchè viene 000

Qua si sta discutendo sull'inutilità di utilizzarlo per le stringhe.

utilizzarlo per le stringhe in che senso? e questi booleani di cui tutti parlate quali sono? i numeri? o le incognite?

.veramente a me restituisce True python..

ho ruguardato e a me restiuisce due. come è ppossibile?

'a' == ('a' and 'b') #il carattere 'a' è diverso da True che viene fuori dalle parentesi

'b' == ('b' and 'a') #il carattere 'b' è diverso da True che esce dalle parentesi

non capisco, spiegati meglio se puoi

DanieleC88

15-06-2008, 19:13

quindi tu non userai mai l'operatore and?
Non ho detto questo, ho detto che, non conoscendo questa particolarità del Python, non mi sarei mai sognato di usare una sintassi del tipo print 'ciao' and 'buonasera'. :D

Non conoscendolo, non mi sarei accorto del suo funzionamento "anomalo", e avrei scelto piuttosto di scrivere una cosa tipo:
if 'ciao':
print 'buonasera'

;)

^TiGeRShArK^

15-06-2008, 19:17

non capisco lo stesso perchè viene 000
perchè se confronti ad uno ad uno 101 e 010 con l'and hai questa situazione:

1 - 0 False (0)
0 - 1 False (0)
1 - 0 False (0)

praticamente 1 sta per True e 0 sta per False.
Se fai un and tra True e False ottieni sempre False poichè devono essere True entrambi per ottenere True.

utilizzarlo per le stringhe in che senso?

come è stato utilizzato in quegli esempi che tu trovi senza senso e io trovo piuttosto inutili :p

e questi booleani di cui tutti parlate quali sono? i numeri? o le incognite?

ehmm...
nessuno dei due..
i booleani possono avere solo due valore: True o False.
In pratica il bit, la + piccola unità utilizzata per immagazzinare le informazioni in informatica è un booleano, dato che può avere come valore solo 0 o 1...

ho ruguardato e a me restiuisce due. come è ppossibile?

se fai 5 and 2 python ti restituisce 2, ma se lo metti nell if, python considera 2 come True e quindi esegue l'istruzione "print True".

^TiGeRShArK^

15-06-2008, 19:22

non capisco, spiegati meglio se puoi

a_and_b = 'a' and 'b' #questa variabile conterrà l'and tra 'a' e 'b', che essendo entrambi veri restituisce 'b' secondo la convenzione di python che verrà assegnata alla variabile a_and_b

'a' == a_and_b # è equivalente a 'a' == 'b'

b_and_a = 'b' and 'a' # conterrà il carattere 'a'
'b' == b_and_a #è equivalente a 'b' == 'a'

DanieleC88

15-06-2008, 19:23

non capisco lo stesso perchè viene 000
Perché l'operatore and, sui numeri, prende un bit alla volta dai due numeri (rappresentati in binario) e lo confronta: nel risultato avrai un 1 solo e soltanto se entrambi i bit iniziali erano 1: nel caso di 101 e 010 sono tutti diversi, quindi il risultato sarà pieno di 0.
e questi booleani di cui tutti parlate quali sono?
Sono dei valori numerici, che possono assumere solo ul valore di verità (1 o True) o di falsità (0 o False).
Gli altri tipi di dati, se non sono booleani ma li usi dentro un if, vanno "interpretati" come booleani: nella maggior parte dei casi, danno False se hai qualcosa di vuoto che stai valutando; tutto ciò che è "non-vuoto" darà True (prova con due stringhe).
ho ruguardato e a me restiuisce due. come è ppossibile?
Lo usi sulle stringhe?

by_to_by

15-06-2008, 20:18

Perché l'operatore and, sui numeri, prende un bit alla volta dai due numeri (rappresentati in binario) e lo confronta: nel risultato avrai un 1 solo e soltanto se entrambi i bit iniziali erano 1: nel caso di 101 e 010 sono tutti diversi, quindi il risultato sarà pieno di 0.

e sera era 101 e 110 era 111?

Sono dei valori numerici, che possono assumere solo ul valore di verità (1 o True) o di falsità (0 o False).
Gli altri tipi di dati, se non sono booleani ma li usi dentro un if, vanno "interpretati" come booleani: nella maggior parte dei casi, danno False se hai qualcosa di vuoto che stai valutando; tutto ciò che è "non-vuoto" darà True (prova con due stringhe).

ho provato "ciao" and "ora" e mi da 'ora' come risultato

Lo usi sulle stringhe?

si, ho scritto sia 5 and 2 che "5" and "2" e ritorna 2 e "2"

cdimauro

15-06-2008, 20:20

beh ma non eri te che dicevi che scrivere codice python è come scrivere frasi in inglese? :asd:
Certamente, ma non sempre è possibile.

L'uso dell'and e dell'or come operatori logici nasce un POCHINO prima di Python, come ho già scritto. Python l'ha semplicemente mutuato.
io faccio parte del mondo informatico ma lo trovo fuorviante
Semmai fuorviante sarebbe l'accozzaglia di caratteri && e || utilizzati per rappresentare l'and e l'or logico.

Se permetti, molto meglio le keyword and e or rispettivamente, che tra l'altro vanno a nozze con la letteratura informatica in merito, che utilizza esplicitamente questi due vocaboli.

Insomma, da decenni s'è sempre parlato di and e or. Mi suona strano che un informatico trovi fuorviante ciò che dovrebbe far parte della tradizione, e dunque ben noto e comprensibile.
e meno male! la vita è già abbastanza complessa in tre dimensioni :Prrr:
mi sto sempre più convincendo che python è il C++ dei linguaggi dinamici :fagiano:
io se uso un linguaggio di alto livello non voglio scrivere codice sporco (come quello che risulterebbe dall'uso dei suddetti operatori) altrimenti non ne vale la pena
Lo reputi tu codice "sporco", non adducendo alcuna motivazione. Lascia, quindi, il tempo che trova, questo tuo giudizio.

Tra l'altro la soluzione adottata da Python è molto più intelligente rispetto a quella di altri linguaggi dinamici, e pure molto più utile.

Io trovo decisamente più sporco l'aver usato dei simboli come && e & per rappresentare due operazioni completamente diverse. A parte la scarsa leggibilità, commettere qualche errore scambiandoli è molto semplice, ed è uno dei problemi più comuni di chi scrive codice con C & derivati.
ma infatti stavamo parlando di logica booleana, non di logica in generale :p
altrimenti vincerebbe sicuramente la logica fuzzy :O
prato == verde?
0.733333333333333333333333333333333333333333333331
No, stavamo parlando di LOGICA. Leggi meglio.
Tra le stringhe sinceramente non ne vedo proprio l'utilità... :fagiano:
Per l'and l'utilità è scarsa: è difficile trovare pattern di utilizzo.

L'or, invece, è decisamente più utile e molto frequente come caso d'uso. :)

^TiGeRShArK^

15-06-2008, 20:24

e sera era 101 e 110 era 111?

no perchè sarebbe:

1 and 1 = 1
0 and 1 = 0
1 and 0 = 0

quindi il risultato è 100.

si, ho scritto sia 5 and 2 che "5" and "2" e ritorna 2 e "2"
e che c'è di strano? :mbe:
se però scrivi:

if '5' and '2':
print True
else:
print False

ti stampa ovviamente True...

DanieleC88

15-06-2008, 20:26

e sera era 101 e 110 era 111?
No, diventava 100, perché solo il terzo bit era attivo in entrambi i numeri di partenza. ;)
ho provato "ciao" and "ora" e mi da 'ora' come risultato
Ma questa è una particolarità del Python, è ciò di cui si discuteva prima. ;)
si, ho scritto sia 5 and 2 che "5" and "2" e ritorna 2 e "2"
Appunto: prova senza le virgolette, diventerà un and aritmetico.

^TiGeRShArK^

15-06-2008, 20:27

Appunto: prova senza le virgolette, diventerà un and aritmetico.
...no restituisce sempre 2 :fagiano:

by_to_by

15-06-2008, 20:28

no perchè sarebbe:

1 and 1 = 1
0 and 1 = 0
1 and 0 = 0

quindi il risultato è 100.

e che c'è di strano? :mbe:
se però scrivi:

if '5' and '2':
print True
else:
print False

ti stampa ovviamente True...

ora ho capito, cmq in quel modo si mi stampa true

Per l'and l'utilità è scarsa: è difficile trovare pattern di utilizzo.

in parole da ignorante significa cosa?

^TiGeRShArK^

15-06-2008, 20:29

in parole da ignorante significa cosa?
immagino che se scrivi:

print primaParola or secondaParola or terzaParola or quartaParola

ti stampa la prima parola non vuota, e quindi potrebbe avere un campo di utilizzo....
personalmente preferisco l'approccio funzionale da utilizzare su una lista di parole... ma è questione di gusti qui :p

by_to_by

15-06-2008, 20:30

...no restituisce sempre 2 :fagiano:

quello che ho scritto io

No, diventava 100, perché solo il terzo bit era attivo in entrambi i numeri di partenza.

attivo? che significa? e il terzo bit intendi contando da destra a sinistra o da sinistra a destra?

by_to_by

15-06-2008, 20:32

immagino che se scrivi:

print primaParola or secondaParola or terzaParola or quartaParola

ti stampa la prima parola non vuota, e quindi potrebbe avere un campo di utilizzo....
personalmente preferisco l'approccio funzionale da utilizzare su una lista di parole... ma è questione di gusti qui :p

intendevo cosa significa che l'and nelle stringhe è difficile trovare un pattern di utilizzo

ti stampa la prima parola non vuota, e quindi potrebbe avere un campo di utilizzo...personalmente preferisco l'approccio funzionale da utilizzare su una lista di parole... ma è questione di gusti qui

che campo di utilizzo potrebbe avere? esempio di approccio funzionale da usare su una lista di parole?

^TiGeRShArK^

15-06-2008, 20:39

quello che ho scritto io

si ma prima parlavamo di quello inserito all'interno dell'if :asd:
in python se scrivi '5' and '2' oppure 5 and 2 ti restituisce sempre '2' oppure 2.

attivo? che significa? e il terzo bit intendi contando da destra a sinistra o da sinistra a destra?
il più significativo, che sarebbe il primo da sinistra...
..io infatti l'avrei chiamato il primo bit... :fagiano:

DanieleC88

15-06-2008, 20:54

...no restituisce sempre 2 :fagiano:
D'oh! :doh:

^TiGeRShArK^

15-06-2008, 20:57

D'oh! :doh:

:asd:
e il bello è che ne abbiamo discusso x mezz'ora ieri sera :asd:

DanieleC88

15-06-2008, 21:03

:asd:
e il bello è che ne abbiamo discusso x mezz'ora ieri sera :asd:
LOL, effettivamente... Però almeno io avevo la scusante di essere su Windows, dove non avevo proprio Python sotto mano per provare. :Prrr:

^TiGeRShArK^

15-06-2008, 21:12

LOL, effettivamente... Però almeno io avevo la scusante di essere su Windows, dove non avevo proprio Python sotto mano per provare. :Prrr:

io oggi l'ho installato sul mbpro...
sinceramente usarlo solo da terminale mi faceva venire i conati di vomito...
e già non è che ami alla follia python.. ma usato da terminale è osceno :asd:
infatti non appena ho visto il topic di oggi di raoul benneth sul vb.net ho fatto partire con gioia visual studio 2008 sotto parallels e ho scritto un pò di sano C# + linq :cool:

:asd:

cdimauro

15-06-2008, 21:42

^TiGeRShArK^

15-06-2008, 23:36

Lavorando coi db, capitano non poche volte situazioni del genere, per cui lo trovo molto utile. :)

..si.
ma lui immagino che nemmeno sappia cosa sia un db.. :fagiano:

Mesh89

16-06-2008, 00:12

BE' ODDIO... un conto è avere 20 anni e un conto è averne 60 :|
se poi mettiamo mia nonna a programmare sistemi operativi allora stiamo freschi.

Oddio, io direi di no, però messa in questi termini anche si...
Ci vuole anche una certa forma mentale, e magari se la mente non ha più una certa elasticità si fa fatica ad acquisirla...

In sostanza direi di no, se non si va agli estremi

by_to_by

16-06-2008, 07:17

Oddio, io direi di no, però messa in questi termini anche si...
Ci vuole anche una certa forma mentale, e magari se la mente non ha più una certa elasticità si fa fatica ad acquisirla...

In sostanza direi di no, se non si va agli estremi

se metti uno a 25 anni a uno a 80 allora qua siamo al limite, qua si parla di casi "normali"

si ma prima parlavamo di quello inserito all'interno dell'if

prima parlavate dell'and non dell'if

intendevo cosa significa che l'and nelle stringhe è difficile trovare un pattern di utilizzo

che campo di utilizzo potrebbe avere? esempio di approccio funzionale da usare su una lista di parole?

mi riquoto ed inoltre, dato che ci sono vi chiedo l'ultima cosa e poi mi tolgo dai piedi. ho trovato questo codice in un altra guida, solo che non ci capisco niente a essere sincero, sarà a causa delle variabili in inglese o altro ma non ci capisco nulla:

# Questo programma calcola la sequenza di Fibonacci.
a = 0
b = 1
count = 0
max_count = 20
while count < max_count:
count = count + 1
# Occorre tenere traccia finché ci sono cambiamenti
old_a = a
old_b = b
a = old_b
b = old_a + old_b
# Attenzione che la virgola alla fine di un istruzione print
# prosegue la stampa sulla stessa linea.
print old_a,
print

che poi cosa significa "# Occorre tenere traccia finché ci sono cambiamenti" ancora non l'ho capito

k0nt3

16-06-2008, 09:05

@cdimauro
non importa quando è nato l'uso dell'or e dell'and in quella maniera.. un linguaggio moderno (come java per esempio) dovrebbe impedire con qualsiasi mezzo la scrittura di codice incomprensibile :p *
se poi per te basta scrivere "and" al posto di && perchè il codice sia "pulito".. il simbolo è solo un simbolo, la sua importanza è secondaria rispetto alla semantica che si porta dietro. infatti gran parte dei linguaggi oggi usa ||, && e compagnia

* se trovo il link al post di PGI-bis sui generici in java te lo mando in pvt :asd:
immagino che se scrivi:

print primaParola or secondaParola or terzaParola or quartaParola

ti stampa la prima parola non vuota, e quindi potrebbe avere un campo di utilizzo....
personalmente preferisco l'approccio funzionale da utilizzare su una lista di parole... ma è questione di gusti qui :p

io questo lo chiamo codice sporco :fagiano:

DanieleC88

16-06-2008, 12:13

che poi cosa significa "# Occorre tenere traccia finché ci sono cambiamenti" ancora non l'ho capito
Sei dentro un ciclo, in qualche modo dovrai salvarti gli ultimi due valori, perché tu possa calcolare dopo i successivi due, che fanno uso proprio di quell'informazione... Sai come sono definiti i numeri di Fibonacci? La funzione che ne calcola l'n-simo numero è facilissima da fare in modo ricorsivo, per l'ultimo esame in assembly MIPS l'ho fatta come esercizio. ;)

by_to_by

16-06-2008, 12:25

Sei dentro un ciclo, in qualche modo dovrai salvarti gli ultimi due valori, perché tu possa calcolare dopo i successivi due, che fanno uso proprio di quell'informazione... Sai come sono definiti i numeri di Fibonacci? La funzione che ne calcola l'n-simo numero è facilissima da fare in modo ricorsivo, per l'ultimo esame in assembly MIPS l'ho fatta come esercizio. ;)

per te è facilissima, ma per me no. non capisco quell'old_a old_b ecc. magari se fosse riscritto e commentato in modo migliore il codice lo capirei. inoltre mi interesserebbe sapere:

intendevo cosa significa che l'and nelle stringhe è difficile trovare un pattern di utilizzo

che campo di utilizzo potrebbe avere? esempio di approccio funzionale da usare su una lista di parole?

comunque tu sei troppo bravo, sei portato per la progammazione, sono cose facilissime per te è per giunta lo hai fatto in assemblt, che è difficilissimo. io non sono portato forse

DanieleC88

16-06-2008, 12:38

per te è facilissima, ma per me no. non capisco quell'old_a old_b ecc. magari se fosse riscritto e commentato in modo migliore il codice lo capirei. inoltre mi interesserebbe sapere:
Fidati, è molto facile. Si tratta solo di entrare nell'ottica. Comunque non mi hai risposto: conosci come sono definiti i numeri di Fibonacci? Se sai quello, il problema diventa molto più semplice (suggerimento: Wikipedia sa tutto :D).
Per calcolare l'n-simo numero di Fibonacci ad esempio ti basta una funzione come questa:
def Fibonacci(n):
if (n < 2):
return 1

return Fibonacci(n-1) + Fibonacci(n-2)

Quegli old_a e old_b non fanno altro che conservare i valori degli ultimi due numeri, prima di salvare i nuovi in a e b. ;)
comunque tu sei troppo bravo, sei portato per la progammazione, sono cose facilissime per te è per giunta lo hai fatto in assemblt, che è difficilissimo. io non sono portato forse
Non ti faccio vedere l'implementazione in MIPS solo perché non è il momento, servirebbe solo a confonderti le idee: ti giuro che è praticamente identica a come la farei in Python, solo un po' più lunghetta da scrivere.

Non metterti in testa certe cose, pensa ad imparare a risolvere problemi usando Python, per gli altri linguaggi c'è tutto il tempo del mondo. ;)

by_to_by

16-06-2008, 12:42

Fidati, è molto facile. Si tratta solo di entrare nell'ottica. Comunque non mi hai risposto: conosci come sono definiti i numeri di Fibonacci? Se sai quello, il problema diventa molto più semplice (suggerimento: Wikipedia sa tutto :D).
Per calcolare l'n-simo numero di Fibonacci ad esempio ti basta una funzione come questa:
def Fibonacci(n):
if (n < 2):
return 1

return Fibonacci(n-1) + Fibonacci(n-2)

Quegli old_a e old_b non fanno altro che conservare i valori degli ultimi due numeri, prima di salvare i nuovi in a e b. ;)

Non ti faccio vedere l'implementazione in MIPS solo perché non è il momento, servirebbe solo a confonderti le idee: ti giuro che è praticamente identica a come la farei in Python, solo un po' più lunghetta da scrivere.

Non metterti in testa certe cose, pensa ad imparare a risolvere problemi usando Python, per gli altri linguaggi c'è tutto il tempo del mondo. ;)

se magari mi spieghi come sono definiti i numeri di fibonacci capirei quell'if e il resto della funzione. cmq se è cosi semplice come hai scritto tu, perchè quello ha fatto tutti quei passaggi?

comunqe io ci penso perchè siamo quasi coetanei e io sono a tabula rasa, sai un sacco di cose tu e sei troppo bravo :muro: :muro: :muro:

marko.fatto

16-06-2008, 13:34

ogni numero è la somma dei due precedenti tranne il primo e il secondo che sono rispettivamente 0 e 1 Successione_di_Fibonacci (http://it.wikipedia.org/wiki/Successione_di_Fibonacci)

DanieleC88

16-06-2008, 13:40

Ecco, se il forum non smette di funzionare proprio mentre clicco "Invia risposta" forse ce la facciamo... ricopio...

Guarda, mi sono ritrovato anche io, parecchie volte, a sbattere la testa contro problemi che il mondo trovava banali e che io credevo impossibili da risolvere. Ho anche pensato di abbandonare tutto, pensando che nemmeno questo fosse ciò che fa per me: ho imparato solo col tempo che pensarla in questo modo non mi avrebbe portato da nessuna parte, quindi mi sono deciso semplicemente a provare e riprovare fino a raggiungere un minimo di risultati concreti. Se so fare qualcosa più di te, è solo perché ho cominciato prima, e ho il tempo dalla mia parte. Hai cominciato adesso? Bene, non pensare a ciò che c'è stato prima: sei all'inizio di qualcosa di nuovo, mettiti alla prova senza demoralizzarti. ;)

Torniamo ai numeri di Fibonacci. Molto semplicemente, la sequenza di Fibonacci si calcola in questo modo: il punto di partenza è assegnare il valore 1 alle prime due posizioni (0 e 1), e calcolare i numeri successivi come la somma dei due numeri precedenti. Fine. ;)
Se noti, è esattamente ciò che fa la versione ricorsiva che ti ho scritto prima: se il numero che cerchiamo è nelle prime due posizioni, basta restituire 1, altrimenti, si restituisce la somma delle due posizioni precedenti. :)

Ti chiederai, se è così semplice fare una versione ricorsiva di una funzione che calcoli l'n-sima posizione nella sequenza di Fibonacci, perché non l'abbiano usata nel codice che hai trovato tu: be', semplicemente perché per ogni numero deve calcolare tutti i precedenti... quindi impiegherebbe molto più tempo se dovesse calcolare le prime 20 posizioni in questo modo. Allora il programma parte assegnando 0 ed 1 ai primi due numeri e, partendo da zero, calcola i successivi, stampandoli man mano che si avanza.

by_to_by

16-06-2008, 13:44

marko.fatto

16-06-2008, 13:48

non ho capito solo perchè con la funzione che hai scritto tu non si può fare e si deve fare come ha scritto nel codice che ho trovato io. proprio non lo capisco

si può fare ma è "pesante".. cioè si "sprecano" molti calcoli (calcolare ogni volta tutti i numeri precedenti)

grigor91

16-06-2008, 13:56

def Fibonacci(n):
if (n < 2):
return 1

return Fibonacci(n-1) + Fibonacci(n-2)

il primo numero di Fibonacci è 0, quindi se n è 1 deve ritornare 0:
def Fibonacci(n):
if (n == 1):
return 0

if (n == 2):
return 1

return Fibonacci(n-1) + Fibonacci(n-2)

by_to_by

16-06-2008, 14:01

il primo numero di Fibonacci è 0, quindi se n è 1 deve ritornare 0:
def Fibonacci(n):
if (n == 1):
return 0

if (n == 2):
return 1

return Fibonacci(n-1) + Fibonacci(n-2)

e non è la stessa cosa che ha scritto daniele? io vorrei solo un codice magari in italiano e con commenti del codice che ho trovato io per capire perchè il metodo di daniele è più pesante e come funziona il codice che ho trovato io

DanieleC88

16-06-2008, 14:01

il primo numero di Fibonacci è 0, quindi se n è 1 deve ritornare 0:
Non è esatto, si parte da zero solo se si vuole definire in quel modo la funzione. Altrimenti si parte dalla prima posizione uguale ad 1 ed è perfettamente identica (confronta Wikipedia).

Se parti da 0, chiedendo il 10° numero stai chiedendo l'indice 10 della sequenza, altrimenti è effettivamente il decimo (primo, secondo, terzo, ..., decimo). ;)

DanieleC88

16-06-2008, 14:06

perchè il metodo di daniele è più pesante
Semplificando, il mio codice ricorsivo in pratica è come se stesse facendo due cicli e sprecando memoria per salvare il suo "stato", quando calcoli i primi due numeri fai un numero enorme di iterazioni, che potresti evitare (come fanno loro) semplicemente salvando gli ultimi due numeri e facendo una veloce somma. ;)

by_to_by

16-06-2008, 21:46

Se parti da 0, chiedendo il 10° numero stai chiedendo l'indice 10 della sequenza, altrimenti è effettivamente il decimo (primo, secondo, terzo, ..., decimo).

sarò cretino ma non ho capito. potresti spiegare meglio? graize

Semplificando, il mio codice ricorsivo in pratica è come se stesse facendo due cicli e sprecando memoria per salvare il suo "stato", quando calcoli i primi due numeri fai un numero enorme di iterazioni, che potresti evitare (come fanno loro) semplicemente salvando gli ultimi due numeri e facendo una veloce somma.

e scritto in codice python un pò più chiaro di quello che ho trovato e magari anche commentato come si deve, come sarebbe?

DanieleC88

16-06-2008, 21:57

sarò cretino ma non ho capito. potresti spiegare meglio? graize
Se tu hai una serie di numeri e inizi il conteggio da 1, il primo numero è 1, il secondo è 2, il terzo è 3, ..., il decimo è 10.
Se tu invece partissi da 0 (cosa che succede con le array)? Il primo numero è 0, il secondo è 1, il terzo è 2, ..., il decimo è 9. ;)
e scritto in codice python un pò più chiaro di quello che ho trovato e magari anche commentato come si deve, come sarebbe?
A me sembra commentato e scritto in modo sintetico e chiaro... Facciamo una cosa, prova a darmene una tua interpretazione, una magari anche sbagliata: così tu ti eserciti, e se sbagli ti correggo. :)

by_to_by

16-06-2008, 21:59

Se tu hai una serie di numeri e inizi il conteggio da 1, il primo numero è 1, il secondo è 2, il terzo è 3, ..., il decimo è 10.
Se tu invece partissi da 0 (cosa che succede con le array)? Il primo numero è 0, il secondo è 1, il terzo è 2, ..., il decimo è 9. ;)

A me sembra commentato e scritto in modo sintetico e chiaro... Facciamo una cosa, prova a darmene una tua interpretazione, una magari anche sbagliata: così tu ti eserciti, e se sbagli ti correggo. :)

ci sono quei nomi di variabili che forse mi confondono. old_a old_b ecc io ancora sto con ilo vocabolario di inglese accanto quindi figurati...

DanieleC88

16-06-2008, 22:16

L'ho ridotto un po', portato in italiano e commentato. Prova ora. ;)
# Questo programma calcola la sequenza di Fibonacci.

# Imposto i valori iniziali dei due primi numeri di Fibonacci
primo = 0
secondo = 1

# Azzero la mia attuale posizione (devo ancora partire!) e
# imposto l'indice massimo da raggiungere
indice = 0
massimo = 20

while (indice < massimo): # finché non ho raggiunto la fine della mia sequenza
print primo # stampa l'attuale primo numero

prossimo = (primo + secondo) # calcola il prossimo numero
primo = secondo # avanza alla prossima posizione
secondo = prossimo # per entrambi i valori temporanei

indice = (indice + 1) # incrementa l'indice (siamo appena andati avanti di una posizione)

by_to_by

16-06-2008, 22:30

DanieleC88

16-06-2008, 22:33

Ho solo detto che, avendo iniziato prima, è normale che io mi trovi un po' più avanti come allenamento... Dai tempo al tempo, non puoi dire che non ce la fai finché non ci hai provato: non scoraggiarti prima ancora di iniziare! :)

by_to_by

16-06-2008, 22:44

ma comunque rileggendo il codice che ho trovato non capisco, leggo quello tuo si. quello tuo è più conciso e semplice (e non conosci python, non capisco come fai). in quello che ho trovato io print è messo all'ultimo e il count + 1 all'inizio. ci sono quattro passaggi per memorizzare i due valori vecchi tu invece ne hai fatti 3

DanieleC88

16-06-2008, 22:53

(e non conosci python, non capisco come fai).
Python per fortuna non ha una sintassi intricata come potrebbero averla altri linguaggi: fosse stato in un dialetto assembly a me sconosciuto, mi sarei sparato prima! :D
È molto simile a come avrei fatto in C o in Pascal o altri linguaggi, ho solo "mimato" lo stile del codice che leggevo dagli esempi tuoi o di altri. :)
in quello che ho trovato io print è messo all'ultimo e il count + 1 all'inizio. ci sono quattro passaggi per memorizzare i due valori vecchi tu invece ne hai fatti 3
Io ho messo il print all'inizio per farti vedere che effettivamente ciò che viene stampato è il valore iniziale di a (che nell'altro codice prima veniva salvato come "vecchio valore di a"), solo per renderlo un po' più immediato. In effetti non capisco perché stamparlo alla fine... :D

L'incremento che io ho spostato alla fine, e nel loro codice è all'inizio, non ha importanza dove si trovi, l'importante è che venga fatto (poteva pure stare nel bel mezzo del blocco). L'ho messo alla fine solo per farti capire che in tutto il blocco non viene mai utilizzato, e lo aggiorno solo in vista del prossimo controllo della condizione del while.

Nel codice che hai trovato tu erano salvati entrambi i vecchi valori, e poi aggiornati i nuovi: li ho ridotti a tre per il solo fatto che "si poteva evitare", quindi per toglierti di mezzo una variabile di fatto superflua. :)

by_to_by

17-06-2008, 10:05

by_to_by

17-06-2008, 10:09

È molto simile a come avrei fatto in C o in Pascal o altri linguaggi, ho solo "mimato" lo stile del codice che leggevo dagli esempi tuoi o di altri.

conosci un sacco di linguaggi, ma come mai ne hai cambiati cosi tanti?

o ho messo il print all'inizio per farti vedere che effettivamente ciò che viene stampato è il valore iniziale di a (che nell'altro codice prima veniva salvato come "vecchio valore di a"), solo per renderlo un po' più immediato. In effetti non capisco perché stamparlo alla fine...

ma come è che non c'è differenza tra metterlo all'inizio e alla fine il print?

L'incremento che io ho spostato alla fine, e nel loro codice è all'inizio, non ha importanza dove si trovi, l'importante è che venga fatto (poteva pure stare nel bel mezzo del blocco). L'ho messo alla fine solo per farti capire che in tutto il blocco non viene mai utilizzato, e lo aggiorno solo in vista del prossimo controllo della condizione del while.

perchè non ha importanza? non dovrebbe essere una cosa regolare da fare? perchè va bene dovunque?

Nel codice che hai trovato tu erano salvati entrambi i vecchi valori, e poi aggiornati i nuovi: li ho ridotti a tre per il solo fatto che "si poteva evitare", quindi per toglierti di mezzo una variabile di fatto superflua.

e del codice che hotrovato io la variabile temporanea superflkua sarebbe old_a = a?

inoltre tu la somma l'hai fatta prima di fare avanzare i valori, nel codice che ho fatto io invece è fatta all'ultimo del blocco di codice

DanieleC88

17-06-2008, 11:27

conosci un sacco di linguaggi, ma come mai ne hai cambiati cosi tanti?
Per vari motivi, un po' per la voglia di "esplorare", un po' perché i linguaggi sono strumenti, se ne usa uno particolare a seconda di ciò che devi fare.
ma come è che non c'è differenza tra metterlo all'inizio e alla fine il print?
Metterlo all'inizio e stampare a o metterlo alla fine e stampare old_a non farà altro che stampare comunque lo stesso valore (che sarebbe poi il valore iniziale di a).
perchè non ha importanza? non dovrebbe essere una cosa regolare da fare? perchè va bene dovunque?
Va bene ovunque perché l'informazione contenuta in quella variabile viene valutata solo come condizione del ciclo, quindi al resto delle istruzioni contenute in quel blocco non importa dove sia incrementata, basta che prima della fine del ciclo venga incrementata. ;)

Prima capisci bene quel codice che hai trovato, vedi come funziona e capisci perché è equivalente al mio codice "minimizzato": dopo ti farò vedere come sia possibile togliere di mezzo ancora una variabile! (ma non pensarci ancora, poi ti farò vedere, è semplice comunque) :D
e del codice che hotrovato io la variabile temporanea superflkua sarebbe old_a = a?
Sì, esatto, non c'è bisogno di usare due valori che ricordino i precedenti stati se non verranno più usati dal codice (spostando il print all'inizio non hai più bisogno di ricordare cosa contenesse a all'inizio, siccome lo usi immediatamente). Basta una sola variabile temporanea a cui appoggiarsi per "avanzare" nella sequenza.
inoltre tu la somma l'hai fatta prima di fare avanzare i valori, nel codice che ho fatto io invece è fatta all'ultimo del blocco di codice
Proprio per quello che ti dicevo giusto un attimo fa: se stampi il valore iniziale di a quando sei appena entrato nel ciclo, non hai più bisogno di appoggiarti a valori temporanei e poi effettuare la somma, puoi salvarla in una nuova variabile (temporanea) e poi aggiornare.

ciao ;)

by_to_by

17-06-2008, 12:16

alcuen cose le ho capite, altre no

il codice comunque l'ho osservato, quale altra variabile si può eliminare?

Per vari motivi, un po' per la voglia di "esplorare", un po' perché i linguaggi sono strumenti, se ne usa uno particolare a seconda di ciò che devi fare.

però è buono cambiare linguaggio cosi senza saperne bene bene uno? o senza imparare a programmare come si deve? e poi in base a cosa decidi quale linguaggio utilizzatre a seconda di ciò che devi fare?

variabilepippo

17-06-2008, 12:22

però è buono cambiare linguaggio cosi senza saperne bene bene uno? o senza imparare a programmare come si deve? e poi in base a cosa decidi quale linguaggio utilizzatre a seconda di ciò che devi fare?

Se fossi in te, per il momento, mi concentrerei su Python. La necessità di studiare altri linguaggi verrà automaticamente... Come giustamente detto da Daniele i linguaggi sono strumenti, quindi serve un po' di esperienza e un po' di buonsenso per usare(/imparare) quello più adatto ad un dato scopo. Con Python puoi risolvere buona parte dei problemi di programmazione che ti si porranno da qui a qualche anno. ;)

DanieleC88

17-06-2008, 12:30

Se fossi in te, per il momento, mi concentrerei su Python. La necessità di studiare altri linguaggi verrà automaticamente... Come giustamente detto da Daniele i linguaggi sono strumenti, quindi serve un po' di esperienza e un po' di buonsenso per usare(/imparare) quello più adatto ad un dato scopo. Con Python puoi risolvere buona parte dei problemi di programmazione che ti si porranno da qui a qualche anno. ;)
Mi hai tolto le parole di bocca, stavo giusto per scrivergli questo! :D
alcuen cose le ho capite, altre no
Che dubbi ti restano? Dimmi. :)
il codice comunque l'ho osservato, quale altra variabile si può eliminare?
Siccome devi solo raggiungere un numero massimo di posizioni, ma visto che il calcolo che effettui non tiene conto della posizione attuale, e si basa invece solo sui due precedenti valori, al posto di due variabili (una la posizione attuale ed una la posizione massima), puoi usarne una che ti dica "quanti cicli devi ancora fare", decrementandola di ciclo in ciclo finché non si azzera. :)

rimanenti = 20
while (rimanenti > 0):
# eccetera eccetera...
rimanenti = (rimanenti - 1)

;)

by_to_by

17-06-2008, 13:57

Se fossi in te, per il momento, mi concentrerei su Python. La necessità di studiare altri linguaggi verrà automaticamente... Come giustamente detto da Daniele i linguaggi sono strumenti, quindi serve un po' di esperienza e un po' di buonsenso per usare(/imparare) quello più adatto ad un dato scopo. Con Python puoi risolvere buona parte dei problemi di programmazione che ti si porranno da qui a qualche anno. ;)

si, ma prendendo come esempio daniele, anche se ha iniziato anni fa, era ed è pur sempre un ragazzo, non programma, penso, a livelli tuoi o altri aocnra quindi perchè cambiare cosi tanti linguaggi? l'importante impararne bene uno come dici tu e poi cambiarlo quando c'è la necessità e comunque in base a cosa scegli i linguaggio che ti serve per determinate cose?

anche se cmq mi chiedo sempre come è possibile che per ogni cosa c'è un linguaggio. alla fine se faccio un programma cahe calcola fibonacci in python lo posso fare anche in tutti gli altrl linguaggi

~FullSyst3m~

17-06-2008, 13:58

Mi hai tolto le parole di bocca, stavo giusto per scrivergli questo! :D

Che dubbi ti restano? Dimmi. :)

Siccome devi solo raggiungere un numero massimo di posizioni, ma visto che il calcolo che effettui non tiene conto della posizione attuale, e si basa invece solo sui due precedenti valori, al posto di due variabili (una la posizione attuale ed una la posizione massima), puoi usarne una che ti dica "quanti cicli devi ancora fare", decrementandola di ciclo in ciclo finché non si azzera. :)

rimanenti = 20
while (rimanenti > 0):
# eccetera eccetera...
rimanenti = (rimanenti - 1)

;)

Mi hai anticipato! :D

DanieleC88

17-06-2008, 14:03

si, ma prendendo come esempio daniele, anche se ha iniziato anni fa, era ed è pur sempre un ragazzo, non programma, penso, a livelli tuoi o altri aocnra quindi perchè cambiare cosi tanti linguaggi?
Per curiosità. :)
anche se cmq mi chiedo sempre come è possibile che per ogni cosa c'è un linguaggio. alla fine se faccio un programma cahe calcola fibonacci in python lo posso fare anche in tutti gli altrl linguaggi
La sequenza di Fibonacci sì, la puoi fare dove ti pare.
Ma, esempio idiota: fammi un bootloader in Python... :D
Oppure, gestiscimi un database in assembly. Magari puoi farlo... ma sarebbe da pazzi. :)

variabilepippo

17-06-2008, 14:19

si, ma prendendo come esempio daniele, anche se ha iniziato anni fa, era ed è pur sempre un ragazzo, non programma, penso, a livelli tuoi o altri aocnra quindi perchè cambiare cosi tanti linguaggi? l'importante impararne bene uno come dici tu e poi cambiarlo quando c'è la necessità e comunque in base a cosa scegli i linguaggio che ti serve per determinate cose?

Te l'ho detto, i linguaggi si scelgono (tra quelli noti) in base al problema da risolvere, ad eventuali vincoli di progetto e all'esperienza maturata. E' un po' come imparare a viaggiare, inizialmente impari a camminare, poi passi alla bici, al motorino, all'automobile... Chi ne ha bisogno può prendere l'aereo, la nave, lo Shuttle, etc. Poi c'è chi odia spostarsi in aereo, chi preferisce muoversi sempre a piedi, chi usa la stessa automobile per tutta la vita! ;) Ovviamente sta al tipo di viaggio da fare, ai tempi, all'esperienza, al buonsenso scegliere un mezzo piuttosto che un altro. Per esempio, se dovessi andare a trovare il tuo vicino di casa prenderesti la macchina o l'aereo? Credo di no. Così come se dovessi andare a trovare i tuoi zii in America probabilmente opteresti per l'aereo o per la nave e lo faresti tenendo in considerazione: tempi, costi/benefici, etc. Un discorso molto simile vale per i linguaggi di programmazione... Se devi sviluppare un gestionale difficilmente lo scrivi in Assembly, così come se hai bisogno di un programma da eseguire su più piattaforme non scegli un linguaggio legato a doppio nodo ad un particolare sistema operativo.

Comunque, se sei alle prime armi, non ti conviene porti questo genere di problemi, impara Python, quando (SE!) un giorno ti starà "stretto" puoi sempre decidere di studiare un nuovo linguaggio.

anche se cmq mi chiedo sempre come è possibile che per ogni cosa c'è un linguaggio. alla fine se faccio un programma cahe calcola fibonacci in python lo posso fare anche in tutti gli altrl linguaggi

Bravo, se conosci un solo linguaggio e con quello puoi risolvere facilmente un problema non devi necessariamente usarne un altro. Ci sono linguaggi definiti "general purpose" (non dedicati ad un solo possibile utilizzo) come il Python, il Java, il C++ con i quali puoi implementare "quasi" tutto.

cdimauro

17-06-2008, 22:56

@cdimauro
non importa quando è nato l'uso dell'or e dell'and in quella maniera..
E' nato da parecchio tempo: http://it.wikipedia.org/wiki/Logica_booleana

Simbologia

Gli operatori dell'algebra booleana possono essere rappresentati in vari modi, oltre a quello adottato in precedenza consistente nel servirsi dei loro nomi AND, OR, NOT. Le diverse simbologie sono scelte in base al campo in cui si lavora.

I matematici usano spesso il simbolo + per l'OR, e × per l'AND, in quanto per alcuni versi questi operatori lavorano in modo analogo alla somma e alla moltiplicazione. La negazione NOT viene rappresentata spesso da una linea disegnata sopra l'argomento della negazione, cioè dell'espressione che deve essere negata.

Nella progettazione di circuiti elettronici, vengono utilizzati anche gli operatori brevi NAND (AND negato), NOR (OR negato) e XNOR (XOR negato); questi operatori, come XOR, sono delle combinazioni dei tre operatori base e quindi non costituiscono un arricchimento della specie di strutture, vengono usati solo per rendere la notazione più semplice.

Operatori:
NOT - simboli alternativi: x, ~, ¬, !
AND - simboli alternativi: AND: *, AND, ^, BUT (usato nella logica brasiliana insieme al NOT)
OR - simboli alternativi: OR: +, OR, v
XOR - simboli alternativi: XOR: +, ⊕, ∨, ^, EOR, orr
NAND - simboli alternativi: NAND, ↑
NOR - simboli alternativi: NOR, ↓
XNOR

Valori:
vero - simboli alternativi: true, 1, ON, SI (YES)
falso - simboli alternativi: false, 0, OFF, NO

Da notare che &, &&, | e || non sono contemplati neppure fra i simboli alternativi... :O
un linguaggio moderno (come java per esempio) dovrebbe impedire con qualsiasi mezzo la scrittura di codice incomprensibile :p *
Dove starebbe "l'incomprensibilità"?
se poi per te basta scrivere "and" al posto di && perchè il codice sia "pulito".. il simbolo è solo un simbolo, la sua importanza è secondaria rispetto alla semantica che si porta dietro.
Infatti la sematica è ben definita. E' stata semplicemente estesa, oltre che per gli interi (infatti i booleani in Python derivano dalla classe int), anche per gli altri tipi di dato esistenti in quest linguaggio, in modo da offrire un modello "omogeneo".
infatti gran parte dei linguaggi oggi usa ||, && e compagnia
Soltanto perché sono di derivazione C. Non per altro.

Tant'è che nella simbologia di cui sopra questa cianfrusaglia non è nemmeno contemplata.
* se trovo il link al post di PGI-bis sui generici in java te lo mando in pvt :asd:
Dovrei averlo già letto, ma se lo ritrovi mi farebbe piacere rileggerlo. :)
io questo lo chiamo codice sporco :fagiano:
Io no:
Dato = cursor.fetch() #prelevo un dato dal db
print Dato or "Spiacente, la birra e' finita perche' e' passato Cyrano poco fa..."
:cool:

by_to_by

18-06-2008, 08:29

Te l'ho detto, i linguaggi si scelgono (tra quelli noti) in base al problema da risolvere, ad eventuali vincoli di progetto e all'esperienza maturata. E' un po' come imparare a viaggiare, inizialmente impari a camminare, poi passi alla bici, al motorino, all'automobile... Chi ne ha bisogno può prendere l'aereo, la nave, lo Shuttle, etc. Poi c'è chi odia spostarsi in aereo, chi preferisce muoversi sempre a piedi, chi usa la stessa automobile per tutta la vita! ;) Ovviamente sta al tipo di viaggio da fare, ai tempi, all'esperienza, al buonsenso scegliere un mezzo piuttosto che un altro. Per esempio, se dovessi andare a trovare il tuo vicino di casa prenderesti la macchina o l'aereo? Credo di no. Così come se dovessi andare a trovare i tuoi zii in America probabilmente opteresti per l'aereo o per la nave e lo faresti tenendo in considerazione: tempi, costi/benefici, etc. Un discorso molto simile vale per i linguaggi di programmazione... Se devi sviluppare un gestionale difficilmente lo scrivi in Assembly, così come se hai bisogno di un programma da eseguire su più piattaforme non scegli un linguaggio legato a doppio nodo ad un particolare sistema operativo.

Comunque, se sei alle prime armi, non ti conviene porti questo genere di problemi, impara Python, quando (SE!) un giorno ti starà "stretto" puoi sempre decidere di studiare un nuovo linguaggio.

Bravo, se conosci un solo linguaggio e con quello puoi risolvere facilmente un problema non devi necessariamente usarne un altro. Ci sono linguaggi definiti "general purpose" (non dedicati ad un solo possibile utilizzo) come il Python, il Java, il C++ con i quali puoi implementare "quasi" tutto.

non credo che arriverò mai a sviluppare un gestionale... comunque spero che è come dici tu, perchè ora come ora mi sembrano tutti gli stessi i linguaggi

k0nt3

18-06-2008, 12:19

E' nato da parecchio tempo: http://it.wikipedia.org/wiki/Logica_booleana

...

Da notare che &, &&, | e || non sono contemplati neppure fra i simboli alternativi... :O

quindi dovremmo continuare a usare una semantica sbagliata perchè è nata tanto tempo fa? :stordita:
gli operatori &, &&, | e || sono usati comunemente solo in informatica.. meno male che wikipedia non è legge :D

Dove starebbe "l'incomprensibilità"?

ad esempio nel fatto che
'b' == ('a' and 'b')
restutuisce true
mentre:
'b' == ('b' and 'a')
restutuisce false
se è vero che l'operatore and gode della proprietà commutativa (e mi sembra che è vero) questo comportamento è abbastanza curioso

71104

18-06-2008, 13:14

se è vero che l'operatore and gode della proprietà commutativa (e mi sembra che è vero) questo comportamento è abbastanza curioso in Python non ne gode; è questo che è poco comprensibile (risposta per cdimauro).

meno male che wikipedia non è legge :D anzi, ben lungi dall'esserlo: Wikipedia è solo un posto dove la gente scrive :D

cdimauro

18-06-2008, 13:32

non credo che arriverò mai a sviluppare un gestionale... comunque spero che è come dici tu, perchè ora come ora mi sembrano tutti gli stessi i linguaggi
Mai dire mai. Fattelo dire da uno che non avrebbe mai voluto lavorare con DB, e alla fine ci lavora spesso (anzi, devo dire che mi trovo benissimo a definire db). Che non avrebbe mai voluto sviluppare gestionali, e per anni c'ha lavorato (continuo a esserne disgustato; ma mi hanno permesso di tirare avanti con la famiglia). Che non avrebbe mai voluto sviluppare applicazioni web, e per diverso tempo c'ha lavorato (qui mi sono defilato per fortuna :D). Ecc. ecc. ecc.

Poi ogni cosa a cui ho lavorato ha contribuito ad arricchire il mio know-how. Nel bene e nel male.

Oggi ovviamente tante cose non le farei, ma col senno di poi è facile parlare. :p
quindi dovremmo continuare a usare una semantica sbagliata perchè è nata tanto tempo fa? :stordita:
Dovrei capire dov'è che sarebbe sbagliata, però: le parole, da sole, non bastano. ;)
gli operatori &, &&, | e || sono usati comunemente solo in informatica.. meno male che wikipedia non è legge :D
La logica esiste da più di duemila anni, e non è un caso che si sia parlato di CONNETTIVI LOGICI. :O

"Casualmente" quelli usati sono sempre stati "e", "o", "no/non", "se-allora". Dico casualmente perché la "e" non è che serva esclusivamente per ELENCARE delle cose: dipende dal contesto.

Ciò giustifica la scelta effettuata da alcuni linguaggi: perfettamente in sintonia sia con la tradizione che con la lingua. :cool:
ad esempio nel fatto che
'b' == ('a' and 'b')
restutuisce true
mentre:
'b' == ('b' and 'a')
restutuisce false
se è vero che l'operatore and gode della proprietà commutativa (e mi sembra che è vero) questo comportamento è abbastanza curioso
Infatti non è vero, perché viene utilizzata la SHORT CIRCUIT EVALUATION, com'è attestato nella definizione del linguaggio. SCE che viene utilizzata anche in tanti altri linguaggi (indovina cosa usano C & derivati :D) per questioni di ottimizzazione. :cool:

P.S. Su Wikipedia non così facile fare modifiche come si possa credere. Provare per credere (io è da più di un mese che sto aspettando che alcune mie modifiche siano "rilasciate", in attesa che le formuli secondo precisi criteri).

marco.r

18-06-2008, 13:41

in Python non ne gode; è questo che è poco comprensibile (risposta per cdimauro).

In praticamente nessun linguaggio di programmazione di alto livello lo sono, tranne forse il Pascal (e qui cdimauro sapra' sicuramente precisare meglio). In tutti gli altri sono implementati come operatori short-circuit.
D'altra parte, come gia' detto, parliamo di linguaggi di programmazione general purpose, e non di sistemi di risoluzione di equazioni booleane.

bool foo()
{
cout << "Io sono FOO" << endl;
return true;
}

bool boo()
{
cout << "Io sono BOO" << endl;
return true;
}

if ( foo() || boo() )
{
cout << "Io vengo sempre stampato" << endl;
}

Stampa

Io sono FOO
Io vengo sempre stampato

mentre

bool foo()
{
cout << "Io sono FOO" << endl;
return true;
}

bool boo()
{
cout << "Io sono BOO" << endl;
return true;
}

if ( boo() || foo() )
{
cout << "Io vengo sempre stampato" << endl;
}

stampa

Io sono BOO
Io vengo sempre stampato

marco.r

18-06-2008, 13:51

Infatti non è vero, perché viene utilizzata la SHORT CIRCUIT EVALUATION, com'è attestato nella definizione del linguaggio. SCE che viene utilizzata anche in tanti altri linguaggi (indovina cosa usano C & derivati :D) per questioni di ottimizzazione. :cool:

Mi hai anticipato :p.
Per inciso non e' solo una questione di ottimizzazione, ma anche di comodita'. Raramente in una catena di or uno e' interessato ad eseguire il codice relativo alla parte che non serve. Anzi di solito si vuole il contrario, che del codice venga eseguito esattamente solo se serve e la SCE e' un must.
In altri casi ancora la cosa e' assolutamente indifferente e non da fastidio.
un uso classico e' quello di verificare la validita' di un oggetto e quindi usarlo

if foo and foo.bar():
...

o in C++

if ( foo && foo->bar() )
{ ... }

I puristi dell'OO magari obietteranno che e' meglio un Null Object pattern, ma mi sembrerebbe come il classico lanciamissili per uccidere una mosca.

~FullSyst3m~

18-06-2008, 14:03

Mi piace troppo quando cdimauro parla!

cdimauro

18-06-2008, 14:04

x marco.r Ovviamente concordo in toto. :p

Per il Pascal nello standard non è prevista la SCE, mentre nella famiglia Turbo Pascal & derivati è presente di default.

by_to_by

18-06-2008, 14:06

Mai dire mai. Fattelo dire da uno che non avrebbe mai voluto lavorare con DB, e alla fine ci lavora spesso (anzi, devo dire che mi trovo benissimo a definire db). Che non avrebbe mai voluto sviluppare gestionali, e per anni c'ha lavorato (continuo a esserne disgustato; ma mi hanno permesso di tirare avanti con la famiglia). Che non avrebbe mai voluto sviluppare applicazioni web, e per diverso tempo c'ha lavorato (qui mi sono defilato per fortuna :D). Ecc. ecc. ecc.

Poi ogni cosa a cui ho lavorato ha contribuito ad arricchire il mio know-how. Nel bene e nel male.

Oggi ovviamente tante cose non le farei, ma col senno di poi è facile parlare. :p

Dovrei capire dov'è che sarebbe sbagliata, però: le parole, da sole, non bastano. ;)

La logica esiste da più di duemila anni, e non è un caso che si sia parlato di CONNETTIVI LOGICI. :O

"Casualmente" quelli usati sono sempre stati "e", "o", "no/non", "se-allora". Dico casualmente perché la "e" non è che serva esclusivamente per ELENCARE delle cose: dipende dal contesto.

Ciò giustifica la scelta effettuata da alcuni linguaggi: perfettamente in sintonia sia con la tradizione che con la lingua. :cool:

Infatti non è vero, perché viene utilizzata la SHORT CIRCUIT EVALUATION, com'è attestato nella definizione del linguaggio. SCE che viene utilizzata anche in tanti altri linguaggi (indovina cosa usano C & derivati :D) per questioni di ottimizzazione. :cool:

P.S. Su Wikipedia non così facile fare modifiche come si possa credere. Provare per credere (io è da più di un mese che sto aspettando che alcune mie modifiche siano "rilasciate", in attesa che le formuli secondo precisi criteri).

io non credo che lo farò mai per altir motivi. comunque tu o vuoi o non vuoi le hai imparate quelle cose e sai fare di tutto di più. hai anche modificato delle voci su wikipedia quindi la tua conoscenza è enorme. è vero, è da una vita che fai queste cose e studi. però non mi sento molto sicuro che anche io diventi cosi, o più o meno bravo

Infatti non è vero, perché viene utilizzata la SHORT CIRCUIT EVALUATION, com'è attestato nella definizione del linguaggio. SCE che viene utilizzata anche in tanti altri linguaggi (indovina cosa usano C & derivati ) per questioni di ottimizzazione.

questo non l'ho capito, potresti dirmi in parole semplici cosa è?

I puristi dell'OO magari obietteranno che e' meglio un Null Object pattern, ma mi sembrerebbe come il classico lanciamissili per uccidere una mosca.

cosa è il null object pattern?
per il resto, non c'ho capito un h del codice di marco.r

Albi89

18-06-2008, 14:13

Per inciso non e' solo una questione di ottimizzazione, ma anche di comodita'. Raramente in una catena di or uno e' interessato ad eseguire il codice relativo alla parte che non serve. Anzi di solito si vuole il contrario, che del codice venga eseguito esattamente solo se serve e la SCE e' un must.

Verissimo, ma si guadagna anche leggibilità con le and.
if (ptr != NULL && ptr->func()) {
...
}

Quì addirittura rischieremmo di far zompare tutto il programmozzo =P

by_to_by

18-06-2008, 14:15

Verissimo.
if (ptr != NULL && ptr->func()) {
...
}

Quì addirittura rischieremmo di far zompare tutto il programmozzo =P

che significa zompare. comunque tu sai cosa è SCE? lo hai studiato all'uni?

cmq non ho capito nulla del tuo codice e poi è C?

k0nt3

18-06-2008, 15:08

Verissimo, ma si guadagna anche leggibilità con le and.
if (ptr != NULL && ptr->func()) {
...
}

Quì addirittura rischieremmo di far zompare tutto il programmozzo =P
il problema qui è che non stai usando la programmazione a oggetti, altrimenti questa soluzione sarebbe da evitare

ps. infatti tale comportamento mi sorprende solo perchè python dovrebbe essere di alto livello

La logica esiste da più di duemila anni, e non è un caso che si sia parlato di CONNETTIVI LOGICI. :O

"Casualmente" quelli usati sono sempre stati "e", "o", "no/non", "se-allora". Dico casualmente perché la "e" non è che serva esclusivamente per ELENCARE delle cose: dipende dal contesto.

Ciò giustifica la scelta effettuata da alcuni linguaggi: perfettamente in sintonia sia con la tradizione che con la lingua. :cool:
di simboli per denotare and, or e compagnia ne sono stati usati a migliaia, questo sì che dipende dal contesto.
se invece mi parli della semantica.. devi sapere che se la fai dipendere dal contesto le cose si complicano non poco. in sè non c'è niente di male, ma se è vero che python dovrebbe essere un linguaggio semplice allora non raggiunge l'obiettivo.

Infatti non è vero, perché viene utilizzata la SHORT CIRCUIT EVALUATION, com'è attestato nella definizione del linguaggio. SCE che viene utilizzata anche in tanti altri linguaggi (indovina cosa usano C & derivati :D) per questioni di ottimizzazione. :cool:

separiamo le questioni di ottimizzazione dalle questioni semantiche.. non mi risulta che in C/C++ o Java succeda che:
'b' == ('a' and 'b')
restituisca true

che io sappia in questi linguaggi l'and (ma anche l'or) gode della proprietà commutativa (a meno che non venga lanciata un'eccezione a runtime, cosa che comunque può accadere in ogni istante dell'esecuzione del programma)

DanieleC88

18-06-2008, 15:47

comunque tu sai cosa è SCE?
Semplicemente con la short circuit evaluation, se verifichi due o più condizioni in and tra di loro e trovi che la prima è falsa, non serve nemmeno che venga valutata la seconda: la condizione è già falsificata di suo. In maniera molto simile, se verifichi due o più condizioni in or tra di loro e trovi che la prima è vera, senza neanche valutare le altre puoi dire subito che tutta la condizione è verificata.

marco.r

18-06-2008, 18:49

cosa è il null object pattern?
per il resto, non c'ho capito un h del codice di marco.r
Sorry, cerchero' di essere piu' chiaro facendo un esempio terra terra.
Facciamo conto che ho un oggetto che mi rappresenta un cane. Per farlo abbaiare scrivo qualcosa tipo

cane = Pluto()
...
cane.abbaia()

In realta' le cose sono piu' complicate perche' in alcuni casi puo' essere che non ci sia alcun cane, e prima di farlo abbaiare devo verificare che effettivamente esista, altrimenti il computer s'incavola:

cane = cuccia.occupante()
if cane:
cane.abbaia()

Si puo' ottenere la stessa cosa usando un and

cane = cuccia.occupante()
cane and cane.abbaia()

Questo perche' la parte a destra dell'and non viene eseguita se non e' soddisfatta quella a sinistra, ed e' l'essenza dell'SCE.
I puristi della programmazione orientata agli oggetti dicono che cosi' non va bene, e che il cane ci deve essere sempre. Se manca se ne usa uno di virtuale che fa solo finta di abbaiare. In questo modo io posso semplicemente scrivere

cane = cuccia.occupante()
cane.abbaia()

E' il concetto del Null Object: il cane c'e' comunque, ma non fa niente.

In generale e' una soluzione piu' bella, solo che ha i suoi inconvenienti, perche' non sempre si e' d'accordo sul cosa vuol dire non fare niente: se lascio cadere un "oggetto che non fa nulla" dalla finestra, non fa nulla per opporsi alla gravita' e cade al suolo o non fa nulla per cadere e rimane a mezz'aria ? Dipende dal contesto, ma quello lo sa chi il vaso lo lascia andare, non il vasaio che glielo vende.
Spero di essere stato chiaro :D

by_to_by

18-06-2008, 19:59

Sorry, cerchero' di essere piu' chiaro facendo un esempio terra terra.
Facciamo conto che ho un oggetto che mi rappresenta un cane. Per farlo abbaiare scrivo qualcosa tipo

cane = Pluto()
...
cane.abbaia()

In realta' le cose sono piu' complicate perche' in alcuni casi puo' essere che non ci sia alcun cane, e prima di farlo abbaiare devo verificare che effettivamente esista, altrimenti il computer s'incavola:

cane = cuccia.occupante()
if cane:
cane.abbaia()

Si puo' ottenere la stessa cosa usando un and

cane = cuccia.occupante()
cane and cane.abbaia()

Questo perche' la parte a destra dell'and non viene eseguita se non e' soddisfatta quella a sinistra, ed e' l'essenza dell'SCE.
I puristi della programmazione orientata agli oggetti dicono che cosi' non va bene, e che il cane ci deve essere sempre. Se manca se ne usa uno di virtuale che fa solo finta di abbaiare. In questo modo io posso semplicemente scrivere

cane = cuccia.occupante()
cane.abbaia()

E' il concetto del Null Object: il cane c'e' comunque, ma non fa niente.

In generale e' una soluzione piu' bella, solo che ha i suoi inconvenienti, perche' non sempre si e' d'accordo sul cosa vuol dire non fare niente: se lascio cadere un "oggetto che non fa nulla" dalla finestra, non fa nulla per opporsi alla gravita' e cade al suolo o non fa nulla per cadere e rimane a mezz'aria ? Dipende dal contesto, ma quello lo sa chi il vaso lo lascia andare, non il vasaio che glielo vende.
Spero di essere stato chiaro :D

un pò contorto, ma mezzo chiaro.. mezzo però

71104

18-06-2008, 21:21

bool foo()
{
cout << "Io sono FOO" << endl;
return true;
}

bool boo()
{
cout << "Io sono BOO" << endl;
return true;
}

if ( foo() || boo() )
{
cout << "Io vengo sempre stampato" << endl;
}

Stampa

Io sono FOO
Io vengo sempre stampato

mentre

bool foo()
{
cout << "Io sono FOO" << endl;
return true;
}

bool boo()
{
cout << "Io sono BOO" << endl;
return true;
}

if ( boo() || foo() )
{
cout << "Io vengo sempre stampato" << endl;
}

stampa

Io sono BOO
Io vengo sempre stampato

si, ed è il lazy or, ma questo non invalida la proprietà commutativa: il contenuto dell'if viene eseguito o meno negli stessi identici casi anche se inverto le chiamate a foo e boo.

cdimauro

18-06-2008, 21:34

io non credo che lo farò mai per altir motivi. comunque tu o vuoi o non vuoi le hai imparate quelle cose e sai fare di tutto di più. hai anche modificato delle voci su wikipedia quindi la tua conoscenza è enorme. è vero, è da una vita che fai queste cose e studi. però non mi sento molto sicuro che anche io diventi cosi, o più o meno bravo
Come dicevo prima: mai dire mai. ;)

Comunque le modifiche su Wikipedia ancora non ci sono: sto aspettando di recuperare una fonte per renderle "verificabili". In ogni caso è roba che non c'entra nulla con l'informatica. :p
il problema qui è che non stai usando la programmazione a oggetti, altrimenti questa soluzione sarebbe da evitare
Ah. E dimmi, allora: con la programmazione a oggetti come faresti? Se la soluzione è NullObject pattern, t'ha risposto Marco, in maniera molto chiara.

Altrimenti, aspetto che tu mi dica cosa intendi con ciò.
ps. infatti tale comportamento mi sorprende solo perchè python dovrebbe essere di alto livello
Lo è sicuramente molto di più di tanti linguaggi più o meno blasonati.

Comunque rispondi alla domanda di cui sopra, e poi vedremo come Python si comporta in merito. :cool:
di simboli per denotare and, or e compagnia ne sono stati usati a migliaia, questo sì che dipende dal contesto.
Si parlava di logica, mi pare. Chiedi ai logici quali simboli hanno usato e usano... :O
se invece mi parli della semantica.. devi sapere che se la fai dipendere dal contesto le cose si complicano non poco. in sè non c'è niente di male, ma se è vero che python dovrebbe essere un linguaggio semplice allora non raggiunge l'obiettivo.
Mi sembra normale che dipendi dal contesto, e ciò a prescindere dal linguaggio utilizzato.

Secondo te l'origine principale dei bug qual è?
separiamo le questioni di ottimizzazione dalle questioni semantiche.. non mi risulta che in C/C++ o Java succeda che:
'b' == ('a' and 'b')
restituisca true

che io sappia in questi linguaggi l'and (ma anche l'or) gode della proprietà commutativa (a meno che non venga lanciata un'eccezione a runtime, cosa che comunque può accadere in ogni istante dell'esecuzione del programma)
Sembra male a te:
f("a") && g("b")
ovviamente f e g sono funzioni o metodi, che possono fare QUALUNQUE cosa al loro interno.

Mi sembra che basti come spiegazione.

Per maggiori informazioni puoi esaminare il K&R per il C o lo Strustrup per il C++ (su Java non mi sono mai interessato alla fonte "ufficiale").
si, ed è il lazy or, ma questo non invalida la proprietà commutativa: il contenuto dell'if viene eseguito o meno negli stessi identici casi anche se inverto le chiamate a foo e boo.
In tal caso, però, l'output del programma non sarà corretto.

Con ciò voglio dire: se l'or e l'and sono commutativi, il compilatore ha piena libertà di poter utilizzare questa proprietà per riorganizzare l'Abstract Syntax Tree come gli pare. Peccato, però, che cambiando l'ordine cambia anche la semantica, e dunque il risultato finale.

Ecco perché la SCE NON può essere considerata una proprietà transitiva: a causa di eventuali effetti collaterali nella valutazione delle espressioni booleane, il risultato può cambiare. E questo non è ammissibile, perché ottimizzare il codice significa che l'applicazione deve rispondere agli stessi input con gli stessi output (ovviamente ferme restando le condizioni d'esecuzione del codice).

k0nt3

18-06-2008, 22:01

Ah. E dimmi, allora: con la programmazione a oggetti come faresti? Se la soluzione è NullObject pattern, t'ha risposto Marco, in maniera molto chiara.

Altrimenti, aspetto che tu mi dica cosa intendi con ciò.

non c'è un solo modo, in ogni caso il NullObject pattern va benissimo per esempio e non ha nessun inconveniente (se non quello di istanziare un oggetto in più).
infatti anche senza usare il NullObject pattern bisogna stabilire come comportarsi di fronte a un oggetto non istanziato ed il problema si ripresenta tale e quale.

Si parlava di logica, mi pare. Chiedi ai logici quali simboli hanno usato e usano... :O

il tuo odio verso gli operatori usati dal C è ingiustificato :Prrr: sono solo dei simboli. sarebbe stato uguale se avessero usato § per AND e @ per OR
i simboli una volta definiti non danno nessuna noia. la definizione della loro semantica invece è molto più importante

Mi sembra normale che dipendi dal contesto, e ciò a prescindere dal linguaggio utilizzato.

non è normale nella logica, lo so che nella programmazione la dipendenza dal contesto conta. ma stiamo parlando di un operatore logico e quindi mi aspetto che si comporti con le leggi della logica

Secondo te l'origine principale dei bug qual è?

la complessità dei linguaggi

Sembra male a te:
f("a") && g("b")
ovviamente f e g sono funzioni o metodi, che possono fare QUALUNQUE cosa al loro interno.

Mi sembra che basti come spiegazione.
e perchè non soddisfa la proprietà commutativa? quell'espressione è vera se e solo se f è vera e g è vera anche se cambi l'ordine

marco.r

18-06-2008, 22:10

si, ed è il lazy or, ma questo non invalida la proprietà commutativa: il contenuto dell'if viene eseguito o meno negli stessi identici casi anche se inverto le chiamate a foo e boo.

:mbe:
A me sembra la dimostrazione concreta che la invalida. Se non ti piace perche' fa uso dei side-effects prendi uno degli esempi precedenti e portalo in C,C++ o Java:
[code]
string* s = 0;
if ( s && s->size() )
{ }

Non commuta affatto con

string* s = 0;
if ( s->size() && s )
{ }

Il problema si presenta pure in Java dove && e || accettano solo booleani.
Se non la pensate cosi' datemi la vostra definizione di commutativita' che ne discutiamo :p.

k0nt3

18-06-2008, 22:17

:mbe:
A me sembra la dimostrazione concreta che la invalida. Se non ti piace perche' fa uso dei side-effects prendi uno degli esempi precedenti e portalo in C,C++ o Java:
[code]
string* s = 0;
if ( s && s->size() )
{ }

Non commuta affatto con

string* s = 0;
if ( s->size() && s )
{ }

Il problema si presenta pure in Java dove && e || accettano solo booleani.
Se non la pensate cosi' datemi la vostra definizione di commutativita' che ne discutiamo :p.

il problema qui è che:
s->size() && s
non viene affatto valutata a causa di un errore nel codice (putatore a null)
se fosse possibile valutarla l'ordine non cambierebbe il risultato dell'espressione.
il caso di python è molto diverso visto che l'espressione _viene valutata_ in due modi diversi solo cambiando l'ordine delle variabili in gioco dentro l'AND

ps. se noti le scorciatoie usate dal compilatore non cambiano di una virgola le tabelle di verità degli operatori, di conseguenza valgono tutte le proprietà come le abbiamo studiate in logica

marco.r

18-06-2008, 22:19

si, ed è il lazy or, ma questo non invalida la proprietà commutativa: il contenuto dell'if viene eseguito o meno negli stessi identici casi anche se inverto le chiamate a foo e boo.

Adesso ho capito meglio cosa intendi dire.
Al di la' del fatto che se cambia come si comporta il programma secondo me non commutano, a prescindere dal fatto che il corpo venga eseguito o meno, e' possibile costruire un esempio in cui l'esecuzione del corpo dell'if cambia a seconda dell'ordine:

string* s = 0;
if ( s == 0 || s->size() )
{
/* blah blah
}

Esegue il codice, mentre

string* s = 0;
if (s->size() || s == 0 )
{
/* blah blah
}

Si pianta (e non esegue il codice). Se lo fai in Java in un caso il codice viene eseguito e nell'altro viene lanciata un'eccezione.

by_to_by

18-06-2008, 23:06

cosa è puntatore a null?

Adesso ho capito meglio cosa intendi dire.
Al di la' del fatto che se cambia come si comporta il programma secondo me non commutano, a prescindere dal fatto che il corpo venga eseguito o meno, e' possibile costruire un esempio in cui l'esecuzione del corpo dell'if cambia a seconda dell'ordine:

string* s = 0;
if ( s == 0 || s->size() )
{
/* blah blah
}

Esegue il codice, mentre

string* s = 0;
if (s->size() || s == 0 )
{
/* blah blah
}

Si pianta (e non esegue il codice). Se lo fai in Java in un caso il codice viene eseguito e nell'altro viene lanciata un'eccezione.

non ci sto capendo niente

DanieleC88

18-06-2008, 23:16

cosa è puntatore a null?
Riducendo, è un puntatore alla locazione 0 in memoria, lo si usa per distinguere tra puntatori a zone di memoria inizializzate (staticamente o dinamicamente) e zone di memoria non inizializzate.
non ci sto capendo niente
E non è necessario che tu lo faccia, ancora, non farci caso. ;)

cdimauro

18-06-2008, 23:21

non c'è un solo modo, in ogni caso il NullObject pattern va benissimo per esempio e non ha nessun inconveniente (se non quello di istanziare un oggetto in più).
infatti anche senza usare il NullObject pattern bisogna stabilire come comportarsi di fronte a un oggetto non istanziato ed il problema si ripresenta tale e quale.
Ne abbiamo già parlato, e l'ha ribadito Marco poco fa: non esiste un unico modo per creare NullObject.

Può essere che te ne serva uno che non faccia nulla, o uno che sollevi un'eccezione, o ancora uno che torni particolari valori: le possibilità sono infinite, e un compilatore non può decidere quale sia la scelta... del progettista (che, tra l'altro, può benissimo avere esigenze diverse in casi d'uso diversi per la STESSA classe).

Dunque il problema permane, e non mi hai detto cosa c'entra la programmazione a oggetti, visto che non apporta benefici al problema. Ma soprattutto: non si capisce perché ti lamenti di Python, che può benissimo implementare anche i NullObject.
il tuo odio verso gli operatori usati dal C è ingiustificato :Prrr: sono solo dei simboli. sarebbe stato uguale se avessero usato § per AND e @ per OR
i simboli una volta definiti non danno nessuna noia. la definizione della loro semantica invece è molto più importante
E' giustificato perché sono illeggibili e confusionari.

Poi mi dovresti spiegare perché i creatori del C hanno preferito adottare dei simboli completamente nuovi quando la letteratura in materia ha qualcosa come 2500 anni: gli faceva proprio schifo adattarsi alla tradizione? O facevano a gara quale accozzaglia di simboli inventarsi per i nuovi operatori?
non è normale nella logica, lo so che nella programmazione la dipendenza dal contesto conta. ma stiamo parlando di un operatore logico e quindi mi aspetto che si comporti con le leggi della logica
Lo fa. Basta tener presente il significato che diamo al concetto di "valore di verità".
la complessità dei linguaggi
Semplicemente e banalmente falso, perché un linguaggio semplicissimo come whitespace tende a far commettere una quantità abnorme di errori rispetto a linguaggi molto più complicati, come potrebbe essere Python.
e perchè non soddisfa la proprietà commutativa? quell'espressione è vera se e solo se f è vera e g è vera anche se cambi l'ordine
E allora, definizione di commutatività alla mano, che il compilatore cambi pure l'ordine degli operandi, giusto?

Poi non lamentiamoci se vengono introdotti subdoli bug nel codice, eh!

Ovviamente sono totalmente d'accordo con Marco. ;)

marco.r

19-06-2008, 00:17

il problema qui è che:
s->size() && s
non viene affatto valutata a causa di un errore nel codice (putatore a null)
se fosse possibile valutarla l'ordine non cambierebbe il risultato dell'espressione.
il caso di python è molto diverso visto che l'espressione _viene valutata_ in due modi diversi solo cambiando l'ordine delle variabili in gioco dentro l'AND

C'e' una questione fondamentale che continui ad ignorare, la stessa che sto ripetendo da diverse pagine: non stiamo parlando di espressioni booleane, ma di computazioni, il che come minimo, anche restando in ambito teorico, aggiunge che una espressione oltre ai valori previsti (True e False ad esempio) puo' assumere un altro valore, "indefinito" (mi sembra che il termine esatto sia "bottom" ma sono un po' arrugginito :p) ad indicare ad esempio che la computazione diverge (Immagina l'espressione di lunghezza infinita False OR ( True AND (False OR (True AND ... )
Possiamo far finta che il problema non esista, pero' lo vedo come un nascondere la testa sotto la sabbia...

La tabella di verita' per l'operatore && in Java diventa

+-------+-------+-------+-------+
| AND | F | T | ind |
+-------+-------+-------+-------+
| F | F | F | F |
| T | F | T | ind |
| ind | ind | ind | ind |
+-------+-------+-------+-------+

Nota che
- nel caso la restringiamo a {T,F} torna ad essere l'AND booleano che conosciamo.
- non e' commutativa (F AND ind == F ma ind AND f == ind). Ciononostante e' quel che si usa di solito perche' quell'"F" in piu' non fa che comodo ed e' comunque consistente con l'AND booleano.

In python viene generalizzato un po' di piu:

+-----------+-------+------------+-------+
| AND | F | y (non F) | ind |
+-----------+-------+------------+-------+
| F | F | F | F |
| x (non F) | F | y | ind |
| ind | ind | ind | ind |
+-----------+-------+------------+-------+

dove con F intendiamo False,[],0,None, e non F tutto il resto
Ancora una volta l'operatore non e' commutativo, ma la definizione e' assolutamente consistente con quella booleana perche' sui booleani si comporta esattamente allo stesso modo.

Detto questo mi sembra di essermi dilungato pure troppo, se volete continuare a parlare di logica booleana fate pure :p.

cdimauro

19-06-2008, 07:44

In effetti ci siamo dilungati anche troppo sull'argomento.

Se non si vuole capire che quando si parla di logica questa NON coincide per forza di cose con quella booleana, stiamo perdendo soltanto tempo: magari un po' di studio in materia male non farebbe.

E non servirebbe neppure andare fuori dall'informatica "spicciola" per comprendere il concetto di logica a n stati (con n > 2): chi ha studiato SQL dovrebbe aver imparato da un pezzo che la tradizionale valutazione delle espressioni (anche booleane) cambia del tutto con l'introduzione dei "valori" (per meglio dire simboli) NULL e UNKNOWN...

by_to_by

19-06-2008, 08:28

C'e' una questione fondamentale che continui ad ignorare, la stessa che sto ripetendo da diverse pagine: non stiamo parlando di espressioni booleane, ma di computazioni, il che come minimo, anche restando in ambito teorico, aggiunge che una espressione oltre ai valori previsti (True e False ad esempio) puo' assumere un altro valore, "indefinito" (mi sembra che il termine esatto sia "bottom" ma sono un po' arrugginito :p) ad indicare ad esempio che la computazione diverge (Immagina l'espressione di lunghezza infinita False OR ( True AND (False OR (True AND ... )
Possiamo far finta che il problema non esista, pero' lo vedo come un nascondere la testa sotto la sabbia...

La tabella di verita' per l'operatore && in Java diventa

+-------+-------+-------+-------+
| AND | F | T | ind |
+-------+-------+-------+-------+
| F | F | F | F |
| T | F | T | ind |
| ind | ind | ind | ind |
+-------+-------+-------+-------+

Nota che
- nel caso la restringiamo a {T,F} torna ad essere l'AND booleano che conosciamo.
- non e' commutativa (F AND ind == F ma ind AND f == ind). Ciononostante e' quel che si usa di solito perche' quell'"F" in piu' non fa che comodo ed e' comunque consistente con l'AND booleano.

In python viene generalizzato un po' di piu:

+-----------+-------+------------+-------+
| AND | F | y (non F) | ind |
+-----------+-------+------------+-------+
| F | F | F | F |
| x (non F) | F | y | ind |
| ind | ind | ind | ind |
+-----------+-------+------------+-------+

dove con F intendiamo False,[],0,None, e non F tutto il resto
Ancora una volta l'operatore non e' commutativo, ma la definizione e' assolutamente consistente con quella booleana perche' sui booleani si comporta esattamente allo stesso modo.

Detto questo mi sembra di essermi dilungato pure troppo, se volete continuare a parlare di logica booleana fate pure :p.

il giapponese credo sia più facile

banryu79

19-06-2008, 08:40

k0nt3

19-06-2008, 09:21

Ne abbiamo già parlato, e l'ha ribadito Marco poco fa: non esiste un unico modo per creare NullObject.

Può essere che te ne serva uno che non faccia nulla, o uno che sollevi un'eccezione, o ancora uno che torni particolari valori: le possibilità sono infinite, e un compilatore non può decidere quale sia la scelta... del progettista (che, tra l'altro, può benissimo avere esigenze diverse in casi d'uso diversi per la STESSA classe).

Dunque il problema permane, e non mi hai detto cosa c'entra la programmazione a oggetti, visto che non apporta benefici al problema. Ma soprattutto: non si capisce perché ti lamenti di Python, che può benissimo implementare anche i NullObject.

ehm.. hai letto quello che ho scritto?
per prima cosa la programmazione OO c'entra perchè
if(object && object.whatever())
non è programmare a oggetti
python non c'entra niente in questo caso, e non ho scritto il contrario da nessun'altra parte.
riguardo al NullObject pattern il compilatore non deve fare nulla, tutto il compito lo deve svolgere il programmatore. ma a parte il fatto che viene creato un oggetto in più non cambia niente rispetto alla soluzione senza NullObject pattern. o forse c'è qualche formula magica per trattare nella maniera giusta i puntatori a null?
questo è il tipico esempio dove qualche riga di codice in più rende il codice migliore sotto ogni punto di vista

E' giustificato perché sono illeggibili e confusionari.
considerazione del tutto soggettiva

Poi mi dovresti spiegare perché i creatori del C hanno preferito adottare dei simboli completamente nuovi quando la letteratura in materia ha qualcosa come 2500 anni: gli faceva proprio schifo adattarsi alla tradizione? O facevano a gara quale accozzaglia di simboli inventarsi per i nuovi operatori?

simboli erano e simboli rimangono. non è vero che la letteratura in materia ha una maniera univoca per denotare gli operatori logici. ci sono molteplici letterature e una di queste è quella del C che ha senso di esistere come tutte le altre.
la stessa domanda allora potrei porla ai logici francesi.. perchè usano simboli diversi per denotare l'inclusione e l'inclusione stretta?
perchè in inghilterra guidano a sinistra?
una volta le chiamavano convenzioni

Lo fa. Basta tener presente il significato che diamo al concetto di "valore di verità".
cosa c'è di contestuale nel valore di verità? le tabelle di verità non hanno nessuna dipendenza dal contesto. l'and di due termini ad esempio è vero se e solo se tutti e due i termini sono veri indipendentemente dal risultato della finale degli europei

Semplicemente e banalmente falso, perché un linguaggio semplicissimo come whitespace tende a far commettere una quantità abnorme di errori rispetto a linguaggi molto più complicati, come potrebbe essere Python.
cosa c'entra whitespace -_- i linguaggi sono complicati per loro natura, ma se ad esempio uso un linguaggio che permette solo somme fra interi ti sfido a commettere un errore :D ovviamente l'espressività va a quel paese

E allora, definizione di commutatività alla mano, che il compilatore cambi pure l'ordine degli operandi, giusto?

Poi non lamentiamoci se vengono introdotti subdoli bug nel codice, eh!

Ovviamente sono totalmente d'accordo con Marco. ;)
...
no
la tabella di verità per l'operatore AND in c/c++ e java è:

T F
T 1 0
F 0 0

esattamente come ce l'hanno insegnata i logici.
poi sappiamo tutti che un programma può interrompersi in qualsiasi momento (non solo durante la valutazione di un'espressione booleana), ma questo non ci azzecca niente con la valutazione delle espressioni. infatti se il programma si interrompe l'espressione non viene valutata. se l'espressione viene valutata allora rispetta la tabella di verità che ho scritto sopra. questo non significa che non stiamo parlando di logica booleana, altrimenti tutte le documentazioni di tutti i linguaggi sarebbero sbagliate (compresa quella di python http://docs.python.org/ref/Booleans.html).

detto questo avete cercato in tutti i modi di sviare il discorso verso le ottimizzazioni che compie il compilatore per valutare le espressioni booleane e ci siete pure riusciti. ma lo ripeto:
queste ottimizzazioni non cambiano di una virgole le tabelle di verità degli operatori.
il mio discorso non c'entra niente con queste ottimizzazioni quindi. io contestavo il fatto che in python:

'b' == ('a' or 'b')

retituisce false, mentre

'b' == ('b' or 'a')

retituisce true

questo in qualche modo è contro la proprietà commutativa dell'or (che vale per tutte le strutture algebriche utili, cioè anelli e derivati).
tutto questo per scrivere una riga di codice in meno...
non so voi, ma secondo me è una caratteristica che non andrebbe usata mai perchè fa precipitare la leggibilità dell'espressione.
è curioso che un linguaggio di alto livello richieda la conoscenza dei meccanismi interni dell'interprete (cioè l'ordine con cui valuta gli operandi degli operatori logici). dovrebbe astrarre completamente da queste cose

by_to_by

19-06-2008, 10:19

DanieleC88

19-06-2008, 10:26

A tal proposito vi chiedo: la logica booleana è una scelta obbligata in un linguaggio di programmazione?
Ovvero, perchè è stata scelta proprio la logica booleana (ammesso che ne fossero di altre altrettanto valide da essere prese in considerazione)?
Be', credo che sia una scelta "quasi" obbligata e sicuramente ragionevole, perché con una giusta composizione dei connettivi della logica booleana e dei costrutti di un linguaggio di programmazione puoi valutare anche condizioni più estese, come se ne faceva esempio prima. Se poi un linguaggio introduce anche altre forme a questo tipo di valutazioni che possano fare al caso nostro, ben venga.
Poi, nella maggior parte dei casi, la riduzione ai due casi Vero/Falso è una questione di praticità: avendo come esempio i puntatori, puoi valutare che il puntatore sia NULL (o 0, o False) o che non lo sia. Nel caso che non lo sia, usando un'interpretazione logica con più di due valori, che valore gli assegneresti? :D
Potresti ammettere per Vero tutto ciò che è "NOT Falso", quindi magari anche un valore "Indefinito", ma mi sembrerebbe un po' una forzatura logica.

ciao ;)

by_to_by

19-06-2008, 11:51

Be', credo che sia una scelta "quasi" obbligata e sicuramente ragionevole, perché con una giusta composizione dei connettivi della logica booleana e dei costrutti di un linguaggio di programmazione puoi valutare anche condizioni più estese, come se ne faceva esempio prima. Se poi un linguaggio introduce anche altre forme a questo tipo di valutazioni che possano fare al caso nostro, ben venga.
Poi, nella maggior parte dei casi, la riduzione ai due casi Vero/Falso è una questione di praticità: avendo come esempio i puntatori, puoi valutare che il puntatore sia NULL (o 0, o False) o che non lo sia. Nel caso che non lo sia, usando un'interpretazione logica con più di due valori, che valore gli assegneresti? :D
Potresti ammettere per Vero tutto ciò è "NOT Falso", quindi magari anche un valore "Indefinito", ma mi sembrerebbe un po' una forzatura logica.

ciao ;)

sei un ragazzo prodigio, non ci sono dubbi. :ave:

banryu79

19-06-2008, 11:53

@ by_to_by:
beh, non tutto da autodidatta: ho lavorato 1 anno e 1/2 a un progetto a contatto con due programmatori con 20 anni di esperienza alle spalle; prima la mi azienda mi ha dato la possibilità di seguire un corso customizzato di C++ della durata di 6 mesi tenuto presso il Dipartimento di Ingegneria Meccanica della mia città, seguito da un dottorando e un asistente.

@DanieleC88:

Poi, nella maggior parte dei casi, la riduzione ai due casi Vero/Falso è una questione di praticità: avendo come esempio i puntatori, puoi valutare che il puntatore sia NULL (o 0, o False) o che non lo sia. Nel caso che non lo sia, usando un'interpretazione logica con più di due valori, che valore gli assegneresti?

Ovviamete true, ma nel caso dei valori nei campi di una tabella di database, per cui si citava ad esempio NULL e UNKNOWN, il problema era l'alternativo a quello citato da te: il dubbio nasce nei casi in cui il valore sia NOT TRUE per cui non c'è/non basta un solo valore (false) ma esistono più possibilità (NULL != UNKNOWN).

@EDIT:

Potresti ammettere per Vero tutto ciò (che) è "NOT Falso", quindi magari anche un valore "Indefinito", ma mi sembrerebbe un po' una forzatura logica

Quindi UNKNOWN lo mappiamo a False. Credo però dipenda dal contesto.

cdimauro

19-06-2008, 14:34

Molto interessante questa discussione ragazzi, scusate il post inutile, però per uno come me che non ha preso la laurea ed è quindi a digiuno di certe conoscenze, è stato molto utile assistere a questo scambio di post.

In particolare gli ultimi e il post di marco.r con le due tabelle di verità: mi ha permesso di cogliere una sottigliezza che (pasatemi il termine) "ignoravo ma intuivo" dopo appunto aver passato le ultime settimane a stretto contatto con SQL a causa dei due valori NULL e UNKNOWN (giustamente citati da cdimauro).

A tal proposito vi chiedo: la logica booleana è una scelta obbligata in un linguaggio di programmazione?
No, ma dipende dal linguaggio e dal tipo di applicazione.
Ovvero, perchè è stata scelta proprio la logica booleana (ammesso che ne fossero di altre altrettanto valide da essere prese in considerazione)?
Perché si mappa(va) perfettamente col funzionamento dei primi circuiti elettrici usati, e cioé lasciar passare la corrente oppure no. Una logica prettamente binaria, che si sposa alla perfezione con quella booleana.
ehm.. hai letto quello che ho scritto?
La prendo come fosse una domanda retorica. :O
per prima cosa la programmazione OO c'entra perchè
if(object && object.whatever())
non è programmare a oggetti
Ah, no? E sarebbe allora?
python non c'entra niente in questo caso, e non ho scritto il contrario da nessun'altra parte.

Avevi scritto questo:

il problema qui è che non stai usando la programmazione a oggetti, altrimenti questa soluzione sarebbe da evitare
ps. infatti tale comportamento mi sorprende solo perchè python dovrebbe essere di alto livello

Adesso, cortesemente, mi spieghi che c'entra Python e il perché di quella battuta sull'"alto livello"?
riguardo al NullObject pattern il compilatore non deve fare nulla, tutto il compito lo deve svolgere il programmatore. ma a parte il fatto che viene creato un oggetto in più non cambia niente rispetto alla soluzione senza NullObject pattern.
Il punto, se non ti fosse ancora chiaro dopo tutto quello che abbiamo scritto sull'argomento, è che non si tratta di un solo oggetto in più. Tutt'altro.

E' questo il grosso problema del NullObject. Che sulla carta trovo semplicemente meraviglioso concettualmente, ma praticamente è di difficile realizzazione se il linguaggio non offre dei meccanismi con cui è possibile costruire NullObject appropriati a seconda del contesto.
o forse c'è qualche formula magica per trattare nella maniera giusta i puntatori a null?
Le formule magiche sono bandite dall'informatica: esistono solo casi d'uso e "best practice". :cool:
questo è il tipico esempio dove qualche riga di codice in più rende il codice migliore sotto ogni punto di vista
Opinabile, sopratutto sul "migliore".

La soluzione prospettata da Marco è condivisibilissima.
considerazione del tutto soggettiva
Ma anche no, visto che fra un && e un and una certa differenza c'è. Inoltre passare da && a & o viceversa è una ben nota causa d'errori con linguaggi C-like, tant'è che in Java hanno forzato l'uso coi soli... booleani. Chissà perché... :O
simboli erano e simboli rimangono. non è vero che la letteratura in materia ha una maniera univoca per denotare gli operatori logici. ci sono molteplici letterature e una di queste è quella del C che ha senso di esistere come tutte le altre.
la stessa domanda allora potrei porla ai logici francesi.. perchè usano simboli diversi per denotare l'inclusione e l'inclusione stretta?
perchè in inghilterra guidano a sinistra?
una volta le chiamavano convenzioni
Ecco, appunto: c'erano già da tempo, e non si capisce perché inventarne di nuove. Soprattutto di contorte.

Poi se conosci la storia del C dovresti ben sapere qual è l'origine di quei simboli e i criteri usati per definirli.
cosa c'è di contestuale nel valore di verità? le tabelle di verità non hanno nessuna dipendenza dal contesto. l'and di due termini ad esempio è vero se e solo se tutti e due i termini sono veri indipendentemente dal risultato della finale degli europei
Qui, tanto per cambiare, passi dalla logica alla logica booleana. Infatti affermi allegramente che ti aspetti che l'and restituisca True, ma questo è quello che TU vorresti ritornasse, visto che per te sembra esistere soltanto una logica: quella a due valori.

Il mondo, però, non gira tutto così: basta guardare oltre il proprio orticello e si aprono orizzonti completamente diversi (e arricchenti).
cosa c'entra whitespace -_- i linguaggi sono complicati per loro natura, ma se ad esempio uso un linguaggio che permette solo somme fra interi ti sfido a commettere un errore :D ovviamente l'espressività va a quel paese
Whitespace lavora soltanto con gli interi, infatti.

L'espressività lasciala stare, perché è inutile ai fini del discorso che si stava facendo.

no
la tabella di verità per l'operatore AND in c/c++ e java è:

T F
T 1 0
F 0 0

esattamente come ce l'hanno insegnata i logici.
Quali logici? I booleani? Perché, come ti dicevo, i logici da qualche millennio non hanno avuto difficoltà a concepire e sviluppare logiche diverse da quella binaria/booleana.
poi sappiamo tutti che un programma può interrompersi in qualsiasi momento (non solo durante la valutazione di un'espressione booleana), ma questo non ci azzecca niente con la valutazione delle espressioni. infatti se il programma si interrompe l'espressione non viene valutata. se l'espressione viene valutata allora rispetta la tabella di verità che ho scritto sopra. questo non significa che non stiamo parlando di logica booleana, altrimenti tutte le documentazioni di tutti i linguaggi sarebbero sbagliate (compresa quella di python http://docs.python.org/ref/Booleans.html).
Da quel link ti sarà sfuggito questo:

In the context of Boolean operations, and also when expressions are used by control flow statements, the following values are interpreted as false: False, None, numeric zero of all types, and empty strings and containers (including strings, tuples, lists, dictionaries, sets and frozensets). All other values are interpreted as true.

Infatti si parla correttamente di valutazione degli operandi, non di conversione a True o False.

Su and e or, poi, è perfettamente chiara la spiegazione del loro funzionamento, con tanto di esempietto pratico.
detto questo avete cercato in tutti i modi di sviare il discorso verso le ottimizzazioni che compie il compilatore per valutare le espressioni booleane e ci siete pure riusciti.
Ci mancherebbe: conoscendo abbastanza bene come funzionano i vari linguaggi trattati, nonché la storia della logica, è il minimo.
ma lo ripeto:
queste ottimizzazioni non cambiano di una virgole le tabelle di verità degli operatori.
Indubbiamente. Ma un conto è il risultato della VALUTAZIONE degli operandi, e tutt'altro ciò che l'operatore deve RESTITUIRE.

Differenza inesistente per chi associa sempre la prima alla seconda, ma... così facendo si commette un grosso errore.
il mio discorso non c'entra niente con queste ottimizzazioni quindi. io contestavo il fatto che in python:

'b' == ('a' or 'b')

retituisce false, mentre

'b' == ('b' or 'a')

retituisce true
Lo è perché nella VALUTAZIONE dell'espressione logica il valore di verità ASSOCIATO è sempre "True" perché è sufficiente il primo argomento per "risolvere" l'operazione. Posto ciò, l'operatore restituisce, appunto, il primo argomento.
questo in qualche modo è contro la proprietà commutativa dell'or (che vale per tutte le strutture algebriche utili, cioè anelli e derivati).
Proprietà che NON esiste con linguaggi che usano la SCE, come ti abbiamo già detto non poche volte, e che continui a non capire o, peggio ancora, a non voler capire.
tutto questo per scrivere una riga di codice in meno...
Non confondiamo le cose: gli operatori logici NON sono commutativi con NESSUN linguaggio che utilizzi la SCE, e Python è soltanto uno degli ultimi.

Sul Pascal standard non avrei nulla da dire: avresti ragione tu.
non so voi, ma secondo me è una caratteristica che non andrebbe usata mai perchè fa precipitare la leggibilità dell'espressione.
Specifica: per te.
è curioso che un linguaggio di alto livello richieda la conoscenza dei meccanismi interni dell'interprete (cioè l'ordine con cui valuta gli operandi degli operatori logici). dovrebbe astrarre completamente da queste cose
Questo perché è evidente che tu non abbia nemmeno mai aperto il K & R per il C, o lo Stroustrup per il C++, e in generale il manuale di riferimento di ogni linguaggio di programmazione (studiato), perché è scritto a chiare lettere come si comporta il LINGUAGGIO (e quindi NON l'interprete) anche in questi casi.

Un interprete (o compilatore) di un linguaggio X è tenuto a rispettare la definizione del linguaggio: se non lo fa, è fuori standard. Sic et simpliciter.
Quindi UNKNOWN lo mappiamo a False. Credo però dipenda dal contesto.
E dal linguaggio. :)

k0nt3

19-06-2008, 15:20

cdimauro

19-06-2008, 15:39

Secondo me dipende soltanto dal linguaggio: basta leggerne le specifiche e vedere cosa contempla in questi casi. :cool:

k0nt3

19-06-2008, 15:48

k0nt3

19-06-2008, 15:54

Secondo me dipende soltanto dal linguaggio: basta leggerne le specifiche e vedere cosa contempla in questi casi. :cool:

e il linguaggio come fa a sapere se NULL significa valore mancante, inamissibile
o nullo? :fagiano: dipende solo dall'applicazione
se il linguaggio fa delle ipotesi sul significato di NULL direi che mediamente nel 66% dei casi sbaglia :cool:

DanieleC88

19-06-2008, 16:06

Ovviamete true, ma nel caso dei valori nei campi di una tabella di database, per cui si citava ad esempio NULL e UNKNOWN, il problema era l'alternativo a quello citato da te: il dubbio nasce nei casi in cui il valore sia NOT TRUE per cui non c'è/non basta un solo valore (false) ma esistono più possibilità (NULL != UNKNOWN).
Certo, ma dipende tutto da ciò che intendi fare. Mi spiego: se progetti il tuo linguaggio in modo che venga inserito in un contesto dove i database sono di vitale importanza, è probabile, anzi, auspicabile che il linguaggio preveda forme di controllo per valori che hanno anche un range non binario (e che contemplino quindi il caso dell'UNKNOWN). Il problema viene dal fatto che di solito un linguaggio, a meno che non sia così specifico come ti dicevo prima, deve darti il modo di descrivere un problema e un algoritmo risolutivo nel caso più generale possibile. Per valori che non rientrano in True/False, quindi, potrebbe bastarti un case per distinguere tutti i possibili casi e agire di conseguenza. :)

DanieleC88

19-06-2008, 16:06

sei un ragazzo prodigio, non ci sono dubbi. :ave:
Ma assolutamente no, sono appena tornato dalla discussione di un progetto che non funzionava e che quindi ho dovuto rimandare al prossimo mese. :doh:
E già adesso si muore di caldo... pensa a luglio... :help:

cdimauro

19-06-2008, 20:13

tralascio di quotare tutto perchè mi interessa solo il punto focale, cioè come vengono usati l'OR e l'AND.
preciso una sola cosa da quello che mi hai quotato: il NullObject pattern non introduce nessun problema aggiuntivo. semplicemente quello che faresti nel caso in cui il puntatore sia NULL lo fai nel caso in cui l'oggetto sia NullObject.
l'unico strumento che serve per implementare un NullObject è la programmazione a oggetti. se il linguaggio è a oggetti non manca niente.
Non è così semplice, come ho già detto più volte, perché per una determinata classe puoi avere la necessità di istanziare n "NullObject" (a seconda degli usi che ne devi fare, come dicevo), e per far questo sarà necessario subclassare la classe padre almeno n - 1 volte (supponendo che la classe padre di per sé possa creare un NullObject con certi, precisi requisiti) modificandone opportunamente il comportamento, e infine istanziarla.

Ovviamente, come dici tu, con un linguaggio a oggetti si può fare, ma immagina lo scenario e prova a pensare al codice che dovresti scrivere: un po' troppo, vero?

Con particolari estensioni dei linguaggi a oggetti il lavoro potrebbe essere magari più semplice, ma... non mi risulta che ce ne siano che aiutino la definizione "rapida" di NullObject che hanno particolari comportamenti.
fino a qui potrebbe avere senso, se non fosse che quando aggiungi l'eguaglianza si rompe tutto e gli operatori perdono la proprietà commutativa. questa è una complicanza inutile IMHO. qualsiasi persona che legge un'espressione contenente un AND suppone che goda della proprietà commutativa, dover aggiungere regole su regole complica le cose inutilmente.
Supponi male, perché se un linguaggio specifica a chiare lettere che utilizza la SCE, per forza di cosa rinuncia alla proprietà commutativa.
ma io non sto parlando della SCE, smettila di sviare il discorso. la SCE come ho già spiegato non cambia di una virgola le tabelle di verità degli operatori, di conseguenza non possono cambiare di una virgola le proprietà degli operatori. sono solo ottimizzazioni, non cambiano la semantica.
Il problema è che non si tratta di due cose distinte, ma semplicemente LEGATE fra di loro: SCE e proprietà commutativa sono mutuamente esclusive.

Per quanto riguarda le tavole di verità di cui parli, queste funzionano benissimo, e servono a definire il COMPORTAMENTO DELL'OPERATORE, ma non il suo VALORE DI RITORNO.

Qui, come vedi, si tratta di due cose distinte, ma che tu continui a pensare siano la stessa. Non è così.
se io scrivo:

a=null
if(a.size() AND a)

il programma lancia un'eccezione ovviamente, ma questo non significa che l'AND vale 'indeterminato' piuttosto che TRUE piuttosto che FALSE. significa banalmente che non c'è stata alcuna valutazione perchè il programma ha lanciato un'eccezione.
invece:

a=null
if(a AND a.size())

viene valutata perchè "incidentalmente" riusciamo ad avere sufficienti informazioni per valutare l'espressione senza invocare a.size() che sarebbe l'errore nel codice.
ma ripeto: questo non c'entra niente con la semantica dell'operatore AND, infatti può capitare in qualsiasi istante che il programma termini per qualche motivo sconosciuto anche se il codice è:

a=null
if(a AND a.size())

ma questo non ha a che vedere con la semantica di AND (lo ripeto.. non si sa mai -_- )
OK, allora facciamo una cosa. Ti dimostro che con la SCE la proprietà commutativa non funziona. Lo faccio con l'esempio che tu stesso hai riportato:
a=null
if(a AND a.size())
cout << "FILLED!\n"
else
cout << "EMPTY!\n"
il cui output è ovviamente "EMPTY!".

Supponiamo ci sia la SCE, e che per assurdo valga anche la proprietà commutativa. Questo vuol dire che, scambiando di posto gli operandi, l'output deve rimanere esattamento lo stesso (per definizione di proprietà transitiva).

Se ciò è vero, allora il compilatore ha piena facoltà di scambiare di posto gli operandi. Quindi l'espressione di cui sopra viene riscritta (nell'Abstract Syntax Tree generato per essa) nella seguente forma:
a=null
if(a.size() AND a)
cout << "FILLED!\n"
else
cout << "EMPTY!\n"
il cui output però non solo non è "EMPTY!", ma nemmeno "FILLED!".

Quindi la proprietà commutativa NON può essere vera. E' falsa. C.V.D.

E questo anche per dimostrare che chi ha pensato alla SCE non si affidava alla "casualità", ma voleva proprio un comportamento ben determinato, anche a costo di rinunciare alla proprietà commutativa: i benefici sono chiaramente superiori a questa perdita.

In soldoni: non possiamo affidarci alla buona sorte, sperando che un compilatore decida di fare la scelta giusta per il nostro programma: il processo di generazione del codice DEVE essere deterministico.

Infine, devi capire una buona volta che la semantica dell'AND ha a che fare con il COMPORTAMENTO che deve tenere l'operatore, ma NON sul risultato che dev'essere RESTITUITO. Un conto è valutare (la bontà del)l'operazione e tutt'altra cosa è decidere cosa ritornare.
e il linguaggio come fa a sapere se NULL significa valore mancante, inamissibile
o nullo? :fagiano: dipende solo dall'applicazione
se il linguaggio fa delle ipotesi sul significato di NULL direi che mediamente nel 66% dei casi sbaglia :cool:
Non è il linguaggio che deve saperlo, ma chi ha deciso di definirlo in quel modo.

In Python la stringa vuota è VALUTATA come "False", mentre una stringa con almeno un carattere "vale" come "True". In altri linguaggi in entrambi i casi il "valore" è False.

Al solito, sono scelte che toccano al designer del linguaggio: può aver avuto le sue ragioni.

Io preferisco il "modello Python", perché lo trovo più coerente e sensato (e ci si arriva facilmente a capirlo quando si passa in rassegna il comportamento che ha con altri oggetti, come le tuple, le liste, i dizionari, i set, ecc., specialmente all'atto pratico, col codice di tutti i giorni).
Certo, ma dipende tutto da ciò che intendi fare. Mi spiego: se progetti il tuo linguaggio in modo che venga inserito in un contesto dove i database sono di vitale importanza, è probabile, anzi, auspicabile che il linguaggio preveda forme di controllo per valori che hanno anche un range non binario (e che contemplino quindi il caso dell'UNKNOWN). Il problema viene dal fatto che di solito un linguaggio, a meno che non sia così specifico come ti dicevo prima, deve darti il modo di descrivere un problema e un algoritmo risolutivo nel caso più generale possibile. Per valori che non rientrano in True/False, quindi, potrebbe bastarti un case per distinguere tutti i possibili casi e agire di conseguenza. :)
"Il case è il male" - fek

:D

DanieleC88

19-06-2008, 20:16

"Il case è il male" - fek

:D
D'oh! :doh:
Ma nemmeno il case posso più usare? :D (vabbe' che in effetti di solito non lo uso proprio io, ma...)

by_to_by

19-06-2008, 20:18

io non c'ho capito quasi niente, tu daniele per per resto sempre un prodigio, a questa età sapere tutte queste cose è da brivido. e se non hai saputo fare il progetto tu che sei cosi bravo dimmi tu che speranze ho io... soprattutto ora che lavoro e ho pochissimo tempo per studiare programmazione..azzo:muro:

cdimauro

19-06-2008, 20:20

D'oh! :doh:
Ma nemmeno il case posso più usare? :D (vabbe' che in effetti di solito non lo uso proprio io, ma...)
Se non lo usi, la pipeline del processore ringrazia, e... i benefici si faranno sentire. :cool:

DanieleC88

19-06-2008, 20:27

e se non hai saputo fare il progetto tu
Che c'entra, mica avevo solo il progetto da fare, e poi è colpa del C, mi sono perso un puntatore per strada... et voilà. :D
Se non lo usi, la pipeline del processore ringrazia, e... i benefici si faranno sentire. :cool:
Be', ma ti ripeto che io di solito non lo uso proprio, anche perché mi fa schifo a vederlo (:D), però se necessario...

cdimauro

19-06-2008, 20:33

Se necessario usa una tavola hash/dizionario/array associativo. ;)

DanieleC88

19-06-2008, 20:59

Anche per un caso minuscolo dove devo distinguere tra tre soli casi? :D

k0nt3

19-06-2008, 21:00

OK, allora facciamo una cosa. Ti dimostro che con la SCE la proprietà commutativa non funziona. Lo faccio con l'esempio che tu stesso hai riportato:
a=null
if(a AND a.size())
cout << "FILLED!\n"
else
cout << "EMPTY!\n"
il cui output è ovviamente "EMPTY!".

Supponiamo ci sia la SCE, e che per assurdo valga anche la proprietà commutativa. Questo vuol dire che, scambiando di posto gli operandi, l'output deve rimanere esattamento lo stesso (per definizione di proprietà transitiva).

Se ciò è vero, allora il compilatore ha piena facoltà di scambiare di posto gli operandi. Quindi l'espressione di cui sopra viene riscritta (nell'Abstract Syntax Tree generato per essa) nella seguente forma:
a=null
if(a.size() AND a)
cout << "FILLED!\n"
else
cout << "EMPTY!\n"
il cui output però non solo non è "EMPTY!", ma nemmeno "FILLED!".

Quindi la proprietà commutativa NON può essere vera. E' falsa. C.V.D.

mi risulta difficile che tu possa dimostrare qualcosa riguardo all'operatore AND quanto nell'ultimo codice che hai postato l'AND non viene nemmeno eseguito.
allora se scrivo questo codice:

int main()
{
int* b;
int c = 4;
int a = *(b=&c) + 5 + *b;
printf("%d", a);
return 0;
}

e poi questo:

int main()
{
int* b;
int c = 4;
int a = 5 + *b + *(b=&c);
printf("%d", a);
return 0;
}

e confronto i risultati.. concludo che l'addizione non gode della proprietà commutativa?
come vedi il problema non è nell'operatore, ma negli operandi. e soprattutto faccio notare per l'ennesima volta che la SCE non ci azzecca niente in tutto questo in quanto non altera in nessuna maniera la semantica degli operatori

by_to_by

19-06-2008, 21:18

Se non lo usi, la pipeline del processore ringrazia, e... i benefici si faranno sentire. :cool:

un case fa tutto questo?

comunque, come al solito non c'ho capito nulla. e che caz...

cdimauro

19-06-2008, 21:24

Anche per un caso minuscolo dove devo distinguere tra tre soli casi? :D
Sprecare un dizionario per soli tre casi sarebbe da galera. :D
mi risulta difficile che tu possa dimostrare qualcosa riguardo all'operatore AND quanto nell'ultimo codice che hai postato l'AND non viene nemmeno eseguito.
allora se scrivo questo codice:

int main()
{
int* b;
int c = 4;
int a = *(b=&c) + 5 + *b;
printf("%d", a);
return 0;
}

e poi questo:

int main()
{
int* b;
int c = 4;
int a = 5 + *b + *(b=&c);
printf("%d", a);
return 0;
}

e confronto i risultati.. concludo che l'addizione non gode della proprietà commutativa?
Qui, proprio perché l'addizione gode della proprietà commutativa, entrambi i programmi potrebbero generare lo stesso output. :cool:

Tra l'altro stai utilizzando qualcosa di pericoloso e altamente sconsigliata come pratica sia dal K & R che dallo Stroustrup.
come vedi il problema non è nell'operatore, ma negli operandi. e soprattutto faccio notare per l'ennesima volta che la SCE non ci azzecca niente in tutto questo in quanto non altera in nessuna maniera la semantica degli operatori
La semantica degli operatori te l'ho definita, e non è quella che ti aspettavi (in particolare, SICURAMENTE non vale la proprietà commutativa).
Spero che questo sia chiaro una volta per tutte. :O
un case fa tutto questo?
Sì. Diffida di chi ti suggerisce di usarlo allegramente: non sa quel che dice.
comunque, come al solito non c'ho capito nulla. e che caz...
Avrai tempo per farlo. Abbi fede (lo so: detto da un ateo fa ridere :asd:)

DanieleC88

19-06-2008, 21:24

un case fa tutto questo?
È un po' come se fosse una catena di if. Gli if hanno bisogno di "saltare" da un pezzo all'altro del codice per eseguire una cosa o un'altra a secondo della verità/falsità della loro condizione. Ovviamente, più salti, più l'esecuzione sequenziale va a farsi benedire. :D

In un programma qualsiasi non senti certo l'effetto per un if in più o in meno, ma in certi ambiti può essere utile ridurre al minimo il loro uso. ;)

~FullSyst3m~

19-06-2008, 21:53

Sprecare un dizionario per soli tre casi sarebbe da galera. :D

Qui, proprio perché l'addizione gode della proprietà commutativa, entrambi i programmi potrebbero generare lo stesso output. :cool:

Tra l'altro stai utilizzando qualcosa di pericoloso e altamente sconsigliata come pratica sia dal K & R che dallo Stroustrup.

La semantica degli operatori te l'ho definita, e non è quella che ti aspettavi (in particolare, SICURAMENTE non vale la proprietà commutativa).
Spero che questo sia chiaro una volta per tutte. :O

Sì. Diffida di chi ti suggerisce di usarlo allegramente: non sa quel che dice.

Avrai tempo per farlo. Abbi fede (lo so: detto da un ateo fa ridere :asd:)

Sono ateo anche io :asd:

~FullSyst3m~

19-06-2008, 21:56

È un po' come se fosse una catena di if. Gli if hanno bisogno di "saltare" da un pezzo all'altro del codice per eseguire una cosa o un'altra a secondo della verità/falsità della loro condizione. Ovviamente, più salti, più l'esecuzione sequenziale va a farsi benedire. :D

In un programma qualsiasi non senti certo l'effetto per un if in più o in meno, ma in certi ambiti può essere utile ridurre al minimo il loro uso. ;)

Mi hai anticipato, quoto in toto! ;)

k0nt3

19-06-2008, 22:04

Qui, proprio perché l'addizione gode della proprietà commutativa, entrambi i programmi potrebbero generare lo stesso output. :cool:
per scongiurare qualsiasi dubbio puoi ad esempio inizializzi l'area a cui punta b a 32. così nemmeno se la costellazione di orione si sovrappone alla costellazione del cigno puoi sperare che il risultato sia uguale :fagiano:
la conclusione è che l'addizione non gode della proprietà commutativa?

La semantica degli operatori te l'ho definita, e non è quella che ti aspettavi (in particolare, SICURAMENTE non vale la proprietà commutativa).
Spero che questo sia chiaro una volta per tutte. :O

se c'è qualcosa che non mi aspettavo è che: 'b' = ('a' AND 'b') restituisce true, tutto fuorchè intuitivo.

banryu79

20-06-2008, 09:57

Quindi UNKNOWN lo mappiamo a False. Credo però dipenda dal contesto.

E dal linguaggio.

secondo me dipende fortemente dal contensto e quindi da cosa significa NULL. potrebbe significare che il valore manca, che non è ammissibile o che semplicemente non c'è in quella tupla. a seconda dei casi potremmo decidere di sostituirlo con una stima, di ignorarlo o di considerare NULL un valore a sè stante

Secondo me dipende soltanto dal linguaggio: basta leggerne le specifiche e vedere cosa contempla in questi casi.

... poi è iniziata la "scazzottata" tra i due :O :D (tra l'altro interessante)

In effetti ora penso che dipenda sia dal linguaggio che dal contesto, oppure che dipenda dal contesto e quindi dal linguaggio.
La prima per i linguaggi generl purpose, la seconda per quelli più specializzati.
Come al solito una verità assoluta e cristallizata non è ragionevole, grazie per le vostre osservazioni.

~FullSyst3m~

20-06-2008, 10:28

... poi è iniziata la "scazzottata" tra i due :O :D (tra l'altro interessante)

In effetti ora penso che dipenda sia dal linguaggio che dal contesto, oppure che dipenda dal contesto e quindi dal linguaggio.
La prima per i linguaggi generl purpose, la seconda per quelli più specializzati.
Come al solito una verità assoluta e cristallizata non è ragionevole, grazie per le vostre osservazioni.

Tutti vorremmo verità assolute, ma in un campo come l'informatica, la programmazione nello specifico, non è molto facile questo ;)

banryu79

20-06-2008, 10:40

Tutti vorremmo verità assolute, ma in un campo come l'informatica, la programmazione nello specifico, non è molto facile questo ;)

No guarda, forse non mi sono espresso chiaramente: io di verità assolute non so che farmene :D

cdimauro

20-06-2008, 13:31

per scongiurare qualsiasi dubbio puoi ad esempio inizializzi l'area a cui punta b a 32. così nemmeno se la costellazione di orione si sovrappone alla costellazione del cigno puoi sperare che il risultato sia uguale :fagiano:
la conclusione è che l'addizione non gode della proprietà commutativa?
Non è che l'informatica possa andare avanti a forza di scongiuri, eh! :sgrat: :D

Allora, la dimostrazione di prima è cannata (in questi ultimi 5 giorni il dolore mi sta logorando la lucidità mentale): non ho usato nulla della SCE nel procedimento. Poco importa comunque: non se n'è accorto nessuno. :D

Tornando alla questione, sì, l'addizione gode della proprietà commutativa. Questa, però, NON è applicabile agli operatori and e or di Python, perché non viene restituito il valore di verità valutato, ma il primo argomento che ha permesso di "risolverlo".

Questo, comunque, poco importa perché la SCE in mezzo serve a garantire due cose:
- la corretta sequenza di valutazione dell'espressione (quindi l'ordine di valutazione degli operandi viene SEMPRE rispettato);
- la terminazione della valutazione degli operandi non appena si è acquisita sufficiente informazione.

Ciò serve proprio per evitare i pericoli di effetti collaterali. Pericolo che c'è, però, con gli altri operatori, e infatti anche l'addizione, pur godendo della proprietà commutativa, se vuoi evitare gli effetti collaterali degli esempi che hai riportato, devi fare come il K & R e lo Stroustrup suggeriscono: utilizzare variabili intermedie.

Tutto ciò ovviamente non è necessario con quei due operatori logici, perché è stata prevista proprio la SCE per queste eventualità.
se c'è qualcosa che non mi aspettavo è che: 'b' = ('a' AND 'b') restituisce true, tutto fuorchè intuitivo.
Non te lo aspetti tu, perché ti aspetti che l'operatore restituisca il valore di verità anziché l'operando che ha portato alla sua valutazione finale.

Succederebbe la stessa cosa se l'&& di C & derivati si comportasse allo stesso modo.

Ma questo non è l'unico, né tanto meno il modo "giusto" di procedere.

L'operatore logico, con o senza SCE, deve fare una cosa: garantire la consistenza logica dell'operazione, restituendo un risultato "adeguato".

In C potrebbe essere sia il valore intero che ha reso possibile la valutazione dell'operazione, che il valore di verità. Gli ideatori del linguaggio hanno ritenuto opportuno scegliere la seconda. Quindi DOPO la valutazione dell'operazione, viene forzata la conversione al corrispondente valore di verità.

In Pascal e Java non si sono posti nemmeno questo problema, perché gli operatori logici lavorano esclusivamente coi booleani, per cui sia argomenti e loro valore di verità coincide.

In Python, contrariamente al C e a tanti altri linguaggi, si è deciso di restituire l'argomento anziché il corrisponde valore di verità.

Ogni scelta ha pregi e difetti, ovviamente.
Per Python il difetto è quello che hai evidenziato: non puoi scambiare l'ordine degli operandi, perché (eventualmente) cambia il risultato.
Il vantaggio, invece, è quello che ho evidenziato io: è possibile sfruttare l'operazione per risolvere "pattern" di codice in maniera molto semplice ed elegante.

Altra cosa da sottolineare, è che NON sempre è necessario ottenere il valore di verità delle operazioni logiche. Anzi, normalmente non serve proprio.
Ad esempio nelle espressioni condizionali usate per le istruzioni if, while, repeat, ecc. il valore di verità serve soltanto per decidere in che modo procedere, e subito dopo viene SCARTATO. Questo vuol dire che l'operazione di conversione molto probabilmente poteva essere scartata, poiché non utile.

Quindi la scelta di Python comporta anche un RISPARMIO sul costo dell'operazione.

Infine, nulla toglie che con Python, ove serva, si possa convertire il valore restituito dagli operatori logici in un booleano: con un semplice bool('a' and 'b') viene restituito True. Ma lo faccio SE E SOLO SE ciò mi è NECESSARIO.

Finora, in 3 anni e mezzo di sviluppo con Python, non mi è MAI stato necessario. Il che mi pare un indice di una buona scelta fatta da Guido per il suo linguaggio.
Ancora più buona se consideriamo che in questo modo ho potuto sfruttare le operazioni per i pattern di codice di cui parlavo prima. E questo mi è capitato DIVERSE VOLTE in quest'arco di tempo. :cool:

Il C e altri linguaggi che, non avendo booleani, hanno operato la scelta del valore di verità, devono, invece, sobbarcarsi SEMPRE il costo della conversione anche se... non sempre necessario. :O
... poi è iniziata la "scazzottata" tra i due :O :D (tra l'altro interessante)

In effetti ora penso che dipenda sia dal linguaggio che dal contesto, oppure che dipenda dal contesto e quindi dal linguaggio.
La prima per i linguaggi generl purpose, la seconda per quelli più specializzati.
Come al solito una verità assoluta e cristallizata non è ragionevole, grazie per le vostre osservazioni.
Dipende soltanto dal linguaggio: è chi lo crea che definisce sempre anche questi dettagli.

Se l'inventore lascia libertà di scelta in questi casi, il linguaggio diventa molto fragile e poco interessante per chi sviluppa, perché si trovare in balia delle varie implementazioni. Un vero inferno, insomma.

Se c'è una valore "assoluto" a cui i programmatori DEVONO affidarsi, è quello della rigorosa definizione dei linguaggi che utilizzano. ;)

~FullSyst3m~

20-06-2008, 13:38

No guarda, forse non mi sono espresso chiaramente: io di verità assolute non so che farmene :D

A quello che dice cdimauro però ti ci puoi, anzi DEVI, affidare! ;)

Se c'è una valore "assoluto" a cui i programmatori DEVONO affidarsi, è quello della rigorosa definizione dei linguaggi che utilizzano

k0nt3

20-06-2008, 13:49

Non è che l'informatica possa andare avanti a forza di scongiuri, eh! :sgrat: :D

Allora, la dimostrazione di prima è cannata (in questi ultimi 5 giorni il dolore mi sta logorando la lucidità mentale): non ho usato nulla della SCE nel procedimento. Poco importa comunque: non se n'è accorto nessuno. :D

Tornando alla questione, sì, l'addizione gode della proprietà commutativa. Questa, però, NON è applicabile agli operatori and e or di Python, perché non viene restituito il valore di verità valutato, ma il primo argomento che ha permesso di "risolverlo".

Questo, comunque, poco importa perché la SCE in mezzo serve a garantire due cose:
- la corretta sequenza di valutazione dell'espressione (quindi l'ordine di valutazione degli operandi viene SEMPRE rispettato);
- la terminazione della valutazione degli operandi non appena si è acquisita sufficiente informazione.

Ciò serve proprio per evitare i pericoli di effetti collaterali. Pericolo che c'è, però, con gli altri operatori, e infatti anche l'addizione, pur godendo della proprietà commutativa, se vuoi evitare gli effetti collaterali degli esempi che hai riportato, devi fare come il K & R e lo Stroustrup suggeriscono: utilizzare variabili intermedie.

Tutto ciò ovviamente non è necessario con quei due operatori logici, perché è stata prevista proprio la SCE per queste eventualità.

Non te lo aspetti tu, perché ti aspetti che l'operatore restituisca il valore di verità anziché l'operando che ha portato alla sua valutazione finale.

Succederebbe la stessa cosa se l'&& di C & derivati si comportasse allo stesso modo.

Ma questo non è l'unico, né tanto meno il modo "giusto" di procedere.

L'operatore logico, con o senza SCE, deve fare una cosa: garantire la consistenza logica dell'operazione, restituendo un risultato "adeguato".

In C potrebbe essere sia il valore intero che ha reso possibile la valutazione dell'operazione, che il valore di verità. Gli ideatori del linguaggio hanno ritenuto opportuno scegliere la seconda. Quindi DOPO la valutazione dell'operazione, viene forzata la conversione al corrispondente valore di verità.

In Pascal e Java non si sono posti nemmeno questo problema, perché gli operatori logici lavorano esclusivamente coi booleani, per cui sia argomenti e loro valore di verità coincide.

In Python, contrariamente al C e a tanti altri linguaggi, si è deciso di restituire l'argomento anziché il corrisponde valore di verità.

Ogni scelta ha pregi e difetti, ovviamente.
Per Python il difetto è quello che hai evidenziato: non puoi scambiare l'ordine degli operandi, perché (eventualmente) cambia il risultato.
Il vantaggio, invece, è quello che ho evidenziato io: è possibile sfruttare l'operazione per risolvere "pattern" di codice in maniera molto semplice ed elegante.

Altra cosa da sottolineare, è che NON sempre è necessario ottenere il valore di verità delle operazioni logiche. Anzi, normalmente non serve proprio.
Ad esempio nelle espressioni condizionali usate per le istruzioni if, while, repeat, ecc. il valore di verità serve soltanto per decidere in che modo procedere, e subito dopo viene SCARTATO. Questo vuol dire che l'operazione di conversione molto probabilmente poteva essere scartata, poiché non utile.

Quindi la scelta di Python comporta anche un RISPARMIO sul costo dell'operazione.

Infine, nulla toglie che con Python, ove serva, si possa convertire il valore restituito dagli operatori logici in un booleano: con un semplice bool('a' and 'b') viene restituito True. Ma lo faccio SE E SOLO SE ciò mi è NECESSARIO.

Finora, in 3 anni e mezzo di sviluppo con Python, non mi è MAI stato necessario. Il che mi pare un indice di una buona scelta fatta da Guido per il suo linguaggio.
Ancora più buona se consideriamo che in questo modo ho potuto sfruttare le operazioni per i pattern di codice di cui parlavo prima. E questo mi è capitato DIVERSE VOLTE in quest'arco di tempo. :cool:

Il C e altri linguaggi che, non avendo booleani, hanno operato la scelta del valore di verità, devono, invece, sobbarcarsi SEMPRE il costo della conversione anche se... non sempre necessario. :O

penso che sostanzialmente sono d'accordo con quello che hai scritto :O (tranne sul fatto che sia opportuno definire gli operatori logici in quel modo :asd: )

by_to_by

20-06-2008, 13:51

Non è che l'informatica possa andare avanti a forza di scongiuri, eh! :sgrat: :D

Allora, la dimostrazione di prima è cannata (in questi ultimi 5 giorni il dolore mi sta logorando la lucidità mentale): non ho usato nulla della SCE nel procedimento. Poco importa comunque: non se n'è accorto nessuno. :D

Tornando alla questione, sì, l'addizione gode della proprietà commutativa. Questa, però, NON è applicabile agli operatori and e or di Python, perché non viene restituito il valore di verità valutato, ma il primo argomento che ha permesso di "risolverlo".

Questo, comunque, poco importa perché la SCE in mezzo serve a garantire due cose:
- la corretta sequenza di valutazione dell'espressione (quindi l'ordine di valutazione degli operandi viene SEMPRE rispettato);
- la terminazione della valutazione degli operandi non appena si è acquisita sufficiente informazione.

Ciò serve proprio per evitare i pericoli di effetti collaterali. Pericolo che c'è, però, con gli altri operatori, e infatti anche l'addizione, pur godendo della proprietà commutativa, se vuoi evitare gli effetti collaterali degli esempi che hai riportato, devi fare come il K & R e lo Stroustrup suggeriscono: utilizzare variabili intermedie.

Tutto ciò ovviamente non è necessario con quei due operatori logici, perché è stata prevista proprio la SCE per queste eventualità.

Non te lo aspetti tu, perché ti aspetti che l'operatore restituisca il valore di verità anziché l'operando che ha portato alla sua valutazione finale.

Succederebbe la stessa cosa se l'&& di C & derivati si comportasse allo stesso modo.

Ma questo non è l'unico, né tanto meno il modo "giusto" di procedere.

L'operatore logico, con o senza SCE, deve fare una cosa: garantire la consistenza logica dell'operazione, restituendo un risultato "adeguato".

In C potrebbe essere sia il valore intero che ha reso possibile la valutazione dell'operazione, che il valore di verità. Gli ideatori del linguaggio hanno ritenuto opportuno scegliere la seconda. Quindi DOPO la valutazione dell'operazione, viene forzata la conversione al corrispondente valore di verità.

In Pascal e Java non si sono posti nemmeno questo problema, perché gli operatori logici lavorano esclusivamente coi booleani, per cui sia argomenti e loro valore di verità coincide.

In Python, contrariamente al C e a tanti altri linguaggi, si è deciso di restituire l'argomento anziché il corrisponde valore di verità.

Ogni scelta ha pregi e difetti, ovviamente.
Per Python il difetto è quello che hai evidenziato: non puoi scambiare l'ordine degli operandi, perché (eventualmente) cambia il risultato.
Il vantaggio, invece, è quello che ho evidenziato io: è possibile sfruttare l'operazione per risolvere "pattern" di codice in maniera molto semplice ed elegante.

Altra cosa da sottolineare, è che NON sempre è necessario ottenere il valore di verità delle operazioni logiche. Anzi, normalmente non serve proprio.
Ad esempio nelle espressioni condizionali usate per le istruzioni if, while, repeat, ecc. il valore di verità serve soltanto per decidere in che modo procedere, e subito dopo viene SCARTATO. Questo vuol dire che l'operazione di conversione molto probabilmente poteva essere scartata, poiché non utile.

Quindi la scelta di Python comporta anche un RISPARMIO sul costo dell'operazione.

Infine, nulla toglie che con Python, ove serva, si possa convertire il valore restituito dagli operatori logici in un booleano: con un semplice bool('a' and 'b') viene restituito True. Ma lo faccio SE E SOLO SE ciò mi è NECESSARIO.

Finora, in 3 anni e mezzo di sviluppo con Python, non mi è MAI stato necessario. Il che mi pare un indice di una buona scelta fatta da Guido per il suo linguaggio.
Ancora più buona se consideriamo che in questo modo ho potuto sfruttare le operazioni per i pattern di codice di cui parlavo prima. E questo mi è capitato DIVERSE VOLTE in quest'arco di tempo. :cool:

Il C e altri linguaggi che, non avendo booleani, hanno operato la scelta del valore di verità, devono, invece, sobbarcarsi SEMPRE il costo della conversione anche se... non sempre necessario. :O

Dipende soltanto dal linguaggio: è chi lo crea che definisce sempre anche questi dettagli.

Se l'inventore lascia libertà di scelta in questi casi, il linguaggio diventa molto fragile e poco interessante per chi sviluppa, perché si trovare in balia delle varie implementazioni. Un vero inferno, insomma.

Se c'è una valore "assoluto" a cui i programmatori DEVONO affidarsi, è quello della rigorosa definizione dei linguaggi che utilizzano. ;)

non ci capirò mai niente..sigh:cry:

k0nt3

20-06-2008, 16:02

non ci capirò mai niente..sigh:cry:
la stessa cosa che ho pensato io quando ho aperto per la prima volta il Sedra Smith*
in effetti l'ho pensato anche la seconda volta, poi ci ho fatto l'abitudine e sono andato avanti ugualmente :fagiano:

* malloppo di oltre mille pagine sull'elettronica (tanto per rendere l'idea l'ho spostato solo due volte: una volta per prelevarlo dalla biblioteca e una volta per riconsegnarlo)

~FullSyst3m~

20-06-2008, 18:37

la stessa cosa che ho pensato io quando ho aperto per la prima volta il Sedra Smith*
in effetti l'ho pensato anche la seconda volta, poi ci ho fatto l'abitudine e sono andato avanti ugualmente :fagiano:

* malloppo di oltre mille pagine sull'elettronica (tanto per rendere l'idea l'ho spostato solo due volte: una volta per prelevarlo dalla biblioteca e una volta per riconsegnarlo)

Avevi il salvagente immagino..

cdimauro

21-06-2008, 09:19

penso che sostanzialmente sono d'accordo con quello che hai scritto :O (tranne sul fatto che sia opportuno definire gli operatori logici in quel modo :asd: )
Guarda, come programmatore, sono sempre disposto a "meravigliarmi". Tante volte acquisiamo degli schemi mentali per cui forziamo in noi delle convinzioni "assolute" su ciò che sia giusto o sbagliato.

Poi magari arriva un linguaggio come Prolog, SmallTalk o anche lo stesso Python, e queste convinzioni le fa crollare inesorabilmente...

Solo che dobbiamo essere sufficientemente maturi ed elastici da trarre vantaggio da tutto ciò, per ampliare e fortificare il nostro bagaglio culturale. :)
non ci capirò mai niente..sigh:cry:
Non sei tenuto a capire fino alla "maggiore età". :O

~FullSyst3m~

21-06-2008, 09:21

Guarda, come programmatore, sono sempre disposto a "meravigliarmi". Tante volte acquisiamo degli schemi mentali per cui forziamo in noi delle convinzioni "assolute" su ciò che sia giusto o sbagliato.

Poi magari arriva un linguaggio come Prolog, SmallTalk o anche lo stesso Python, e queste convinzioni le fa crollare inesorabilmente...

Solo che dobbiamo essere sufficientemente maturi ed elastici da trarre vantaggio da tutto ciò, per ampliare e fortificare il nostro bagaglio culturale. :)

Non sei tenuto a capire fino alla "maggiore età". :O

Ehm... è già nella maggiore età! Ha detto che è più grande di un anno rispetto a Daniele, quindi ha 21 anni :O

cdimauro

21-06-2008, 10:38

Mi riferivo alla maturazione come programmatore. ;)

DanieleC88

21-06-2008, 10:42

Ehm... è già nella maggiore età! Ha detto che è più grande di un anno rispetto a Daniele, quindi ha 21 anni :O
Era in senso metaforico, "maggiore età" come programmatore... Se adesso è agli inizi... :stordita:

~FullSyst3m~

21-06-2008, 11:00

Era in senso metaforico, "maggiore età" come programmatore... Se adesso è agli inizi... :stordita:

Siccome aveva tirato in ballo l'età ho pensato subito all'età anagrafica e non quella da programmatore! ;)

Albi89

21-06-2008, 12:47

by_to_by

21-06-2008, 12:56

Cioè mi assento per qualche giorno e trovo questo poco di confusione?
Non mi sembrava così assurda come cosa...
In C/C++ gli operatori di confronto restituiscono true e false, in Python l'ultimo valore valutato se l'asserzione è vera, altrimenti un valore "falso" (cioè 0 o False).

La cosa che mi lascia scettico è un'altra, in realtà:
>>> 'b' == True
False
>>> if 'b':
print 'ciao'

ciao
non c'è una conversione implicita nel confronto tra il tipo bool e gli altri: inoltre, se confrontati, 2 non è True, ma 1 sì, mentre come condizione entrambe vengono valutate come "vere" (in un if, in un while...).

E' l'unica cosa che mi ha davvero confuso un po': mi sarei aspettato un comportamento omogeneo tra i due casi, ma forse dipende dalla mia mente corrotta dal C :cry:

parli come un prof universitario o un veterano della programmazione, non c'ho capito un azz. potresti spiegare con parole semplici per un ignorante?e il tipo bool è True e gli altri sono 'b' ecc?

^TiGeRShArK^

21-06-2008, 13:00

il valore di 'b' è il carattere 'b' quindi è diverso dal booleano True, però se fai un evaluation sulla verità o falsità di 'b' allora risulta essere vero perchè per defnizione tutto ciò che non è una stringa vuota viene valutato come Vero, il che non significa però che ha un valore pari a True ;)

by_to_by

21-06-2008, 13:02

^TiGeRShArK^

21-06-2008, 13:42

che casino... è perchè fa cosi scusa? inoltre, 2 == true è false, mentre 1 == true è vera. perchè?

perchè, sempre per definizione, quando viene valutato 1 è vero, mentre quando vengono valutati tutti gli altri numeri si ottiene false.
in pratica al posto di while True potresti anche scrivere while 1 oppure while 'a' che sarebbe del tutto equivalente.

~FullSyst3m~

21-06-2008, 19:48

perchè, sempre per definizione, quando viene valutato 1 è vero, mentre quando vengono valutati tutti gli altri numeri si ottiene false.
in pratica al posto di while True potresti anche scrivere while 1 oppure while 'a' che sarebbe del tutto equivalente.

Semplice, vero by_to_by?

~FullSyst3m~

21-06-2008, 21:17

Sono un pò fuori OT (ma sempre programmazione è!). Guardate quest'applet scritta in Java, è il famoso "correttore di stuck pixels". Avevo visto questo programma per la PSP, ma che funziona da una pagina web mai :D

http://www.jscreenfix.com/basic.php

^TiGeRShArK^

21-06-2008, 21:24

~FullSyst3m~

21-06-2008, 21:32

le applet sono ormai una tecnologia superata.
Ora come ora hanno senso solo quando è necessaria un'integrazione con la pagina web.
Per un'applicazione del genere avrei visto molto meglio la + recente tecnologia java web start.

Superata per dire, se ne fa ancora un larghissimo uso dappertutto. Ma studiando Java poi si può programmare con le varie tecnologie che la circondano (nel tuo esempio Web Start), oppure per ogni "versione" si deve studiare un Java diverso?

Comunque, tornando all'applet, su cosa si basa per visualizzare tutte quei colori in continuo movimento?

^TiGeRShArK^

21-06-2008, 22:04

Superata per dire, se ne fa ancora un larghissimo uso dappertutto. Ma studiando Java poi si può programmare con le varie tecnologie che la circondano (nel tuo esempio Web Start), oppure per ogni "versione" si deve studiare un Java diverso?

Comunque, tornando all'applet, su cosa si basa per visualizzare tutte quei colori in continuo movimento?
Dipende dale versioni.
La versione desktop è quella J2SE ed è praticamente uguale sia che usi un'aplet, che un'applicazione web start che un'applicazione stand-alone normale.
Ovviamente però vi sono delle modifiche da fare perchè per l'applet e le applicazioni web start si applicano diversi criteri di protezione.
Poi c'è la tecnologia JEE che è dedicata al mondo enterprise e utilizza gli EJB come strato di mapping object to relational e come gestori della business logic, mentre per la visualizzazione abbiamo diverse tecnologie che possono andare dalle semplici pagine JSP, all'utilizzo di Java Server Faces o di pagine xhtml che vengono automaticamente tradotte in JSP.
Invece per i cellulari, i sistemi embedded e portatili c'è la tecnologia J2ME.
Essa a sua volta è divisa a secondo delle capacità del dispositivo e va dalla + completa Personal Profile alla + limitata tecnologia MIDP, che
è quella su cui si basano praticamente tutti i programmi java fatti per cellulare.
Ovviamente tra J2SE, j2ME e JEE cambiano moltissime cose, anche se comunque c'è una base comune.
per quanto riguarda applet vs web start, ecco quello che dice nel sito ufficiale della sun:

When to write Applets vs. Applications

In the early days of Java, one of the critical advantages that Java applets had over Java applications was that applets could be easily deployed over the web while Java applications required a more cumbersome installation process. Additionally, since applets are downloaded from the internet, by default they have to run in a restricted security environment, called the "sandbox", to ensure they don't perform any destructive operations on the user's computer, such as reading/writing to the filesystem.

However, the introduction of Java Web Start has made it possible for Java applications to also be easily deployed over the web, as well as run in a secure environment. This means that the predominant difference between a Java applet and a Java application is that an applet runs in the context of a web browser, being typically embedded within an html page, while a Java application runs standalone, outside the browser. Thus, applets are particularly well suited for providing functions in a web page which require more interactivity or animation than HTML can provide, such as a graphical game, complex editing, or interactive data visualization. The end user is able to access the functionality without leaving the browser.

Per quanto riguarda i colori visualizzati in quell'applet, non ho visto il codice, ma avrà banalmente fatto un overload del metodo paint del frame dell'applet, disegnando i punti con le varie funzioni messe a disposizione da java.

~FullSyst3m~

21-06-2008, 22:20

Dipende dale versioni.
La versione desktop è quella J2SE ed è praticamente uguale sia che usi un'aplet, che un'applicazione web start che un'applicazione stand-alone normale.
Ovviamente però vi sono delle modifiche da fare perchè per l'applet e le applicazioni web start si applicano diversi criteri di protezione.
Poi c'è la tecnologia JEE che è dedicata al mondo enterprise e utilizza gli EJB come strato di mapping object to relational e come gestori della business logic, mentre per la visualizzazione abbiamo diverse tecnologie che possono andare dalle semplici pagine JSP, all'utilizzo di Java Server Faces o di pagine xhtml che vengono automaticamente tradotte in JSP.
Invece per i cellulari, i sistemi embedded e portatili c'è la tecnologia J2ME.
Essa a sua volta è divisa a secondo delle capacità del dispositivo e va dalla + completa Personal Profile alla + limitata tecnologia MIDP, che
è quella su cui si basano praticamente tutti i programmi java fatti per cellulare.
Ovviamente tra J2SE, j2ME e JEE cambiano moltissime cose, anche se comunque c'è una base comune.
per quanto riguarda applet vs web start, ecco quello che dice nel sito ufficiale della sun:

Per quanto riguarda i colori visualizzati in quell'applet, non ho visto il codice, ma avrà banalmente fatto un overload del metodo paint del frame dell'applet, disegnando i punti con le varie funzioni messe a disposizione da java.

Certo che la SUN ne sforna di giocattolini. Comunque alcune cose spcifiche non le ho capite perchè non mi è mai capitato di studiarle, ma in generale ho capito abbastanza.

Per studiare Javascript bisogna conoscere Java? Perchè nella libreria ho trovato un libro su Javascript :D

^TiGeRShArK^

21-06-2008, 23:25

Certo che la SUN ne sforna di giocattolini. Comunque alcune cose spcifiche non le ho capite perchè non mi è mai capitato di studiarle, ma in generale ho capito abbastanza.

Per studiare Javascript bisogna conoscere Java? Perchè nella libreria ho trovato un libro su Javascript :D

no, javascript non ha assolutamente nulla a che fare con java.
javascript è un semplice linguaggio di scripting debolmente orientato agli oggetti e debolmente tipizzato.
E' tornato in auge ultimamente soprattutto per la possibilità di utilizzare l'xmlhttprequest in modalità asincrona su cui si basa la tecnologia AJAX.
Infatti ultimamente i vari browser stanno integrando motori di elaborazione di javascript sempre migliori e + performanti, soprattutto quello di webkit, che, se non ricordo male, ad oggi dovrebbe essere il + prestante.

cdimauro

22-06-2008, 09:28

Cioè mi assento per qualche giorno e trovo questo poco di confusione?
Non mi sembrava così assurda come cosa...
In C/C++ gli operatori di confronto restituiscono true e false, in Python l'ultimo valore valutato se l'asserzione è vera, altrimenti un valore "falso" (cioè 0 o False).

La cosa che mi lascia scettico è un'altra, in realtà:
>>> 'b' == True
False
>>> if 'b':
print 'ciao'

ciao
non c'è una conversione implicita nel confronto tra il tipo bool e gli altri: inoltre, se confrontati, 2 non è True, ma 1 sì, mentre come condizione entrambe vengono valutate come "vere" (in un if, in un while...).

E' l'unica cosa che mi ha davvero confuso un po': mi sarei aspettato un comportamento omogeneo tra i due casi, ma forse dipende dalla mia mente corrotta dal C :cry:
La seconda che hai detto. :D
perchè, sempre per definizione, quando viene valutato 1 è vero, mentre quando vengono valutati tutti gli altri numeri si ottiene false.
in pratica al posto di while True potresti anche scrivere while 1 oppure while 'a' che sarebbe del tutto equivalente.
Per essere più preci, la classe bool discende dalla classe int, e le sue due istanze, True e False, valgono rispettivamente 1 e 0.

Infatti questo:
>>> True + 1
2
>>> False - 1
-1
ha perfettamente senso in Python, ma non in linguaggi che implementano i booleani come classi / entità a sé stanti.

~FullSyst3m~

22-06-2008, 10:13

no, javascript non ha assolutamente nulla a che fare con java.
javascript è un semplice linguaggio di scripting debolmente orientato agli oggetti e debolmente tipizzato.
E' tornato in auge ultimamente soprattutto per la possibilità di utilizzare l'xmlhttprequest in modalità asincrona su cui si basa la tecnologia AJAX.
Infatti ultimamente i vari browser stanno integrando motori di elaborazione di javascript sempre migliori e + performanti, soprattutto quello di webkit, che, se non ricordo male, ad oggi dovrebbe essere il + prestante.

Perchè debolmente orientato agli oggetti e debolmente tipizzato?

ha perfettamente senso in Python, ma non in linguaggi che implementano i booleani come classi / entità a sé stanti.

Ma i booleani, True e False, non dovrebbero avere lo stesso significato per tutti i linguaggi? Perchè alcuni linguaggi li implementano come classi a sè stanti?

DanieleC88

22-06-2008, 10:30

Suppongo, per necessità. Da quel poco che ne so, in Python ogni cosa dovrebbe essere un oggetto, non avrebbe avuto molto senso introdurre un'eccezione.

by_to_by

22-06-2008, 10:38

Suppongo, per necessità. Da quel poco che ne so, in Python ogni cosa dovrebbe essere un oggetto, non avrebbe avuto molto senso introdurre un'eccezione.

per oggetto e per eccezione cosa intendi?

DanieleC88

22-06-2008, 10:57

per oggetto e per eccezione cosa intendi?
Un oggetto è un qualcosa con proprietà e/o metodi comuni a tutta quella classe di oggetti di cui fa parte, un'eccezione è un caso caso particolare (ma qui io dicevo proprio in italiano, non era gergo informatico :p).

71104

22-06-2008, 11:01

non c'è una conversione implicita nel confronto tra il tipo bool e gli altri: inoltre, se confrontati, 2 non è True, ma 1 sì, mentre come condizione entrambe vengono valutate come "vere" (in un if, in un while...). veramente questo succede pari pari anche in C++; preciso che non so se si tratti di implementazione o standard, comunque in molti compilatori bool non è altro che un char forzato ad avere due valori, e siccome questi due valori sono 0 (false) e 1 (true) il risultato è che true != 2.

E' l'unica cosa che mi ha davvero confuso un po': mi sarei aspettato un comportamento omogeneo tra i due casi, ma forse dipende dalla mia mente corrotta dal C :cry: C++ semmai

parli come un prof universitario o un veterano della programmazione, non c'ho capito un azz. potresti spiegare con parole semplici per un ignorante? ma che palle :asd:

71104

22-06-2008, 11:05

un'eccezione è un caso caso particolare in C++ no; io trovo molto utile per esempio "lanciare" booleani, lo faccio sempre quando mi interessa risalire rapidamente per lo stack in seguito al fallimento di un'operazione, del quale non mi interessa sapere la causa.

DanieleC88

22-06-2008, 11:13

in C++ no; io trovo molto utile per esempio "lanciare" booleani, lo faccio sempre quando mi interessa risalire rapidamente per lo stack in seguito al fallimento di un'operazione, del quale non mi interessa sapere la causa.
Non contesto mica... Però io ho detto che usavo il termine "eccezione" senza riferimenti gergali, in italiano semplice. :Prrr:

;)

^TiGeRShArK^

22-06-2008, 13:12

Perchè debolmente orientato agli oggetti e debolmente tipizzato?
è debolmente tipizzato perchè, come in python, non è necessario specificare il tipo della variabile al momento della sua creazione.
Ad esempio in java si deve scrivere in questo modo per assegnare il valore 37 alla variabile firstNum:

int firstNum = 37;

e il compilatore saprà già che il tipo della variabile è un tipo intero.
In Python invece si deve scrivere così:

firstNum = 37

e in questo caso il tipo della variabile viene valutato solo al runtime.
In javascript si ha una situazione del tutto equivalente:

var firstNum = 37;

Dove var serve per dichiarare la variabile, però non contiene alcuna informazione sul tipo della stessa.
Inoltre, sempre in javascript è anche possibile scrivere:

firstNum = 37;

che equivalente al caso precedente dato che il linguaggio provvede ad effettuare una dichiarazione implicita e automatica.
Tanto per mostrare un altro aspetto della tipizzazione delle variabili abbiamo un ulteriore caso utilizzato nel C#:

int firstNum = 37;

// oppure

var firstNum = 37;

Nonostante la parola chiave var sia uguale a quella del javascript, in questo caso essa ha un significato totalmente diverso.
Il C#, infatti, al pari del Java, è fortemente tipizzato, e quindi, come dicevamo prima, il compilatore deve sapere in anticipo di che tipo è una variabile.
Quindi come si comporta il C#?
semplicemente il compilatore capisce automaticamente il tipo della variabile a seconda dell'r-value utilizzato nell'operazione di assegnamento.
Praticamente vede che c'è un numero intero e quindi implicitamente capisce che la variabile firstNum è un intero.
All'atto pratico è esattamente la stessa cosa scrivere int o var in C# dato che il comportamente sarà assolutamente equivalente.
Però si guadagna abbastanza in leggibilità, soprattutto in casi come questi:

var usersMap = new Dictionary<string, string>();

che imho è preferibile rispetto a:

Dictionary<string, string> usersMap = new Dictionary<string, string>();

Comunque, a parte qualche piccola semplificazione, mi pare di aver fatto un breve riassuntino dell'utilizzo della tipizzazione nei vari linguaggi :p

~FullSyst3m~

22-06-2008, 13:21

è debolmente tipizzato perchè, come in python, non è necessario specificare il tipo della variabile al momento della sua creazione.
Ad esempio in java si deve scrivere in questo modo per assegnare il valore 37 alla variabile firstNum:

int firstNum = 37;

e il compilatore saprà già che il tipo della variabile è un tipo intero.
In Python invece si deve scrivere così:

firstNum = 37

e in questo caso il tipo della variabile viene valutato solo al runtime.
In javascript si ha una situazione del tutto equivalente:

var firstNum = 37;

Dove var serve per dichiarare la variabile, però non contiene alcuna informazione sul tipo della stessa.
Inoltre, sempre in javascript è anche possibile scrivere:

firstNum = 37;

che equivalente al caso precedente dato che il linguaggio provvede ad effettuare una dichiarazione implicita e automatica.
Tanto per mostrare un altro aspetto della tipizzazione delle variabili abbiamo un ulteriore caso utilizzato nel C#:

int firstNum = 37;

// oppure

var firstNum = 37;

Nonostante la parola chiave var sia uguale a quella del javascript, in questo caso essa ha un significato totalmente diverso.
Il C#, infatti, al pari del Java, è fortemente tipizzato, e quindi, come dicevamo prima, il compilatore deve sapere in anticipo di che tipo è una variabile.
Quindi come si comporta il C#?
semplicemente il compilatore capisce automaticamente il tipo della variabile a seconda dell'r-value utilizzato nell'operazione di assegnamento.
Praticamente vede che c'è un numero intero e quindi implicitamente capisce che la variabile firstNum è un intero.
All'atto pratico è esattamente la stessa cosa scrivere int o var in C# dato che il comportamente sarà assolutamente equivalente.
Però si guadagna abbastanza in leggibilità, soprattutto in casi come questi:

var usersMap = new Dictionary<string, string>();

che imho è preferibile rispetto a:

Dictionary<string, string> usersMap = new Dictionary<string, string>();

Comunque, a parte qualche piccola semplificazione, mi pare di aver fatto un breve riassuntino dell'utilizzo della tipizzazione nei vari linguaggi :p

E se invece di un intero scrivi una stringa? Non puoi usare più var, oppure var lo puoi usare in generale con qualsiasi tipo di variabile (sto parlando di C# logicamente)?

DanieleC88

22-06-2008, 13:23

Con qualsiasi tipo, non appena incontra l'assegnazione ne imposta il tipo e quello rimane fino alla fine. ;)

cdimauro

22-06-2008, 15:01

Ma i booleani, True e False, non dovrebbero avere lo stesso significato per tutti i linguaggi? Perchè alcuni linguaggi li implementano come classi a sè stanti?
Ognuno sceglie la strada che ritiene migliore.
Suppongo, per necessità. Da quel poco che ne so, in Python ogni cosa dovrebbe essere un oggetto, non avrebbe avuto molto senso introdurre un'eccezione.
Sì, sono tutti oggetti.

Comunque in precedenza in Python si usavano 1 e 0 per True e False, in quanto il tipo bool è stato introdotto soltanto con la versione 2.3 (mi pare).

Per cui la scelta di farlo discendere da int è stata perfettamente naturale e retrocompatibile.
è debolmente tipizzato perchè, come in python, non è necessario specificare il tipo della variabile al momento della sua creazione.
Ad esempio in java si deve scrivere in questo modo per assegnare il valore 37 alla variabile firstNum:

int firstNum = 37;

e il compilatore saprà già che il tipo della variabile è un tipo intero.
In Python invece si deve scrivere così:

firstNum = 37

e in questo caso il tipo della variabile viene valutato solo al runtime.
In javascript si ha una situazione del tutto equivalente:

var firstNum = 37;

Dove var serve per dichiarare la variabile, però non contiene alcuna informazione sul tipo della stessa.
Inoltre, sempre in javascript è anche possibile scrivere:

firstNum = 37;

che equivalente al caso precedente dato che il linguaggio provvede ad effettuare una dichiarazione implicita e automatica.
Tanto per mostrare un altro aspetto della tipizzazione delle variabili abbiamo un ulteriore caso utilizzato nel C#:

int firstNum = 37;

// oppure

var firstNum = 37;

Nonostante la parola chiave var sia uguale a quella del javascript, in questo caso essa ha un significato totalmente diverso.
Il C#, infatti, al pari del Java, è fortemente tipizzato, e quindi, come dicevamo prima, il compilatore deve sapere in anticipo di che tipo è una variabile.
Quindi come si comporta il C#?
semplicemente il compilatore capisce automaticamente il tipo della variabile a seconda dell'r-value utilizzato nell'operazione di assegnamento.
Praticamente vede che c'è un numero intero e quindi implicitamente capisce che la variabile firstNum è un intero.
All'atto pratico è esattamente la stessa cosa scrivere int o var in C# dato che il comportamente sarà assolutamente equivalente.
Però si guadagna abbastanza in leggibilità, soprattutto in casi come questi:

var usersMap = new Dictionary<string, string>();

che imho è preferibile rispetto a:

Dictionary<string, string> usersMap = new Dictionary<string, string>();

Comunque, a parte qualche piccola semplificazione, mi pare di aver fatto un breve riassuntino dell'utilizzo della tipizzazione nei vari linguaggi :p
Solo una cosa al volo (che comincia la MotoGP!!!): Python è un linguaggio dinamico, ma FORTEMENTE tipato.

Non si possono sommare numeri e stringhe, ad esempio: non viene fatta nessuna conversioen dal primo al secondo o viceversa.