Newsgroup: it.comp.macintosh
Titolo: (Semi - OT)Dubbi su Obj-C

Sto leggendo un manualetto scaricato direttamente dall'ADC su 
Objective-C. Sono davvero molto interessato a questo linguaggio, 
sopratutto per la sua integrazione con X e per lo splendido IB.
Ho alcuni dubbi però:
1) riguardo ai metodi di classi, c'è un passo che recita così:
	 The names of methods that can be used by class objects, class methods, 
are preceded by a plus sign:
+ alloc;
The methods that instances of a class can use, instance methods, are 
marked with a minus sign:
- (void)display;
Ora (scusate l'ignoranza) mi sfugge la differenza tra instance methods e 
class methods...non è che qui si sta parlando semplicemente di medoti 
pubblici e privati??
2) per quanto riguarda, invece, gli argomenti di un metodo, il manuale 
riporta un esempio:
	When there’s more than onea rgument, the arguments are declared within 
the method name after the colons. Arguments break the name apart in the 
declaration, just as in a message. For example:
- (void)setWidth:(float)width height:(float)height;
Ora qui non ho capito perchè ha messo "height:(flot)height", in 
particolare perchè ha messo "height:" prima del paramentro 
(float)height, mentre prima di (float)width no? In pratica che sta a 
significare "height:" ?
Grazie mille!

 Grazie mille!
Ciao,
Alberto

 significare "height:" ?
fa parte del nome del metodo, quando lo wrappi in un altro linguaggio
quel metodo lo scriversti appressapoco cosi':
setWidth_height(float witdh, float height) 
ad esempio il metodo 
- (void)setWidth:(float)width altezza:(float)heigth
e' un altro metodo
 

 e' un altro metodo
Ok, quindi nel tuo secondo esempio ("(void)setWidth:(float)width 
altezza:(float)height") in java si sarebbe tradotto cosě: "void 
setWidth(float width, flot altezza)" ?
Cioč non capisco perchč mettere due nomi sia altezza sia height, ne 
basta 1 per specificare il nome del parametro d'istanza, o almeno cosě č 
di solito di C, Java...

 senso, o mi sbaglio?
A differenza di altri linguaggi anche le classi sono oggetti.

 A differenza di altri linguaggi anche le classi sono oggetti.
Ah ecco! Il mio paragone era col java e quindi non riuscivo a trovare 
una corrispondenza...

 di solito di C, Java...
e' un unico nome splittato in piu' parti e gli argomenti stanno in mezzo
non mi pare poi cosi' difficile e' solo una questione di sintassi

 Ho alcuni dubbi perň:
http://www.amazon.co.uk/exec/obidos/ASIN/0672325861/qid=1150801811/sr=8-
1/ref=sr_8_xs_ap_i1_xgl/202-2129527-1095035
questo ti toglie tutti i dubbi
:-)

 non mi pare poi cosi' difficile e' solo una questione di sintassi
No ora no, capito. Ammetterai perň che suddividere il nome di un metodo 
in piů parti non č poi una cosa cosě intuitiva da capire, certo una 
volta che lo si sa, tutto fila liscio :)
Bhe che dire, caro uliano grazie mille! Continuo nella mia lettura, ai 
prossimi dubbi riposto :)

 :-)
Ok, vedrň di trovarlo in libreria :)

 prossimi dubbi riposto :)
ottimo
e togli l'ot tanto objc oramai lo usa solo apple ;)

 e togli l'ot tanto objc oramai lo usa solo apple ;)
Ok!

 deallocare qualche cosa.
No. Nemmeno per idea. Stai facendo della gran confusione.
-- 
blog:  
http://www.akropolix.net/rik0/blogs
 | Uccidete i filosofi,
site:  
http://www.akropolix.net/rik0/
      | tenetevi riso e
forum: 
http://www.akropolix.net/forum/
     | bacchette per voi.

 significare "height:" ?
Si chiamano "named parameters". Sono una delle cose più fighe
immaginabili. Python li ha e sono impagabili. Ruby non li ha e hanno
architettato un metodo per simularli. ObjectiveC li ha.
Purtroppo Java e C++ non li hanno, ed è un grandissimo peccato.
Aumentano la leggibilità abbestia (e se ben implementati) evitano
l'onere di dovere ricordare una cosa arbitraria in genere come l'ordine
dei parametri.


 setWidth(float width, flot altezza)" ?
No. In Java probabilmente avrebbero chiamato il tutto
setWidthAndHeight(float w, float h);


 A differenza di altri linguaggi anche le classi sono oggetti.
Fortunatamente. Č una tale idiozia buttare in un linguaggio ad oggetti
delle cose che non sono oggetti.


 ObjectiveC li ha.
no

 delle cose che non sono oggetti.
come short int float double char e altre amenita'? :-)

 dei parametri.
Esatto, diciamo che il mio errore è stato cercare di leggere il manuale 
e paragonare il tutto a linguaggi che già conosco abbastanza, ma mi sa 
che in questo caso, devo partire da 0 :)

 che in questo caso, devo partire da 0 :)
tutto dipende da quello che conosci gia', io per gli oggetti conoscevo
meglio python che java o c++ e mi sono trovato subito benissimo :-P

 meglio python che java o c++ e mi sono trovato subito benissimo :-P
In effetti i concetti del objc sono molto più vicini allo smalltalk che al 
c++. 

 wrote:

in effetti il c++ ha senso solo per roba iperefficente, lo static
typeing scassa la minchia non poco
(java invece ha senso solo perche' c'e' un sacco di codice)

 meglio python che java o c++ e mi sono trovato subito benissimo :-P
Python probabilmente è più simile ad Obj-C, ma C++ (per quello che 
conosco) è molto differente. Come linguaggi OO sono partito dal C++ e 
quando sono passato al Java mi sono trovato a mio agio (anzi anche molto 
agevolato). Obj-C lo vedo molto diverso. Ma forse è solo la prima 
impressione.

 impressione.
No, lo è. 

 (java invece ha senso solo perche' c'e' un sacco di codice)
Poi ci sono un botto di strumenti per il design di codice java/c++.
Il c# qualcuno l'ha visto?

 quando sono passato al Java mi sono trovato a mio agio 
e te credo sono molto simili
(uno la brutta copia dell'altro, relazione riflessiva ;P) 

 wrote:

chi? :O

 chi? :O
Mi pare si usi programmando su .net. Ma non so se è un'invezione di zio 
billo (e quindi il # è un riferimento alla sua persona).... 

 Il c# qualcuno l'ha visto?
Tempo fa (molto tempo fa) gli diedi una rapida occhiata, mi sembrň la 
copia M$ di java. Parlando poi con un pň di gente, mi ha confermato la 
mia impressione, aggiungendo perň che portava alcuni miglioramenti. 
Sincermente poi non mi sono piů interessato al linguaggio (anche perchč 
ho cambiato piattaforma).

 No, lo č.
Quindi mi tocca studiare parecchio :)

 billo (e quindi il # è un riferimento alla sua persona).... 
billo e' un hash?

 Quindi mi tocca studiare parecchio :)
Ed a meno di sviluppare su cocoa non serve ad un cazzo... :(

 billo e' un hash?
Come si chiama in itagliano? :DDDDD

 (uno la brutta copia dell'altro, relazione riflessiva ;P) 
No dai C++ è molto bello, forse un pò antico, ma bello. Rapido, diretto, 
senza tutta la ridondanza del Java e sopratutto completo (OO e 
procedurale). Forse un pò disordinato ma vale la pena conoscerlo.

 Quindi mi tocca studiare parecchio :)
no, non tanto, devi solo "dimenticare" un po' di sovrastrutture
e' molto molto piu' semplice e lineare del c++ (sintassi astruse a
parte, non che quelle del c++ siano eleganti)

 Ed a meno di sviluppare su cocoa non serve ad un cazzo... :(
Ah certo, ma il mio scopo è proprio quello. Poi ho sentito parlare di 
garbage collection nella prossima edizione (Leopard?), quindi il tutto 
diventa molto interessante. Senza contare il magnifico IB, mai visto 
niente di simile!

 niente di simile!
Visti i risultati in java se ne può fare a meno del gc. Poi secondo me rende 
il runtime troppo complesso (te serve sto thread asincrono per fare il 
garbage). 

 parte, non che quelle del c++ siano eleganti)
Beh insomma...qui mi sembra che più avanti vado nella lettura e più 
diventa difficile (ora si sta parlando di SEL, che macello :) ), ma 
forse è pure colpa di questo documento che non è gran chè. Mi devo 
procurare il libro che mi hai linkato prima ;)

 wrote:

diesis?
cancelletto?

 wrote:

beh objc e' imho MOLTO + bello, magari non cosi' rapido, ma un casino
piu' flessibile e altrettanto OO e procedurale
anzi, c++ ha modificato (leggermente tanto per aumentare il casino)
anche i costrutti c objc estende solo e le estensioni sono pochissime 
voglio vedere che faccia fai quando scopri l'introspezione il key value
coding e i bindings... :-DDD
roba che il c++ se la sogna ;)

 cancelletto?
Esatto! E zio billo come se chiama? Cancelli... :P

 garbage). 
Beh questi sono problemi di Apple (o di chi sviluppa tale teconologia), 
l'importante (dal mio punto di vista) è che il programmatore venga 
agevolto :)

 roba che il c++ se la sogna ;)
Vero, decisamente più elegante e raffinato.

 wrote:

no e' colpa della tua formazione precedente: tutto statico a compile
time
qua i metodi vengono "linkati" a runtime e un SEL e' semplicemente un
modo per riferirsi a un determinato metodo
il libro che ti ho linkato e' didatticamente abbastanza fatto bene, ha
un target dal beginner all'intermediate e una esposizione chiara (tieni
conto che a giudicare i libri io sono severissimo)

 roba che il c++ se la sogna ;)
Dammi tempo e ti ritorno un pò di feed :D

 modo per riferirsi a un determinato metodo
Non tutti, solo se si forza il late binding. 

 wrote:

no certo la faccenda e' opzionale ma se ti serve un SEL...

 wrote:

ohhhhhhhhh (ammirazione e stupore!)

 ohhhhhhhhh (ammirazione e stupore!)
So exciting le tac ai sorci...
:PPPPPP

 wrote:

mah, certo il gc fa comodo, fico il python infatti ce l'ha... pero'
appena vuoi qualcosa di tanticchia piu' efficente e passi a scrivere una
funzioncina in C ecchile li che saltano fuori di nuovo le references da
contare... 
insomma la botte piena e la moglie zoccola ancora non su questi schermi

 forum: 
http://www.akropolix.net/forum/
     | bacchette per voi.

 come short int float double char e altre amenita'? :-)
Infatti IMHO non ci dovrebbero stare. Purtroppo sono necessari in quanto
ObjectiveC è un soprainsieme del C. E complessivamente non limitano il
modello ad oggetti, puoi considerarli come un'ottimizzazione (e infatti
lo sono).
Ma avere le classi che non sono oggetti a tutti gli effetti, è solo una
limitazione con vantaggi risibili.


 che in questo caso, devo partire da 0 :)
Il punto è che conoscere Java è un buon prerequisito per capire
ObjectiveC, ma serve anche sapere quanto Java sia limitato.


 no
Sono diversi, ma si chiamano sempre named parameters. Aumentano sempre
la leggibilità e tutto. Poi che Python sia più dinamico ancora e più
"moderno" non ci piove.


 volta che lo si sa, tutto fila liscio :)
Perchè tu lo vedi come "divisione del metodo" e purtroppo in objective C
risulta così. Ecco... immaginati questo
mt = Employee(name="Edgar A. Poe", address="...", phone="0055512566",
birth=date1, assumption=date2)
sicuramente più leggibile, più facile da ricordare e tutto.
Purtroppo in ObjectiveC sarebbe solo una cosa tipo
id mt = [[Employee alloc]  initWithName:"Edgar A. Poe" 
                                withAddress:"..." 
                                withPhone:"0055512566" 
                                withBirth:date1 
                                withAssumption:date2]
comunque più leggibile che non avere i nomi.


 Come dici tu, magari ho frainteso.
Infatti hai frainteso. Li c'è scritto:
"In Cocoa alcune classi definiscono metodi di creazione che combinano
due passi di allocare e inizializzare e di ritornare una nuova istanza
inizializzata della classe. Questi metodi tipicamente prendono la forma
+.
Tu invece hai detto:
: Se il metodo alloca della memoria, si antepone allo stesso il
: carattere '+' per ricordare allo sviluppatore che da qualche parte
: bisogna deallocare qualche cosa.
E questo è falso. I metodi con il + sono semplicemente metodi di classe.
Punto e basta. Il + non è una convenzione dei programmatori: è roba
sintattica che dice ad ObjectiveC che sono metodi di classe.
Il fatto poi non toglie che i metodi che allocano ed inizializzano
insieme *debbano* essere metodi di classe per ragioni ovvie. Ma ci sono
molti altri metodi di classe (che quindi "iniziano con +" ) che non
allocano memoria affatto (e tantomeno dicono che bisogna deallocare
qualcosa).
Non solo... tipicamente gli oggetti inizializzati e allocati tali
costruttori "all in one" sono già nell'autorelease pool, quindi *non*
bisogna deallocarli esplicitamente (a meno che non si siano prima
retainati).


 billo (e quindi il # è un riferimento alla sua persona).... 
In  pratica si.


 niente di simile!
Prova Matisse. E comunque IB è legato a Cocoa. Se poi programmi Cocoa in
Python o in Ruby, puoi usarlo comunque.


 il garbage).
Non confondere il fatto di fare garbage collection con un metodo per
farlo. Python fa garbage collection, ma lo fa attraverso reference
counting: nessun thread asincrono.
Ci sono un fottio di algoritmi di garbage collection, ognuno con i suoi
pregi e i suoi difetti.


 diventa difficile
Macchè. È che sei affezionato alle tue catene.
Cerca su Google 10 things a Java programmer should know about ruby.
Sono alcune slides, le leggi in pochissimo e ti aprono la mente.


 piu' flessibile e altrettanto OO e procedurale
Non è che C++ sia *molto* più efficiente di ObjectiveC eh... appena
appena. Ha solo un runtime più piccolo, ma appena tiri in mezzo
applicazioni serie, finisce che ti reimplementi a mano qualche pezzo di
quel runtime.


 "moderno" non ci piove.
non e' questione di moderno, e' la sua natura interpretata (ok oggi va
di moda dire dinamica ;) ) che gli da la possibilita' di averli
nell'ordine che ti pare e ... di avere dei defaults cosi' specifichi
solo quello che ti serve
insomma un altro pianeta
io poi quando ho imparato python usavo IDL
http://www.ittvis.com/idl/index.asp
 e li era esattamente cosi', quindi
nessuna sorpresa
...oggi uso python + una serie di pacchettini+o- compilati ora ho pure
imparato che compilarmeli e' facile, faccio le stesse cose senza pagare
un ghello di licenze :-D

 ObjectiveC,
non sono mica tanto d'accordo...
imho e' meglio solo plain c senza pregiudizi ad oggetti

 ObjectiveC, ma serve anche sapere quanto Java sia limitato.
Su questo ti rispondo tra qualche tempo, quando avrò più convidenza con 
Obj-C :)

 These methods typically take the form '+' className...
sono i metodi che ritornano istanze gia' allocate che sono metodi di classe
e quindi hanno il modificatore "+", non il viceversa ;)
-- 
Ma soprattutto, che ci faceva il serpente sull'albero?

 architettato un metodo per simularli.
:( dai i simboli non sono poi cosi' malaccio


 appena. 
in se no non tanto (poi dipende da cosa fai), ma la flessibilita' e la
dinamicita' di objective c ti porta ad affrontare i problemi in modo
inefficente (ma elegantissimo)

 Sono alcune slides, le leggi in pochissimo e ti aprono la mente.
Aspetta aspetta :)
Sto leggendo le slide che mi hai indicato e mi è venuto in mente una 
cosa che effettivamente faccio spesso in Java in maniera del tutto 
automatica:
Integer.toString(intvar);
In effetti, ora che mi ci fai pensare, qui non c'è nessuna istanza di 
classe, la classe Integer va ad agire direttamente sulla variabile 
"intvar" senza eseguire nessuna istanziazione, apputo come se il nome di 
classe (Integer) è un oggetto...
Ora che vedo questa cosa, sopratutto che ci rifletto su, non mi spiego 
come faccia a funzionare. Che gran curiosità che ho in questo momento :)

 programmer should know about ruby.
off tred: m'e' arrivato il libro, per ora ruby non mi sta piacendo
granche' (1)... di originale e interessante c'ho visto solo i blocchi...
boh andro' avanti lentamente e senza l'entusiasmo che avevo quando
l'ordinai
(1) financo un po' perloso... :-D 

 In  pratica si.
io sapevo che il nome csharp deriva da questo terrificante geek-pensiero:
C -> C++ -> C++
             ++


 Esatto! E zio billo come se chiama? Cancelli... :P
=__=;;;;;;


 non ha senso, o mi sbaglio?
Mi sa che devi studiarti un pò di "fondamentali" della programmazione
:-P
Una classe è la rappresentazione di un tipo di dato astratto, una
"fabbrica" di oggetti. Se tu mandi un messaggio alla classe o fai
operazioni su detta classe in linea di massima questa operazione
coinvolge tutte le istanze nate dalla classe.
-- 
Lawrence - 
http://www.oluyede.org/blog
"Nothing is more dangerous than an idea
if it's the only one you have" - E. A. Chartier

 come short int float double char e altre amenita'? :-)
Beh in .NET quelli sono alias di oggetti anche se viene comunque usato
il boxing. Una porcheria lo stesso :-P


 diverso. Forse hanno qualche implicazione col l'overloading?
Hanno implicazioni con la chiarezza del codice. E' inutile avere 20
metodi uguali in cui cambiano solo i parametri. Come è inutile avere 20
metodi che si occupano solo di settare e prendere il valore di una
variabile. Linguaggi come Python e Ruby cercano di semplificare la vita
alla gente tutto qui.


 Il c# qualcuno l'ha visto?
Io l'ho usato per un anno e mezzo. Che vuoi sapere?


 garbage). 
usare come metro di comparazione un GC poco efficiente per demonizzare i
GC è poco furbo :-P


 insomma la botte piena e la moglie zoccola ancora non su questi schermi
Python ha un GC a reference counting quindi si, devi contare le
referenze per ogni oggetto. Tra l'altro nessuno ti obbliga ad usare la
API di Python direttamente, ci sono altri metodi per creare estensioni.
Se invece usassi Ruby ti accorgeresti che la sua interfaccia è parecchio
più semplice da programmare perchè usa un GC mark&sweep. 
Ci sono vantaggi e svantaggi :-)


 Una porcheria lo stesso :-P
se e' ms non ho grossi dubbi...

 più semplice da programmare perchè usa un GC mark&sweep. 
ruby lo sto leggendo da ierl'altrosera a tempo persissimo e devo dire
che mi sta piacendo molto meno di quello che avevo previsto basandomi
sul parlare che se ne fa
se non ci sono clamorose sorprese piu' avanti python (con 2-3 difettucci
veniali) rimane meglio di un bel po'
(meglio contare le referenze, un po' di efficenza ecchediamine... mica
e' complicata l'interfaccia python verso il c...)

 Obj-C :)
Io grazie a PyObjC farò meno sforzo quando mi interesserà apprenderlo
:-P


 come faccia a funzionare. Che gran curiosità che ho in questo momento :)
E' semplicemente un metodo statico, c'azzecca poco col discorso delle
classi-oggetto che dicevamo prima


 :-P
dubito molto che pybojc aiuti
ma e' verissimo che farai poca fatica, diciamo grazie a un modello a
oggetti abbastanza simile
perdi l'ereditarieta' multipla e guadagni le categorie 
il resto piu' o meno si equivale

 se e' ms non ho grossi dubbi...
vabbè


 veniali) rimane meglio di un bel po'
in cosa Python rimane meglio di un bel pò?


 perdi l'ereditarieta' multipla e guadagni le categorie 
Non so cosa siano le categorie :-)


 Non so cosa siano le categorie :-)
una cosina moolto interessante :)
// NSString+Claudio.h
@interface NSString (PersonalizzataDaClaudio)
+ (NSString *)ilMioNome;
@end
// NSString+Claudio.m
@implementation NSString (PersonalizzataDaClaudio)
+ (NSString *)ilMioNome
{
   return @"Claudio";
}
@end
// Nel tuo programma
#import NSString+Claudio.h
// ...
NSString *nome = [NSString ilMioNome];


 Integer.toString(intvar);
e si potrebbe andare ancora avanti...
Java: Math.abs(intValue)
Ruby: intValue.abs


 (1) financo un po' perloso... :-D
che libro, il PickAxe? Come ti sembra, stavo pensando di comprarlo?


 in cosa Python rimane meglio di un bel pò?
chiarezza prevedibilita' e linearita'...

 Non so cosa siano le categorie :-)
aggiunta di metodi a classi... anche classi di cui non disponi del
sorgente

 un oggetto
si immaginavo ma nello specifico che gli fanno? la variabile con tipo
risponde automaticamente a certi metodi o diventa un oggetto con tutti i
sovraccarichi che questo comporta?

 che libro, il PickAxe? Come ti sembra, stavo pensando di comprarlo?
il ilbro non sembra male, e' il ruby che non mi ha preso

 un ghello di licenze :-D
Ottimo, no?
-- 
blog:  
http://www.akropolix.net/rik0/blogs
 | Uccidete i filosofi,
site:  
http://www.akropolix.net/rik0/
      | tenetevi riso e
forum: 
http://www.akropolix.net/forum/
     | bacchette per voi.

 come faccia a funzionare. Che gran curiosità che ho in questo momento :)
È un metodo di classe. Non centra con le classi oggetto, ma ti dimostra
che una classe può avere funzionalità anche se non è istanziata.
E c'è roba del genere pure in C++, eh...
Dopo tutto se hai le funzioni, non vedo perchè non puoi avere metodi di
classe... (e se non le hai con i metodi di classe le emuli).
Comunque Java è pieno di metodi di classe, e anche molti pattern (in
Java) devono usarli.


 io sapevo che il nome csharp deriva da questo terrificante geek-pensiero:
Se è vero lo imparo solo per quello.


 (1) financo un po' perloso... :-D 
Si. Questo è vero. Io lo vedo come un linguaggio che tiene le cose belle
di Perl e butta via quelle cattive.


 inefficente (ma elegantissimo)
Beh guarda che hanno fatto dei test e sull'uso medio mandare messaggi
non è più costoso che chiamare una funzione virtuale.


 Obj-C :)
Ma perchè non lanciarti direttamente con Python o con Ruby?


 imho e' meglio solo plain c senza pregiudizi ad oggetti
Non ho mica detto che sia l'unico. Ma in generale un po' di esperienza
ad oggetti "vera" aiuta. Purtroppo in molti posti si insegna un
linguaggio ad oggetti, ma non la programmazione ad oggetti.
Č un grande limite. Ma d'altra parte. Conoscere il "plain C" non č un
requisito per ObjectiveC. Č un po' un luogo comune (esattamente molti
pensano che conoscere C serva per conoscere C++).
Mi spiego... la sintassi č simile, ma č abbastanza tipica ormai. D'altra
parte molte delle cose tipiche in C, in ObjectiveC non si fanno, perchč
c'č tutta la parte piů ad alto livello.
Per esempio una cosa come
typedef struct {
    size_t degree;
    size_t _allocated;
    mpz_t mod;
    BOOL _constructed;
    mpz_t *coefs;
} __aks_poly_struct;
typedef __aks_poly_struct ap_t[1];
non la farai in ObjectiveC (nota la "finezza" per come č dichiarato
ap_t). Allo stesso modo capire a fondo i puntatori non ti aiuta molto
(meglio conoscerli, certo, ma meglio sapere lavorare ad oggetti,
piuttosto).
Insomma conoscere bene Java rende apprendere ObjectiveC davvero
semplice. A patto di avere la mente aperta, certo.


 :( dai i simboli non sono poi cosi' malaccio
Infatti non dico che sono male. Dico solo che Ruby non ha i named
parameters.
Il fatto che per l'utente finale sia pressochè la stessa cosa è lo
stesso :)
Comunque potrebbero entrare in Ruby 2.0


 Stessa cosa in Java5 se non erro.
Si. L'autoboxing c'č, ma č in pratica zucchero sintattico. Sotto le cose
AFAIK funzionano come al solito. E comunque sono abbastanza convinto che
le classi in Java non siano oggetti a tutti gli effetti (anche se
possono essere rappresentati da oggetti di tipo Class).
Non so quanto la differenza esista solo nella mia testa o sia reale.
-- 
blog:  
http://www.akropolix.net/rik0/blogs
 | Uccidete i filosofi,
site:  
http://www.akropolix.net/rik0/
      | tenetevi riso e
forum: 
http://www.akropolix.net/forum/
     | bacchette per voi.

 Ottimo, no?
di +

 di Perl e butta via quelle cattive.
vabbeh dai sospendo il giudizio
devo dire che con python le cose andarono diversamente, mi divoravo il
libro in stato di semi euforia... boh forse quello era il primo o forse
c'e' sotto qualcosa

 non è più costoso che chiamare una funzione virtuale.
il punto e' che on objc ti viene da fare tutto a id, in c++ le funzioni
virtuali col contagocce (temo che sia un po' colpa/merito dei templates)

 semplice. A patto di avere la mente aperta, certo.
il punto di java ma anche di c++ e' che tutti quelli che conosco che li
usano mi guardano come se fossi un matto quando parlo dei vantaggi di
non specificare i tipi a compile time... 
ci deve essere una tendenza intrinseca che porta in direzioni divergenti
da una parte gli *eredi* di smalltalk (i dinamici) dall'altra c++ e
compagnia (gli efficentisti)
(1) gia' dal c al c++ cambiano tutta una serie di inezie che rompono i
coglioni, a ricordarsele

 chiarezza prevedibilita' e linearita'...
Renditi conto che non vuol dire nulla eh :-)
-- 
Lawrence - 
http://www.oluyede.org/blog
"Nothing is more dangerous than an idea
if it's the only one you have" - E. A. Chartier

 una cosina moolto interessante :)
Fingiamo che io abbia capito qualcosa di quell'orribile sintassi :-)


 sorgente
In Python è molto semplice :-)


 sovraccarichi che questo comporta?
la seconda.


 Non so quanto la differenza esista solo nella mia testa o sia reale.
L'ideale sarebbe leggersi della sbobba sulla JVM e il suo bytecode per
capire ma sinceramente non mi interessa


 la seconda.
che merda

 Renditi conto che non vuol dire nulla eh :-)
lo so benissimo
nulla oppure tutto
a seconda se ci s'intente
(trattasi di comunicazione informale quindi ambigua)
cmq al livello cui sto adesso (bassino) quello che mi fastidia di piu'
e' la sintassi

 In Python č molto semplice :-)
l'objc formalizza questo processo
non altrettanto semlice (fattibile?) in c++ o in java

 quell'orribile sintassi :-)
fatico a darti torto... pero' e' davvero la cosa peggiore

 Fingiamo che io abbia capito qualcosa di quell'orribile sintassi :-)
beh non che sia bellissima :(
a tratti sa di accrocchio...
-- 
Ma soprattutto, che ci faceva il serpente sull'albero?

 il boxing. Una porcheria lo stesso :-P
Bzzzt, sbagliato, sono value types e passati sullo stack. Sono
utilizzabili come oggetti, nel qual caso vengono promossi nello heap
(boxing) e poi ritrasformati in valori semplici quando si fa il downcast
(unboxing).
 - ∞
-- 
http://millenomi.altervista.org/

 e togli l'ot tanto objc oramai lo usa solo apple ;)
Beh, c'e' sempre GNUstep.
Ok, ok...
 - ∞
-- 
http://millenomi.altervista.org/

 garbage). 
IMHO meglio un runtime complesso che dover stare a contare il numero di
-release e -autorelease e assicurarsi che bilancino gli -init.
 - ∞
-- 
http://millenomi.altervista.org/

 modo per riferirsi a un determinato metodo
Be', e' un po' meglio: si riferisce al NOME di un metodo, per cui si
puo' applicare a classi diverse senza doverle per forza conoscere.
L'implementazione speicifica di un metodo invece e' un puntatore a
funzione che in objc ha tipo IMP.
 - ∞
-- 
http://millenomi.altervista.org/

 + (NSString *)ilMioNome;
E' molto piu' interessante fare una categoria con metodi d'istanza, ad
esempio aggiungendo un metodo - (NSData*) MD5 a NSData, o - (NSString*)
stringByEncodingWithROT13...
Rendono il codice molto piu' leggibile che dover implementare helper
altrove (e infatti C# 3.0 le avra').
 - ∞
-- 
http://millenomi.altervista.org/

 le classi in Java non siano oggetti a tutti gli effetti
Infatti non si puo' scrivere:
Class abc = String; // errore di compilazione.
Si puo' ottenere un oggetto di tipo Class<?> con la sintassi
NomeClasse.class ma non e' possibile ad esempio invocare direttamente un
metodo statico sull'oggetto che ottieni (e' necessario usare
Reflection).
 - ∞
-- 
http://millenomi.altervista.org/

 stringByEncodingWithROT13...
si si... era giusto un esempio! :)


 ... che?
non ti definisci gli altri initializers. una palla eh.


 e' la sintassi
Direi che allora puoi lasciarlo dove è. Io ti dico, li ho provati e
usati tutti e due (Python di più).
Ruby ha molte cose che mi piacciono, francamente. Non saprei decidere,
se fossi costretto. Adesso sto più appresso a Ruby perchè "nuovo" (nel
senso di giocattolo nuovo) e perchè sto lavorando con Rails.
Ma a parte questo per me si equivalgono. Va a gusti o a momenti.


 -release e -autorelease e assicurarsi che bilancino gli -init.
Anche perchč i release e compagnia il runtime č in grado di
aggiustarseli da solo. 


 e si potrebbe andare ancora avanti...
Infatti non capisco quelli che dicono che Java č ad oggetti "puro". Non
lo č: e comunque anche essendolo, non ha il minimo senso volere infilare
le viti con il martello solo perchč tutto č un chiodo.


 che libro, il PickAxe? Come ti sembra, stavo pensando di comprarlo?
Excellente. Divertente, ma non alla forzatura come quello di Wall.
Utile, ricco di informazioni sul linguaggio, ma anche reference.
Direi che hanno appreso la lezione del Nutshell di Alex.


 c'e' sotto qualcosa
Esatto. È il primo dinamico che ti apre il mondo. Poi scopri cose che
facevi in  Python fatte in un altro modo. Un paio si fanno in modo
facile (e in Python non si fanno), un altro paio si fanno in modo più
facile. Altre probabilmente rognano un po (per esempio il trucco è non
abusare del fatto che i metodi possano omettere le parentesi).
Insomma, bello, utile. Ma abbastanza sovrapponibile.


 coglioni, a ricordarsele
si
int c = 6 //**/ 2
;
quanto vale c?


 Fingiamo che io abbia capito qualcosa di quell'orribile sintassi :-)
In pratica si traduce cosě
class String 
  def String.il_mio_nome
    "Claudio"
  end
end


 In Python č molto semplice :-)
Non cosě tanto sui builtin, purtroppo.


 virtuali col contagocce (temo che sia un po' colpa/merito dei templates)
Ma non è id che rallenta eh...


 Reflection).
E anche qui potrebbero solo avere "nascosto" certe cose. Anche se
francamente sono dell'idea che non sono oggetti. Potremmo chiedere,
vediamo se questi rispondono. <g>


 aggiustarseli da solo. 
E' potenzialmente in grado di...? Si' (GC).
Lo fa? As of 10.4 e GNUstep correnti _no_. Va fatto tutto a manina.
 - ∞
-- 
http://millenomi.altervista.org/

 vediamo se questi rispondono. <g>
Com'e' realizzato internamente nella JVM non lo so, ma nella sintassi
Java non e' possibile avere un oggetto-classe (i.e. String non e'
un'espressione che genera un oggetto).
In Objective-C invece si puo' avere tranquillamente [[self class]
metodoStatico]. [self class] e' un'espressione che genera un oggetto di
tipo Class su cui posso chiamare metodi statici; tant'e' che nei metodi
statici stessi self e' un riferimento a quell'oggetto classe (*).
L'oggetto Class<?> di j2se 5 non ha questa funzionalita'.
// Esempio:
Class<Integer> c = Integer.class; // si'
c.intValue("1234"); // no. errore di compilazione
// Esempio objective-c:
Class str = [NSString class]; // si' -- NSString non e' un'espressione
                              // valida perche' ObjC e' un superset di C
                              // e NSString e' un tipo.
[str stringWithFormat:"%d", 1234]; // si'.
 - ∞
(*) Questo permette di fare un trucco molto bello: se una superclasse
definisce un metodo statico (es. NSArray fa arrayWithArray:) e
all'interno usa [[self alloc] init]..., le sottoclassi produrranno da
questi metodi statici oggetti del PROPRIO tipo, non della superclasse.
Es:
NSArray* arr = [NSArray arrayWithArray: ... ];
NSMutableArray* arr2 = [NSMutableArray arrayWithArray: ... ]; // senza
bisogno di fare override!
-- 
http://millenomi.altervista.org/

 end
questo e' python?
leggermente diverso in ruby --
class String
   def self.il_mio_nome
      "Claudio"
   end
end


 non altrettanto semlice (fattibile?) in c++ o in java
Subclassando, facilissimo


 
è un mix

 Java) devono usarli.
Ah quindi questo esempio non calza. Però almeno mi sono fatto un'idea di 
come una classe in se stessa possa avere funzionalità anche senza essere 
istanziata :)

 Ma perchè non lanciarti direttamente con Python o con Ruby?
E non ho risposta a questo. A dire il vero credevo di trovare in Obj-C 
qualcosa di simile al C++ e quindi più semplice (per me) da imparare, ma 
vedo che sono caduto male...
Cmq grazie dei mille consigli :)

:

E' Ruby -_-
  ngw

 Comunque potrebbero entrare in Ruby 2.0
Cosa c'entrano i simboli con i named parameters ? :)
Per i named parameters si usa un hash, i simboli sono spesso usati come chiavi
ma in realtà non c'entrano nulla.
Saranno in Rite btw.
  ngw

 Direi che hanno appreso la lezione del Nutshell di Alex.
Sono libri profondamente diversi, e il pickaxe è precedente al nutshell di 2/3
anni.
  ngw

 E' potenzialmente in grado di...? Si' (GC).
Visto che quello di Python funziona cosě, direi proprio di si.


 è un mix
grrr


 2/3 anni.
Scherzi? Č cosě vecchia la prima edizione del Pickaxe? Io ho solo la
seconda su cui non c'č scritto di quando č la prima.


 E' Ruby -_-
beccato! :)


 Subclassando, facilissimo
Subclassare *non* è affatto la stessa cosa. Per esempio creare una
sottoclasse non cambia gli oggetti già esistenti. Caricare una categoria
si. Aggiungere un metodo dinamicamente pure.


 non altrettanto semlice (fattibile?) in c++ o in java
In C++ suppongo solo facendo lavori inenarrabili (o avendo già tutto
predisposto creando un bel po' di runtime a manella). In Java so che
puoi loadare dinamicamente delle classi e roba del genere, ma AFAIK
questo non cambia il comportamento delle classi esistenti.
Anzi... non so cosa succede nel caso di... aspetta. Fosse passando per
un Proxy. Boh. Questo lato di Java lo conosco poco: se una cosa
altrimenti banale è troppo complessa da fare, io non mi ci impegolo.
Cambio linguaggio.


 (unboxing).
Il che è sempre un hack. Conosco la diff tra value types e ref types.
Sono finito anche sul blog di Brad Adams per una spiegazione del genere.
Mi scuso se sono stato "generico" ma dopo un pò perdo i colpi su .NET
:-P
Grazie per la correzione
-- 
Lawrence - 
http://www.oluyede.org/blog
"Nothing is more dangerous than an idea
if it's the only one you have" - E. A. Chartier

 Non cosě tanto sui builtin, purtroppo.
Diciamo che in Ruby allora č tutto piů semplice


 e' la sintassi
Ma son l'unico Pythonista a cui la sintassi di ruby piace? heheh


 end
Ahahah ruby 100, objc -10


 Infatti non capisco quelli che dicono che Java è ad oggetti "puro". 
ho sempre saputo che fosse "ibrido". Chi lo definisce "puro".
Io sono dell'idea che ibrido e puro siano termini errati da usare in
questo contesto però


 Ma son l'unico Pythonista a cui la sintassi di ruby piace? heheh
+1


 Ahahah ruby 100, objc -10
Comunque quella di Claudio era brutta perchè ha compattato tutto con i
commenti e messo di fila quello che sta in tre files.
In realtà visto dentro xcode non è malaccio. E comunque per quando è
nato, ObjectiveC era geniale. Purtroppo non si è diffuso.


 ho sempre saputo che fosse "ibrido". Chi lo definisce "puro".
Ma no, sai quelli che dicono "è ad oggetti puro, pensa, perfino la main
deve stare in un oggetto". Che detto così sembrano anche una caterva di
dementi.
Ad ogni modo molti Javisti sono convinti che sia "la via".


 Diciamo che in Ruby allora è tutto più semplice
Che mo ci tradisci la causa è mo ti metti a scrivere rbrb?<g>
Scherzi a parte... allora non sono io che mi sono appena accorto che
appiccicare un metodo ad una stringa nun se po'. Buffo... in Python in
anni e anni non lo ho mai fatto.
In Ruby dopo pochi mesi ho codice in produzione che appiccica metodi
agli Hash.


 si. Aggiungere un metodo dinamicamente pure.
Hai ragione, in effetti aggiungere metodi ad oggetti di terze parti o
gia' esistenti e' una differenza sostanziale.
-- 
Firma in ferie

 seconda su cui non c'č scritto di quando č la prima.
Contando che il nutshell č del 2003 (a memoria), il pickaxe dovrebbe essere di
fine 2000.
  ngw

 agli Hash.
Io infatti ho sempre sostenuto che sono linguaggi profondamente differenti,
che al di la delle ovvie similitudini (duck typing, tipizzazione forte
dinamica, oo puri) portano ad uno "stile" e ad una forma mentale totalmente
differente (io, ribadisco, ormai uso Ruby anche mentre programmo in Python, e
senza nemmeno accorgermene).
Gli Hash li uso anch'io per creare querystring:
require 'cgi'
class Hash
  def query_string
    each_pair do |key, value|
      if value.kind_of?(Array)
        self[key] = value.map { |val| CGI.escape(val) }.join("+")
      else
        self[key] = CGI.escape(value)
      end
    end
    "?" << map { |kv| kv.join("=") }.join("&")
  end
end
{"foo" => "bar", "baz" => "foo bar"}.query_string č ?baz=foo+bar&foo=bar cosě
:p
  ngw

 vedo limiti tecnici.
Posso garantirlo io: questa parte di Python non e` assolutamente
difficile da compilare in linguaggio macchina (infatti Pyrex lo fa
tranquillamente, ad esempio).
Alex

 +1
Le graffe invece dell'"indent significativo"?  o la sottile distinzione
fra a..b e a...b?  Penso di si` -- chi ha questi gusti raramente e` un
pitonista (qualche eccezione ci sara` anche, immagino).
L'uso di @foo invece di self.foo e $foo invece di "global foo"?  Forse
no -- molti pitonisti aborrono lo stropping, ma non tutti (io ad esempio
ci vedo pro e contro).
Le RE embedded e l'uso di $` e $' e compagnia cantante?  Qui sono SICURO
di si` -- chi apprezza QUELLA robaccia e` sicuramente un utente perl,
NON python!-)
'nzomm: di dettagli sintattici in cui Python e Ruby differiscono ce n'e`
un tot, e per alcuni di essi preferire Ruby e` praticamente impossibile
per un pitonista, anche se, certo, possono esserci delle eccezioni.
Alex

 counting: nessun thread asincrono.
L'implementazione CPython usa reference counting, piu` mark&sweep
generazionale per rimuovere anche i cicli; altre implementazioni di
Python usano meccanismi diversissimi (Jython usa la GC di JVM,
IronPython quella di dotNET o Mono, ma entrambi sono ottime e fedeli
implementazioni di Python).
Alex

, che dubito sia quello
che intendi.  URL pls?
Alex

 Subclassando, facilissimo
se la classe che vuoi estendere e' tanticchia complessa (magari con
dietro un cluster di classi di cui non sai nulla) c'e' caso che
subclassare non sia sempre la soluzione + comoda (o anche possibile)

 nato, ObjectiveC era geniale. Purtroppo non si è diffuso.
poi conta che estende *senza toccarlo* il c

 Ok, ok...
ecco... 
(cambia qualcosa?)

 non ti definisci gli altri initializers. una palla eh.
lassa stér.. ;)

 Ma non è id che rallenta eh...
non stiamo a capirci, se scrivi in fortran e' improbabile che fai
programmazione generica, magari il nuovo fortran 95 supercazzola non te
lo impedisce, e' solo improbabile che lo fai
in ogni linguaggio si fanno le cose nel modo in cui (per cui) e' stato
pensato
no non e' id e' che in objc viene da stare piu' dinamici (ed e' giusto
che sia cosi')

 deve stare in un oggetto". 
gia', una jattura pazzesca ;)

 quanto vale c?
che e' quella pocheria che hai scritto? :-O

 avere la tipizzazione dinamica.
Hmmm -- sei familiare col concetto (LISP/CLOS/Dylan) di "generic
function", e "multimethods" come implementazioni delle GF?  La mia
vecchia proposta dell'Adaptation sta (in ottica di Py3000) mutandosi in
una di GF/MM, sostanzialmente dopo che Phil Eby ha mostrato come questo
classico concetto dell'OO avanzato puo` essere considerato una
generalizzazione della mia Adaptation e in effetti la implementa in modo
banale (Phil aveva iniziato implementando PyProtocols basato
sull'Adaptation, poi a un certo punto ha introdotto GF e MM e ne e`
rimasto "fulminato sulla via di Damasco").  Beh, GF/MM per certi versi
sono _l'overloading fatto *bene*_... e vivono benissimo in un ambiente a
tipizzazione dinamica (come LISP e CLOS dimostrano)... il punto
cruciale, come per l'adaptation, e` che una "terza parte" puo` far si`
che la funzione (generica) F accetti (e agisca correttamente con)
l'oggetto O, senza toccare una virgola del codice di F ne` di O...
Alex

 questi metodi statici oggetti del PROPRIO tipo, non della superclasse.
Questa e` la differenza fondamentale fra staticmethod e classmethod in
Python: staticmethod si comporta come i metodi statici in C++ o Java
(ignora l'eredita`), classmethod come i metodi di classe in Smalltalk o
ObjC (rispetta l'eredita`).
Alex

 vedo che sono caduto male...
malissimo, prima dimentichi il c++ e prima fai :-O
(no dai, non del tutto)
quanto alla domanda di M(a) Costén per darti una risposta considera che
se il tuo obiettovo e' primariamente sviluppare sw su piattaforma osx
obj-c e' forse piu' indicato
non che non si possa fare in python o ruby ma
a) e' sicuramente piu' involuto (certo ci sono i wrapper ma poranto con
se il loro overload di casini, per dire pyobjc con xcode 2.3 non si
compila, si compila se lo prendi dall'svn ma, almeno quando ho provato
io,  non passava i test... insomma *rogne* aggiuntive)
b) se devi *disegnare* intesamente sulla gui un linguaggio compilato e'
probabilmente meglio
c) tutto quello che impari sul dinamismo degli oggetti in objc non lo
butti se e quando vuoi aprire la tua mente a quella meraviglia di python
(ruby non lo conosco, a parte che e' *simile*, e quindi non giudico)
(se invece ti interessa sviluppare multipiattaforma il discorso e' molto
piu' complesso)

 grrr
:P

 E' Ruby -_-
lo so

 piu' complesso)
No, niente multipiattaforma. Non conosco quali sono i vantaggi di python 
o di ruby rispetto a obj-C, avevo deciso di avviarmi verso uno di questi 
linguaggi dinamici e ho scelto obj-C, anche perchè tempo fa mi trovai a 
copiare un esempio trovato su di un manuale Apple (di un programmino 
molto semplice in GUI) e ne rimasi a dir poco estusiasta (sopratutto per 
IB di cui mi innamorai...). Quindi ora ho deciso di continuare su quella 
strada :)
Poi cmq come riporti al punto c) mi serve entrare nella mentalità di un 
linguaggio *dinamico* (ho passato troppo tempo sul C, Java, C++, in 
quest'ordine).
Ciao!

 tranquillamente, ad esempio).
Ottimo. Vero, ci avevo anche fatto qualche giochino qualche anno fa con
Pyrex. Poi fra una cosa e l'altra non lo ho mai usato.



che al di la del fatto che Java č una palla, č davvero fatto bene.
Dicono peraltro che anche quello di VisualStudio sia cosě, ma io non lo


 gia', una jattura pazzesca ;)
lo penso anche io.


 NON python!-)
Per $' e compagnia sono d'accordissimo. Non piacciono (e non piacciono
anche a tanti rubysti), e infatti c'è un modulo apposta che da loro nomi
inglesi. Sempre bruttarello, ma almeno le parole dicono quello che sono,
la punteggiatura no.
Per le re embedded ci sono vantaggi e svantaggi. Nel senso che esistono
comunque gli oggetti Regexp che funzionano come oggetti normali e
semplicemente le regexp hanno una versione "literal" (con / /). Non mi
da più fastidio di tanto. Sono gusti eh.
Dicevo, il vantaggio è avere già sub nelle stringhe, per esempio.
foo.gsub(/\s/, '_')
io lo trovo abbastanza leggibile. E per certi versi mi piace di più di 
re.sub('\s', '_', foo)
o di 
rr.sub('_', foo)
Sono inezie, ma io logicamente la vedo come un'operazione su una
stringa, e mi sembra logico sia un metodo della stringa. Ovviamente in
Python non sarebbe comodissimo fare così. E poi uno può sempre vederla
come un operazione sul pattern che "trasforma".
Dal mio punto di vista le cose "brutte sintatticamente" di Ruby sono
altre. A me non fa impazzire il self. di Python. E freudianamente lo
scordo spesso -- ma tanto ci sono i test che mi aspettano al varco --.
Ma l'alternatvia è temibile.
Quando stai definendo in Python un metodo, sai che le cose che iniziano
per self. sono "robba di istanza". La roba locale non ha prefissi.
In Ruby dentro una classe quando definisci un metodo, sai che le
variabili di istanza sono @var. Ok, accettabile, non mi da fastidio.
Ma c'è un ma. Quando tu trovi 
def bar
  # ... code ...
  foo
end
non hai modo di sapere direttamente se foo è una variabile locale o un
metodo. E infatti l'interprete deve ricorrere ad euristica. Se ha visto
un assegnamento su foo, deduce che è una variabile, se no è un metodo.
Ora, da un punto di vista pratico per prendere i casi malati bisogna
impegnarsi. Sempre da un punto di vista pratico posso fregarmene se foo
è un metodo o una variabile.
Poi a vista quando sono "nel mezzo di una dichiarazione"
def bar
  # ... code ...
  foo
  # ... more code ...
end
sono quasi certo sia un metodo (e comunque l'editor può dirmelo eh...)
Ma quando sono in fondo no. Voglio che la funzione ritorni il valore di
foo, e su questo non ci piove; dopo tutto è sempre un espressione. Ma
non so cosa succede. Ok. Marginale eh... però...
Poi si arriva alle chicche.
a +b
viene interpretato come
a(+b) [ b è un intero, lo voglio specificare positivo, a un metodo ]
non come (a + b). Ok, a+b o a + b sono sicuramente più belli da leggere,
l'errore è un giocattolo e basta.
Però ribadisco.. se togliere le parentesi per certi versi può migliorare
la leggibilità (conoscendo il contesto, penso per esempio a certe cose
di Rails), in generale può essere un vero macello. Sono molto combattuto
a riguardo.


 essere di fine 2000.
azzo. credevo fosse più giovine. allora evidentemente ho detto una
strunzata.


 che sia cosi')
Si, ma quello che voglio dirti è che ObjC è pur sempre compilato in
codice macchina, inoltre i meccanismi "lenti" sono molto ottimizzati dal
runtime.
Globalmente non lo senti come linguaggio "lento", questo voglio dire. Se
ti metti a misurarlo forse su certe cose salta fuori che C++ è più
veloce, ma finisce li.


 poi conta che estende *senza toccarlo* il c
Vero. È una bellissima cosa.


 che e' quella pocheria che hai scritto? :-O
È una cosa che in C++ (o in C99) e in C89 ha valori diversi. Ti lascio
intuire il perchè.


 subclassare non sia sempre la soluzione + comoda (o anche possibile)
Anzi, molti designer di strutture ad oggetti dicono esplicitamente "non
subclassate se non conoscete *bene* la cosa che state subclassando".
Poi in Java non si può neppure subclassare tutto, figuriamoci.


 l'oggetto O, senza toccare una virgola del codice di F ne` di O...
Si questo certo. Ma nel contesto di cui discutevamo, parliamo
dell'overloading alla C++. In pratica avere metodi con lo stesso nome
che accettano parametri diversi. Ma se non hai piů limitazioni di tipo e
in pratica nemmeno di numero, l'overloading "povero" non serve.


 (ruby non lo conosco, a parte che e' *simile*, e quindi non giudico)
Vero. Ma perchè non partire direttamente dai piatti succulenti?


 IB di cui mi innamorai..
Ribadisco, IB è relativo a Cocoa, indipendentemente dal linguaggio in
cui ci programmi. Quindi va bene uguale con Python o con Ruby. 


 cui ci programmi. Quindi va bene uguale con Python o con Ruby.
si, ho capito il discorso di IB. Anzi, stamattina faccio un salto in 
libreria della mia città, se non trovo libri su Obj-C (che mi sa sono un 
pò rari vista la poca diffusione del linguaggio), ne prendo un su Python ;)

 In questa i programmatori hanno imparato la lezione. 
quoto e' l'unica cosa in cui preferisco la sintassi di ruby

 cui ci programmi. Quindi va bene uguale con Python o con Ruby. 
ib si, il sovraccarico di rogne sta nei wrappers

 Vero. Ma perchè non partire direttamente dai piatti succulenti?
dipende dalle priorita', se e' ilportante una applicazione ottimizzata
monopiattaforma io starei su objc, viceversa se voglio rimanere (anche
futuribilmente) + portatile, ma a quel punto il cocoa lo lascerei
perdere e punterei su qt/wx

 intuire il perchè.
beh il commentino... ma c99 e' c++ senza le classi?

 wrote:

se non hai preclusioni ideologiche 
amazon.co.uk
arrivano in poco e non paghi la dogana
un libro fondamentale se ti interessa cocoa e'
http://www.amazon.co.uk/exec/obidos/ASIN/0321213149/qid=1150878430/sr=1-
1/ref=sr_1_2_1/202-5858255-1087836
se non vuoi buttare soldi evita come la peste
http://www.amazon.co.uk/exec/obidos/ASIN/0764573993/ref=pd_bxgy_img_2_cp
/202-5858255-1087836

 NON python!-)
sta roba non piace nemmeno a me :-)
-- 
Lawrence - 
http://www.oluyede.org/blog
"Nothing is more dangerous than an idea
if it's the only one you have" - E. A. Chartier

 Ad ogni modo molti Javisti sono convinti che sia "la via".
nella mia uni Java č la via, difatti a fine mese arriva Gosling in
persona a fare una conferenza per tirar su un pň di adepti :-P


 agli Hash.
è lo stile di programmazione che diventa diverso. Se guardi Rails è
pieno di estensioni del genere :-)


 beh il commentino... ma c99 e' c++ senza le classi?
no è C revisionato nel 99


 no è C revisionato nel 99
si chiaro, mi chedevo se nella revisione l'avevano avvicinato alla
sintassi del c++ (per quelle cose senza le classi in cui c89 e c++
divergavano)

 (cambia qualcosa?)
Er, no...
 - ∞
-- 
http://millenomi.altervista.org/

 Visto che quello di Python funziona così, direi proprio di si.
Ah ops, si parla di pyobjc :)
Sarebbe bello vederlo pero' in funzione sul runtime principale. Al WWDC
vedremo tutto quanto.
 - ∞
-- 
http://millenomi.altervista.org/

 ho mai usato.
Si'. E' il pro-pro-pro-pronipote di quello di Visual Basic e fa il suo
lavoro ben piu' che egregiamente. Ultimamente (da VS .NET in poi) ha
mutuato certe caratteristiche (come le guide automatiche per la
spaziatura, il docking e la possibilita' di istanziare oggetti non
visuali) da IB.
 - ∞
-- 
http://millenomi.altervista.org/

 Globalmente non lo senti come linguaggio "lento"
(Certo che pero' con un certo tot di pagine web aperte l'amico Safari,
che usa il WebKit, che usa ObjC e C++, diventa 'na chiavica.)
 - ∞
-- 
http://millenomi.altervista.org/

 poi conta che estende *senza toccarlo* il c
Be', alle volte capitano sovrapposizioni (ad esempio compilare SDL con
il compilatore objective-c apple non si puo' perche i campi di certe
strutture si chiamano "id").
 - ∞
-- 
http://millenomi.altervista.org/

 /202-5858255-1087836
Grazie uliano!
In effetti sono appena ritornato dalla libreria e non ho trovato 
niente!!! Ne obj-C e nemmeno su Python (si vede che abito proprio in una 
piccola città...).
Ok, lo prendo da amazon :)



pinòlo ;-P

.
 - ∞
-- 
http://millenomi.altervista.org/

 wrote:

per il python direi che per cominciare "learning python" di orilli e'
ottimo

 ObjC (rispetta l'eredita`).
Annotato. (Non si smette mai d'imparare :p)
 - ∞
-- 
http://millenomi.altervista.org/

 la punteggiatura no.
A dir la verita $' č regexp_match.pre_match, l'altro č
regexp_match.post_match. I vari $1, $2 e schifezza andante č regexp_match[1],
regexp_match[2] e cosě via.
Guarda la classe MatchData.
Io per dire non ho mai usato English in vita mia.
  ngw

 quoto e' l'unica cosa in cui preferisco la sintassi di ruby
Beh, consolati, li il folding è facile da fare :)


 vedremo tutto quanto.
Si. E vedremo anche quando pyobjc comincia a litigare con il nuovo gc
:))


 visuali) da IB.
Poi possiamo dire anche che IB č cosě da tempo e che quando č uscito era
*fantastico*.


 persona a fare una conferenza per tirar su un pò di adepti :-P
Gosling a parte tutto è un hacker con le palle e vale la pena di
sentirlo eh...


 che usa il WebKit, che usa ObjC e C++, diventa 'na chiavica.)
Qui non tanto. Ma non credo sia una questione di linguaggio :)


 divergavano)
Hanno aggiunto i commenti // (che tecnicamente nel C89 non sarebbero
validi). Hanno aggiunto anche i vla... e un po' di roba. Ma no, non è
C++ senza classi. È C99 :))


 pieno di estensioni del genere :-)
Vero. E alle volte se ne abusa. 
Ma in effetti rails di cose "strane" ne ha. Si stava facendo una
discussione su render che forse... insomma, diciamo che si poteva forse
progettare meglio.


 ib si, il sovraccarico di rogne sta nei wrappers
Ma si... nulla che non paghi i vantaggi, però. A meno che uno non debba
proprio scendere nelle viscere di MacOS X.


 perdere e punterei su qt/wx
Io ti dico... Python + Cocoa non ha grossi svantaggi e ha un treno di
vantaggi.


 PEEEERCHEEEEEH!" :)
Eh beh. Certo.


 Beh, consolati, li il folding è facile da fare :)
pork put vak borell...
sto ancora cristonando, sgrunt
cmq folding a parte l'approccio a indentazione e' poco sano anche per la
gestione dei tab e amenita' simili

 proprio scendere nelle viscere di MacOS X.
allora diciamo cosi', alle prima, facciamo seconda
applicazione seria sviluppata in pyobjc che vedo cambio idea 
;PPP

 gestione dei tab e amenita' simili
Basta gestire i tab non usandoli :)


 Io per dire non ho mai usato English in vita mia.
Neanche io. Per le regexp ci sono anche i nomi umani, lo so. Parlavo del
fatto in generale dei vari $punteggiatura che appunto uno può (se lo
infastidiscono) non usarli mai.


 applicazione seria sviluppata in pyobjc che vedo cambio idea 
Potresti usarla e non saperlo. Io tipicamente non vado dentro i bundles
a cercare Python. Poi le "applicazioni serie" sappiamo tutti che non
sono un buon metro.


 Basta gestire i tab non usandoli :)
e' una cosa poco pulita poco chiara poco lineare
poco "python" insomma

 sono un buon metro.
uh?

 in pratica nemmeno di numero, l'overloading "povero" non serve.
Vero, serve poco, se puoi discriminare solo sul numero di parametri e
non su altro; quelle due volte in croce che ti serve e` abbastanza
banale farlo "a mano", tipo:
def foo(self, *a):
    overload = getattr(self, 'foo%d' % len(a), None)
    if overload is None:
        raise TypeError, "Can't call foo with %d args" % len(a)
    return overload(*a)
def foo0(self): ...
def foo1(self, x): ...
etc.
Alex

 banale farlo "a mano"
Si, o addirittura chiedere di usare i named parameters e sfangarsela con
un po' di codice che lavora sul dizionario.


 poco "python" insomma
Si usano gli spazi, 4, 2, 8 quanti ne vuoi ma gli spazi.
Vedi PEP 8
http://www.python.org/dev/peps/pep-0008/
-- 
Lawrence - 
http://www.oluyede.org/blog
"Nothing is more dangerous than an idea
if it's the only one you have" - E. A. Chartier

 gestione dei tab e amenita' simili
??


 sentirlo eh...
Beh diciamo che le ultime sparate che ha fatto sui linguaggi dinamici me
lo fanno percepire come uno poco "aperto" di mente.
Ecco qui
http://www.disco.unimib.it/XML/contenuti/evento/dettaglioEvento.jsp?_cid
=778fc486&param1=190040312&param2=96462919&_crc=707dba8


 
http://www.python.org/dev/peps/pep-0008/
e' una rottura configurare l'editor a mettere gli spazi quando premi tab
insomma una cosa a cui devi pensare, cosa della quale ne faresti a meno,
e, se ti scappa un tab o un altro carattere che l'editor assimila a uno
spazio, ti vai a inrognare
sostanziamente e' una complicazione gratuita

 lo fanno percepire come uno poco "aperto" di mente.
Queste non le ho lette. Magari gli si sono un po' limate le palle e
adesso preferisce dire quello che il marketing chiede.
Ma una volta Lisp gli piaceva...
Comunque di Ruby parla ovviamente male. Rischia di levargli la fetta piů
debole di mercato da sotto il culo (le piccole applicazioni, dove le
servlet sono semplicemente un overkill, oltre che un incubo), con il
sensato rischio di disruptive technology [ e tutto il carrozzone di modo
di pensare dinamico che si tira dietro ].


 :))
Immagino che funzionera' nel seguente modo:
 - il codice compilato con -fobjc-gc avra' chiamate di intercettazione
sulle assegnazioni;
 - il codice non compilato con -fobjc-gc dovra' usare retain/release.
 - avere un riferimento a un oggetto Objective-C in un contesto GC
incrementa il retain count dell'oggetto. (Un -release non puo' rimuovere
questo -retain?)
Questo garantirebbe che un oggetto sottoposto a GC possa essere usato da
codice tradizionale e viceversa. E farebbe funzionare pyobjc lo stesso
(basta non aggiungere -fobjc-gc ai flag di compilazione).
Ma questo me lo sto immaginando io, eh.
 - ∞
-- 
http://millenomi.altervista.org/

 Qui non tanto. Ma non credo sia una questione di linguaggio :)
Pero' puo' essere questione di "pesantezza" dovuto all'overhead di tutto
lo smacello suddetto (altri browser filano piu' lisci).
Sto su un G4 1ghz, 768mb ram.
 - ∞
-- 
http://millenomi.altervista.org/

 Sto su un G4 1ghz, 768mb ram.
Infatti.


 Ma questo me lo sto immaginando io, eh.
È probabile eh.


 sostanziamente e' una complicazione gratuita
Se lo dici tu. Io uso gli spazi dappertutto ;-)
con TextMate mi è bastato 1 click, nemmeno 2!!!


 con TextMate mi č bastato 1 click, nemmeno 2!!!
pssst... lui usa TM :)


 con TextMate mi è bastato 1 click, nemmeno 2!!!
un click e' sempre piu' di 0 il neurone deve pensarci... e se magari e'
fritto dall'alcool o altro e non lo fa...

 pssst... lui usa TM :)
ma non gli ho ancora fatto click ;)
(meno male che sono abba consistente coi tab :-D)

 inelegante
Diciamo "gusti personali" :-)
Io con Python finalmente vedo codice LEGGIBILE da subito e da li non si
scappa. Son contento che il linguaggio forzi lo stile. Può piacere o no,
a me non dispiace.


 a me non dispiace.
come tutte le cose che *mi forzano* non mi piace (e non perche'
altrimenti non avrei indentato... proprio non reggo chi decide per gli
altri da presupposti paternalistici) ;P

 -- "Today, you can build
native, uncompromising, best-of-breed Mac OS X applications using only
Python", dicono.  L'articolo e` dell'Agosto 2005; la versione Universal
di PyObjC e` uscita da neppure un mese, spero che la cosa sia ancora
vera (ma non l'ho ancora provata).
Alex

 wrote:

beh su ppc e per il python 2.3.5 standard l'installer fa *UN CASINO
DELLA MADONNA* andando a piazzare un scco di roba nella home del tipo
che la sviluppa (forse ronald) che ti viene creata appositamente dentro
users :-)
invece compilandosela a amano, tutto liscio (anche col xcoe 2.3 che
prima untava, ho provato)
ma il punto e' checce' ne dica apple, ci sono ste uncompromised best of
breed applications oppure no
in 10 mesi da che e' uscito quell'aritcolo NEMMENO una
delle tre
a) l'affermazione di apple e' quantomeno poco realistica
b) la comunita' pitonica e' non sa sviluppare full breeded applications
c) la comunita' pitonica si sbatte il bigolo a riguardo di osx e
piuttosto pensa a essere cross plataform

Allora mi aggancio qui per postare qualche altro dubbietto su Obj-C:
Inizio, non ho capito la funzione degli operatori "retain" e "release". 
In particolare in questa utilizzati in questa funzione (sto leggendo 
Learing Cocoa with Objective-C):
(void)seTName:(NSString *) newName
{
	[newName retain];
	[name release];
	name = newName;
}
Dove name č una variabile d'istanza (NSString).
Altro particolare. Si parlava del metodo init (prima vabbč quello 
standard ereditato dalla classe NSObject), che viene subito 
specializzato in questa forma:
(id)initWithName:(NSString *)newName artist:(NSString *)newArtist
{
	[super init];
	[self setName:newName];
	[self setArtist:newArtist];
	return self;
}
Ora mi chiedevo, ma come mai il costruttore ritorna un tipo "id" (quando 
puoi nel corpo ritorna self)?? Non era giusto (o piů corretto) ritornare 
Song (che poi č la classe che si sta costuendo)??
Infine se hai un pň di pasienza, proprio non č molto chiaro il concetto 
di metodo di classe...spero che continuando nella lettura mi venga 
chiarito perchč proprio non capisco a cosa serve.
Grazie!!!

 Song (che poi è la classe che si sta costuendo)??
Se usassi (Song*) come return type, andrebbe bene a GCC per quanto
riguarda la classe Song, ma se hai una sottoclasse (ad esempio RockSong)
lui si lamenterebbe alla linea return self; perche' RockSong* e Song*
sono tipi di classe diversi (o almeno mi pare che lo faccia anche se
logicamente non dovrebbe). Dovresti allora scrivere return (Song*) self;
per forzare il tipo del self.
So che c'era anche un Altro Importante Motivo che in questo momento mi
sfugge assai.
PS: un modo piu' intelligente sarebbe:
- (id)initWithName:(NSString *)newName artist:(NSString *)newArtist
 {
        if (![super init])
                return null;
        [self setName:newName];
        [self setArtist:newArtist];
        return self;
 }
o meglio ancora:
- (id)initWithName:(NSString *)newName artist:(NSString *)newArtist
 {
        if (self = [super init]) {
                [self setName:newName];
                [self setArtist:newArtist];
        }
        return self;
 }
perche' -init di NSObject e' garantito che ritorna un oggetto, e allora
la versione originale funziona, ma -init di altre classi no. Se devi
fare subclassing di altre classi di Cocoa (esempio NSDocument che devi
sottoclassare per forza) devi stare attento, perche' -init puo'
ritornare nil.
La seconda forma e' paranoide, perche' certe classi (NSArray) possono
persino NON ritornare l'oggetto puntato da self (e' una tecnica
denominata class cluster, e' un po' un casino). Se usi i modelli di
Xcode (File > New File), il codice che vedrai e' proprio di questa forma
paranoica.
 - ∞
-- 
http://millenomi.altervista.org/

 paranoica.
Eh troppo presto per me, ho da poco cominciato ad interessarmi al Obj-C.
Cmq grazie mille per i consigli!!!

 paranoica.
La classe corretta del cluster viene scelta in -alloc e NON sostituita in -init
Personalmente la forma if ((self = [super init])) non la uso da un bel po'.
Ciao
Mirko

 Cmq grazie mille per i consigli!!!
No problem. E' semplice in realta', e' solo difficile da spiegare :p
 - ∞
-- 
http://millenomi.altervista.org/

 bel po'.
Ero convinto che fosse -init a sostituire l'oggetto, che poi spiegava
anche tutta la forma if (self = ...) che Apple usa religiosamente
ovunque ci sia un -init (in template e documentazione).
 - ∞
-- 
http://millenomi.altervista.org/

         nome = nuovoNome; // ora e' sicuro che se uso nome piu' tardi
Anche qui nome = [nuovoNome retain]; si puo' usare.
 - ∞
-- 
http://millenomi.altervista.org/

 ovunque ci sia un -init (in template e documentazione).
Se non ricordo male quella forma veniva usata dai tempi di NeXT, ma il motivo
non lo esatto conosco. Le classi che effettuano una sostituzione in 
-init sono poche.
Cerca il post a riguardo nel blog di Wil Shipley e il thread in cocoa-dev.
Ciao
Mirko

 Cerca il post a riguardo nel blog di Wil Shipley e il thread in cocoa-dev.
Cerchero'. So che Shipley (...o non era lui?) predicava "usate if
(![super init]) che e' molto piu' comoda"...
(Comunque io uso la forma Appleosa se non altro perche' e' quella che
sta nel template Code Sense "init" gia' pronto di Xcode).
 - ∞
-- 
http://millenomi.altervista.org/

 Semplicemte cosě non avrebbe funzionato?
Eh no!
Facendo come scrivi, il vecchio valore di name rimane in memoria a
penzolare fino al termine dell'applicazione. Inoltre quando qualcuno lancia
all'oggetto puntato da newName un messaggio "release", la variabile istanza
name rimane a puntare il nulla.
Programmi abitualmente in Java, vero?
-- 
Ma piu' mi insultano piu' mi ricarricano

 Programmi abitualmente in Java, vero?
A furia di spiegare autorelease, mi sono dimenticato di 'sto pezzo
extraimportante :°°
 - ∞
-- 
http://millenomi.altervista.org/

 extraimportante :같
era troppo ovvio e non ci hai fatto caso :)
dapprima avevo accolto la decisione di insegnare java come primo linguaggio
nei corsi universitari come una cosa assolutamente positiva, adesso mi sto
ricredendo: sono sempre piu' convinto che il linguaggio per apprendere la
programmazione resti il C


 programmazione resti il C
Al corso di laurea di Ingegneria Informatica al Poli di Milano, prima si
impara il C (e conseguente mappatura tra istruzioni C e quelle
effettivamente eseguite dalla macchina) e solo dopo si passa a Java.
 - ∞
-- 
http://millenomi.altervista.org/

 No problem. E' semplice in realta', e' solo difficile da spiegare :p
Eh si lo penso pure io, questione di abitudine ;)

 Programmi abitualmente in Java, vero?
Si, diciamo che č il linguaggio da cui provengo (insieme al C++)

 dall'esterno...o sto dicendo un mare di sciocchezze?
ti faccio un esempio in C, probabilmente ti sara' piu' chiaro
int *a, *b
// Inizializziamo a come un array di 255 interi
a = (int *)malloc(255, sizeof(int));
// anche b adesso punta alla memoria puntata da a
b = a;
// Rilasciamo la memoria puntata da a
free(a);
// Adesso sia a che b non sono piu' validi


 dall'esterno...o sto dicendo un mare di sciocchezze?
ti faccio un esempio in C, probabilmente ti sara' piu' chiaro
int *a, *b
// Inizializziamo a come un array di 255 interi
a = (int *)calloc(255, sizeof(int));
// anche b adesso punta alla memoria puntata da a
b = a;
// Rilasciamo la memoria puntata da a
free(a);
// Adesso sia a che b non sono piu' validi
-- 


 Si, diciamo che č il linguaggio da cui provengo (insieme al C++)
Caccia all'errore (se c'č).
class A{
  void setName(char* name){
      name_ = name;
  }
private:
  char* name_;


 fallimento di +alloc. -init non dovrebbe fare niente.
In effetti ha anche senso. Se non c'è la memoria, è già alloc che
dovrebbe fallire, ad init non ci si arriva ancora. E init non dovrebbe
in se allocare memoria, IIRC.
Forse gli +initWith... o no? Al momento non ho sotto mano un testo.


 newName è parametro di input) non vedo il motivo di andarlo a specificare.
Per la semplice ragione che siccome non hai un garbage collector, te la
devi stregare tu. Come ti hanno detto, quando un oggetto ha il reference
count a 0, possiamo semplificare dicendo che viene distrutto.
Quando è distrutto. È morto. Kaput.
Quindi tu in name non ci hai una stringa. Ci hai un cadavere putrefatto
e a rompergli le palle mandandogli dei messaggi, rischi solo che ti
provi a succhiare il cervello in stile B-Movie.
Il modello di programmazione non è sincrono. È a eventi. Tipicamente se
non fai *mai* dei retain e dei release, ti trovi dei memory leak. Se fai
dei release e non dei retain ti trovi in crash. Non vedo davvero cosa ci
sia di difficile.


 programmazione resti il C
È una vecchia disputa. Java non va bene, deforma la mente, siamo
d'accordo. IMHO la cosa migliore resta fare linguaggi dinamici (per
imparare a scrivere software e a progettare) *e* C o C++ per lavorare un
po' su altre cose.
Java da solo è evidentemente insufficiente.


 }
Errori sintattici non mi sembra ce ne siano, l'unica cosa che posso 
ipotizzare č che facendo una cosa del genere:
---------
A myobj;
char * mystr;
mystr = (char *) malloc(10*char);
A.setName(mystr);
delete(mystr);
----------
A questo punto anche A.name non punta piů a nulla, giusto?

 sia di difficile.
Oh grazie! Era quello che volevo sapere. Quindi aspettiamo la prossima 
versione con garbage collection e tutto sarà (almeno per me) più semplice ;)

 // Adesso sia a che b non sono piu' validi
Ok, ottimo, capito!

 A questo punto anche A.name non punta più a nulla, giusto?
Questo è un problema. Ma potrebbe essere risolto sulla stessa lunghezza
d'onda.  Ecco... correggiamolo così (poi perchè usi gli allocatori del C
e non quelli C++?)
class A{
   void setName(char *name, size_t sz){
        name_ = new char[sz];
        strncpy(name_, name, sz);
   }
private:
   char* name_;
};
lascia stare possibili errori di sintassi e compagnia... non vedi nulla
di davvero *malato*?


 versione con garbage collection e tutto sarà (almeno per me) più semplice ;)
Che il garbage collector semplifichi la vita è (relativamente) indubbio.
Relativamente nel senso che i programmatori C++ con le palle e lavorano
in RAII dicono di non averne bisogno (e in parte hanno ragione). Peccato
per le altre complicazioni aggiuntive.


 Già iniziano ad emerfere:
Io parlavo delle complicazioni del C++ :))
Comunque si... immagino che passare un framework pensato in un modo su
gc possa dare un bel po' di problemini. Anche se AFAIk gli stessi non
cis ono lavorando con PyObjC oppure Java...


 per forzare il tipo del self.
Maaaa sbaglio o questo in Obj-C vale solo perché così l'IDE ti aiuta?
AFAIK potrebbe dichiarare che ritorna euro, pizze o foto del Purrone e
sarebbe perfettamente valido (anche se non una buona idea). Sbaglio?  


Chiedo a te, che sei sempre documentatissimo... ma è vero che nelle
ultime build di Safari (quelle del 10.4 credo) esso usa già il GC?

 di davvero *malato*?
Di malato vedo che se la dimensione si sz non corrisponde alla 
dimensione di name oppure se name non è allocato, allora in name_ non 
sappiano cosa ci va a finire...

 Forse gli +initWith... o no? Al momento non ho sotto mano un testo.
Chiaramente intendevo gli 
+stringWith...
+arrayWith
etc


 sarebbe perfettamente valido (anche se non una buona idea). Sbaglio?
AFAIK ObjectiveC non implementa nessun controllo di tipo piů del C.
Ovvero se gli fai ritornare double invece che puntatori, piange. Ma se
ritorna un NSArray* invece che un NSString* o un id, afaik non dice
nulla.
Ma era una cosa cui non avevo mai pensato, in effetti. Attendo maggiori
spiegazioni "teoriche" :)
Questo codice da solo qualche Warning.
#include <Foundation/Foundation.h>
NSArray* baz(){
  return [NSString stringWithString:@"Hello"];
}
int main(){
  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
  NSArray *s = [NSString stringWithString:@"Hello"];
  NSLog(@"%d %@", [s length], s);
  NSLog(@"%@", baz());
  return 0;
}
D'altra parte la tipizzazione statica dei linguaggi "tradizionali" č
solo per i deboli di cuore.


 sappiano cosa ci va a finire...
domanda: che fine fa la stringa puntata da name_ prima dell'assegnazione
(**)?


 (**)?
Uhm...nulla, resta dove sta...vuoi dire che non viene deallocata? 
Continua dopo la nuova allocazione (**) ad occupare memoria.

 sappiano cosa ci va a finire...
No. Specificare la dimensione a parte è abbastanza comune in C, e si
spera che il programmatore che chiama la funzione lo faccia
correttamente.
Quel codice lassu è da licenziamento in tronco. C'è un errore
*elementare* che su una funzione chiamata sufficientemente spesso può
semplicemente fare franare il programma alla lunga.
Ovvero c'è un memory leak grosso come una casa. Viene sempre allocata
memoria, e poi va perduta ogni volta che viene chiamata setName.
Non per farmi i fatti tuoi, ma dove lo hai imparato il C++? Perchè,
senza offesa, io direi che proprio non lo conosci (e mi si spiegano
tutti i problemi che hai con ObjectiveC).
D'altra parte io di andare direttamente con Python o Ruby lo avevo detto
eh :)


 eh :)
Sisi, lo tengo a mente! Ma preferisco ora continuare con Obj-C visto che 
ho trovato del materiale e se trovo un libro di Python dò uno sguardo 
anche a quello!

 solo per i deboli di cuore.
Yeah. Sex, drugs, and runtime typization :D

 In effetti del C++ conosco solo la teoria
qua non si vuole crocefiggere nessuno, ma non peggiorare ulteriormente la
tua situazione!! :))


 sarebbe perfettamente valido (anche se non una buona idea). Sbaglio?
salvo poi spararti una pernacchia quando a runtime non viene trovato il
metodo (unknown selector)


 Continua dopo la nuova allocazione (**) ad occupare memoria.
Esatto.


 tutti i problemi che hai con ObjectiveC).
Scusa, sembro piů brusco di quello che volevo essere. Un ottimo testo č
il manuale di C++ di Lippman Lajole. Vale senza dubbio la pena di essere
letto (anche se io non sono patito di C++, pur dovendo lavorarci
parecchio).


 +arrayWith
Questi metodi sono usati come scorciatoia per unire allocazione e 
inizializzazione.
(+alloc/-init/-autorelease)
Ciao
Mirko

 tua situazione!! :))
ROTFL :)


 Yeah. Sex, drugs, and runtime typization :D
Si, ma preferisco il sesso.


 metodo (unknown selector)
Si.. o forse no. Dipende dal metodo e dalla delegazione :)
Comunque chiaro che mettere tipi e poi violarli č discutibile. Piuttosto
vai coll'id :)


 metodo (unknown selector)
Beh ma non crasha, no?
A., che se il debugging è più facile che scrivere codice non c'è
divertimento :)

 Beh ma non crasha, no?
Uhm... diciamo che non gode.
2006-07-02 22:19:51.218 a.out[25754] *** -[NSCFString swigala]: selector
not recognized [self = 0x504320]
2006-07-02 22:19:51.219 a.out[25754] *** Uncaught exception:
<NSInvalidArgumentException> *** -[NSCFString swigala]: selector not
recognized [self = 0x504320]
Trace/BPT trap


 inizializzazione.
Questo lo so :)
E in effetti non capisco il punto della mia stessa domanda. Non ho idea
di quello che volevo scrivere. Ho corretto il +initWith... che non aveva
senso e non mi sono preoccupato di vedere se il resto lo aveva.
Sigh. Il caldo.


 tua situazione!! :))
:)

 Esatto.
Ah però in questo post ci ero arrivato :p

 parecchio).
Ma figurati, no problem. Sono qui per imparare e se ci vuole quale 
zamanzina la accetto volentieri :)

 ultime build di Safari (quelle del 10.4 credo) esso usa già il GC?
Dato che in 10.4 _NON_ c'e' supporto, nel runtime, per il GC, a meno che
WebKit nuovo si porti appresso un Cocoa e un libobjc tutti nuovi, direi
proprio di no.
 - ∞
-- 
http://millenomi.altervista.org/

 }
In realta' lo stile tipo* per riferirsi a un oggetto e' un extra di GCC.
Esistono implementazioni di ObjC (esempio POC) che NON permettono questo
stile, ma solo di usare id.
 - ∞
-- 
http://millenomi.altervista.org/

 stile, ma solo di usare id.
Vero. Anche perchč POC afaik č solo un preprocessore + runtime, ma non č
un compilatore vero e proprio. Sbaglio?
