Newsgroup: it.comp.programmare
Titolo: Linguaggi

Un salutone a tutti!!
E' la prima volta che posto su questo NG, affascinato da sempre dal mondo
della programmazione adesso ho deciso di mettermi seriamente a studiare. Fin
adesso ho evitato di postare per evitare le solite domande da
principiante....ma una grande curiosità dovete togliermela!!Vorrei sapere
qualcosa circa i vostri percorsi di studio, quali linguaggi conoscete e
quali sono stati i vostri tempi di apprendimento per ognuno di essi. Inoltre
qualche consiglio per evitare di incappare in fregature (Libri , scuole,
corsi pacco ecc.).
Sperando che la questione possa essere di largo interesse vi ringrazio
anticipatamente per le vostre risposte.
A presto!!

corsi pacco ecc.).
Tutto è molto relativo, un linguaggio è sicuramente più semplice da
imparare se ne conosci molti altri e dipende dall'interesse messo
nello studio del linguaggio.
Io ho iniziato da VB (ma ti sconsiglio di farlo) che ho imparato in
qualche mese.
Javascript (lo conosco però male) una settimana.
C++ un anno, ma per conoscerlo bene bene serve molto più tempo.
Python 2 giorni (non sto scherzando).
Perl lo sto studiando ora.
Evita in generale i corsi, libri evita quelli della Jackson perché
spesso sono tradotti molto male.
-- 
                    Marco Barisione (ICQ 84277092)
Se sei interessato alla creazione di it.comp.lang (per i linguaggi di
programmazione senza un gruppo apposito e per i confronti fra i
linguaggi) partecipa alla discussione sul manifesto su it.news.gruppi.

Python 2 giorni (non sto scherzando).
in 2 giorni hai imparato _tutto_ il Python?
--
Rhymes
rhy...@myself.com
http://www.foxhound-games.it

in 2 giorni hai imparato _tutto_ il Python?
Sicuramente non tutto ma ero in grado di scrivere applicazioni che in
C++ ero capace a scrivere dopo un anno.
Molti moduli di python sono molto simili a quelli del C, per quanto
riguarda il linguaggio in sé (trasscurando parti come la realizzazione
di estensioni in C) è molto semplice ed intuitivo.


Sicuramente non tutto ma [...]
Bhé però ero a casa con l'influenza quindi almeno un 23 ore al giorno
sono stato incollato al computer :-)
Comunque se non sbaglio Alex Martelli (che adesso sta scrivendo un
libro su python per O'Reilly) dopo 6 mesi era già considerato un
esperto di Python.


corsi pacco ecc.).
guarda... in questi anni in cui ho programmato, ho imparato molti
linguaggi, ma l'unica cosa che veramente mi e' servita e' la tecnica
di probrammazione.
Impara a scrivere del buon codice, leggibile, efficiente, fatot bene
insomma, se poi lo scriverai in C++ o Pascal o Java o VB si vedra',
non sempre puoi scegliere tu il linguaggio... 
ciauz
Vincenzo 'lo sciamano'   Bologna (ITALIA-ITALY)
Homepage  
http://www.geocities.com/vincesalsero/
Membro Fondatore del CSM (Club Seghe Mentali)
http://www.seghementali.org

esperto di Python.
ho letto qualcosa su questo linguaggio (che tra tutto sembra essere
una sorta di java)... mi sapresti dire per che tipo di applicazioni è
adatto (grafica, gestionale, automazione...)?
--
Ciao!
Davide

corsi pacco ecc.).
io sono in qs NG da poco, ma frequento da un pò gli altri legati alla
programmazione e allo sviluppo di algoritmi.
Ricordati che per imparare ad hoc un linguaggio è utile avere una
spinta, un interesse, che in caso di contrattempo non ti faccia
perdere la voglia e la curiosità di andare avanti... io con questi
sistemi ho imparato "da dio" (ovvero non ho più bisogno di consultare
manuali o altro) la maggior parte delle cose che so.
Principalmente conosco linguaggi Web-oriented prevalentemente
utilizzati nel mio lavoro, ovvero linguaggi di scripting come
vbscript, javascript, vrml (questo c'entra veramente poco con la
programmazione),java, e visual basic per la programmazione client.
da poco mi sto buttando su waba per la programmazione di palmari Palm
OS, ma penso che l'abbandonerò per utilizzare C.
--
Ciao!
Davide

esperto di Python.
Si ma hai presente il background che aveva prima di iniiziare col
Python??


adatto (grafica, gestionale, automazione...)?
E` adatto a tutti i tipi di applicazione che non richiedono una grande
velocità (o la richiedono solo in piccole parti di codice che puoi
scrivere in C o C++), lo puoi comunque usare in tutti i campi in cui
usi Java (dai un'occhiata a jython).
Inoltre Python si sta diffondendo rendendo sempre più semplice trovare
moduli che fanno quello che vuoi tu.


Python??
Ma no  cosa dici conoscerà si o no solo 10000 linguaggi di
programmazione! ;-)
Comunque la velocità nell'imparae Python è dovuta sia alla sua
semplicità sia al fatto che gli header standard del C sono disponibili
come moduli per Python, quindi per chi conosce il C o il C++ c'è molto
risparmio di tempo.


 evitare di incappare in fregature (Libri , scuole, corsi pacco ecc.).
avendo avuto un percorso da autodidatta sono in generale molto scettico 
sulla validita' di corsi e scuole. Molto meglio avere un buon libro; 
pero' su questo argomento non ti posso consigliare dato che i libri di 
adesso (a parte alcuni classici) sono diversi da quelli disponibili "ai 
miei tempi".
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 programmazione e allo sviluppo di algoritmi.
in quali ng si parla di algoritmi?


il mio percorso di studi e' stato abbastanza variegato e "strano"
Tu 'll'ha bell'e visto lo strano, te :-)
Io ho cominciato con il "BASIC" dello ZX81, che faceva caa', e quindi sono
passato molto presto all'assembler Z80 (anche perche' in 16K non c'era poi
molto da scialare), fedele alla linea Sinclair presi il QL (sniff! Ce l'ho
ancora) che aveva un BASIC abbastanza potabile, e di li' sono passato all'
assembler 68000; all'universita' mi mazzularono subito col FORTRAN, che ho
fatto del mio meglio per dimenticare, e col Pascal. E per reazione imparai
il Clipper :-) - dopodiche' mi spiegarono che esiste il C e l'SQL, e cosi'
passai a quelli. Piu' o meno in quel periodo, ebbi l'illuminazione, a cura
dei proff. Soda e Cesarini (pace e benedizioni scendano su di loro), tanto
che ancor oggi chiamo "codice" solo quello che ho scritto DOPO quella data
(il resto, lo chiamo "merda": un po' volgare, ma rende l'idea). Poi Linux,
e questo significava bash a grandine, Web (e quindi HTML, Java, Javascript
e PHP; per necessita', ASP). Ho visto il C# e sono scappato :-)
In qualche momento di questo tortuoso percorso ho imparato OpenScript, che
poi Asymetrix ha deciso di lasciar perdere, e VisualBASIC... ma questi due
li cito a parte, perche' si parlava di "linguaggi".
I miei linguaggi preferiti rimangono assembly 68000 e x86, C e PHP... c'e'
un collega che tenta di portarmi sul sentiero del C++ - ma la Forza scorre
potente in me, e per ora ho resistito :-)
Leonardo
-- 
".signature": bad command or file name

potente in me, e per ora ho resistito :-)
Perché?


Perché?
Non c'e' un perche'. Per ora e' cosi'. Domani, chi sa.
Leonardo whatever will be, will be


 2002 (previsione)       C++ / python / lisp(forse)
2002 (consiglio)       C++ / smalltalk / python / prolog / lisp(forse)
Con precedenza a C++ (che già lo mastichi bene) seguito da smalltalk e
python (se non altro perchè questi due linguaggi li impari,
rispettivamente, in 2 e 4 giorni, totale meno di una settimana per
entrambe!. Qualche cosa di più per capire i meccanismi più complessi e
le librerie).
Prolog e Lisp dopo perchè all'inizio li troverai leggermente ostici.
Fatti una infarinatura (una o due settimane per ciascuno). Poi
eventualmente passa qualche tempo a "macinare" nella testa come e quando
i due approcci possono essere vantaggiosi. Infine ... approfondisci il
lisp (o un linguaggio simile).
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 --
manca lo spazio: trattino-trattino-spazio, non trattino-trattino.
Maurizio
-- 
Maurizio Sambati
Skice Software
E-mail: 
gsm...@inwind.it
--------------------------

smalltalk [...] in 2 [...] giorni
E` cosě facile?


 due, però sono interessato)
Primo perchè il consiglio era per Antonio Cuni del quale conosco il
livello di preparazione e, più o meno, gli interessi attuali.
Secondo perchè approfondire Prolog va bene se ti serve lavorare con un
motore inferenziale (per esempio se devi sviluppare un sistema esperto).
Mentre il Lisp è più generale come linguaggio (e soprattutto come
paradigma) e imparare a ragionare secondo il paradigma funzionale (e
capire la lambda notazione e il lambda calcolo) è comunque utile anche
se lavori poi con linguaggi che non supportano nativamente questi
concetti.


concetti.
Anch'io sono interessato al Lisp, dove posso trovare su internet
materiale DI BUONA QUALITA da cui partire?
P.S. Per quanto riguarda l'e-mail che hai mandato io ho la stessa età
di Antonio Cuni...


 E` cosě facile?
Scherzi? Il linguaggio in se (regole sintattiche e cose simili) lo
impari si e no in un paio d'ore. Il resto ti serve per farci
l'abitudine. Alcune cose sono assolutamente semplici ma l'opposto di
come sei abituato a farle, quindi tendi a sbagliare. Come tenderesti a
sbagliare se ti dicessi di programmare in C** che č identico al C++
salvo che usi le graffe al posto delle tonde e viceversa e che usi ' al
posto di . e . al posto di ; e ; al posto di :
Per capirlo ci vuole il tempo di leggerlo. Per impararlo ci vogliono un
paio di minuti (fissarti in testa le differenze) per usarlo ...
class foo (
public;
    foo{int &i}.
    double foobar{}.
).
double bar{}
(
    foo f{3}.
    return f'foobar{}.
)
facile. E riesci persino a leggerlo. Ora prova a scriverlo. Scriviti un
pezzettino di codice qualunque in cui dichiari una classe e definisci
una funzione in cui chiami un membro di una classe.
Scherzi a parte č MOLTO piů difficile una transizione di questo genere.
Le differenze fra lo smalltalk e gli altri linguaggi non č cosě
drastica. Soprattutto perchč tende a rendere il codice molto piů
leggibile che non in altri linguaggi.
Per esempio paragona:
aRect.setSize( 3, 4 );
con
aRect setWidth: 3 height: 4.
oppure
val = a < b ? c : d;
con
val := (a < b) ifTrue: c ifFalse: d.


 val := (a < b) ifTrue: c ifFalse: d.
Tu come interpreti questa riga smalltalk?
Nota che le parentesi intorno a a<b sono opzionali e che il codice non
corrisponde esattamente a quello C++. Per avere l'equivalente avrei
dovuto scrivere:
val := a < b ifTrue: [c] ifFalse: [d].
Ti stupirai di sapere cosa succede.
In pratica:
il metodo '<' chiamato per l'oggetto 'a' con parametro 'b'. Questo ha
come risultato un booleano per il quale viene chiamato il metodo
'ifTrue:ifFalse:' che è un metodo unico con due parametri. Il valore
ritornato da questo metodo viene assegnato a 'val'.
Il mistero delle parentesi quadre si svela in questo modo: il due
parametri del metodo 'ifTrue:ifFalse:' non sono valori ma bensi blocchi
di codice. Un blocco di codice in smalltalk è a tutti gli effetti un
oggetto. Il metodo non ritorna uno dei due parametri ma piuttosto il
valore della valutazione del parametro.
La cosa più simile in C++ sarebbe dire che operator? è un membro della
classe bool che prende due puntatori a funzioni e che ritorna il valore
ottenuto chiamando una delle due funzioni.
Oppure potremmo dire che la sintassi della chiamata potrebbe essere
qualche cosa del tipo:
a.operator<(b).operator?( { return c; }, { return d; } );
anche se non ha molto senso dovrebbe rendere l'idea della possibilità di
passare come paramtero ... un blocco di codice (che in C++ si scrive fra
graffe).
E se la cosa ti intrippa ti aggiungo che:
la classe Boolean esiste, ma non funziona come ti aspetteresti tu.
Ovvero non ha due possibili istanze o cose simili. Piuttosto è (in
termini C++) una classe astratta. Ovvero che non ha istanze ma definisce
semplicemente dei metodi (tutti i metodi in smalltalk sono virtuali).
Poi esistono due classi derivate da Boolean che si chiamano True e
False. Naturalmente queste due classi sono ... singleton. L'unica
possibile istanza di True è globalmente accessibile con il nome true
(nota che la classe ha la maiuscola e il valore no). Ovviamente l'unica
possibile istanza di False è globalmente accessibile con il nome false.
A questo punto puoi immaginare come sono implementati i vari metodi (fra
cui il famoso metodo 'ifTrue:ifFalse:'. Se non ci arrivi da solo
continua a leggere.
Vuoi una bella notizia? Se hai seguito fino a questo punto conosci il 70
percento del linguaggio e sei quasi certamente in grado di capire anche
alcuni meccanismi che smalltalk usa. Non solo: hai anche già imparato
alcuni concetti "avanzati" (come il fatto che un blocco di codice è un
oggetto, che è una delle cose più difficili da capire!!).
Per dimostrarti che sei in grado di "leggere" (o meglio di capire) buona
parte del linguaggio ti posto una buona parte dell'implementazione delle
classi Boolean, True e False (non tutte nel senso che non ti posto tutti
i possibili membri ma solo alcuni in modo che ti fai un'idea). Scommetto
che cogli il meccanismo senza bisogno di altre spiegazioni. Al punto che
per ridurre la lunghezza del messaggio ELIMINO dal codice i commenti!!
Arriva:
Smalltalk.Core defineClass: #Boolean
 superclass: #{Core.Object}
 indexedType: #none
 private: false
 instanceVariableNames: ''
 classInstanceVariableNames: ''
 imports: ''
 category: 'Kernel-Objects'
------------------------------
Core.Boolean class >> new
 self error: (#errCreateBoolean << #dialogs >> 'You may not create any
more Booleans - this is two-valued logic')
------------------------------
Core.Boolean >> not
 self subclassResponsibility
------------------------------
Core.Boolean >> & aBoolean
 self subclassResponsibility
------------------------------
Core.Boolean >> | aBoolean
 self subclassResponsibility
------------------------------
Core.Boolean >> xor: aBoolean
 ^(self == aBoolean) not
------------------------------
Core.Boolean >> ifFalse: alternativeBlock
 self subclassResponsibility
------------------------------
Core.Boolean >> ifFalse: falseBlock ifTrue: trueBlock
 self subclassResponsibility
------------------------------
Core.Boolean >> ifTrue: alternativeBlock
 self subclassResponsibility
------------------------------
Core.Boolean >> ifTrue: trueBlock ifFalse: falseBlock
 self subclassResponsibility
------------------------------
Smalltalk.Core defineClass: #False
 superclass: #{Core.Boolean}
 indexedType: #none
 private: false
 instanceVariableNames: ''
 classInstanceVariableNames: ''
 imports: ''
 category: 'Kernel-Objects'
------------------------------
Core.False >> not
 ^true
------------------------------
Core.False >> & alternativeObject
 ^self
------------------------------
Core.False >> | alternativeObject
 ^alternativeObject
------------------------------
Core.False >> ifFalse: alternativeBlock
 ^alternativeBlock value
------------------------------
Core.False >> ifFalse: falseBlock ifTrue: trueBlock
 ^falseBlock value
------------------------------
Core.False >> ifTrue: alternativeBlock
 ^nil
------------------------------
Core.False >> ifTrue: trueBlock ifFalse: falseBlock
 ^falseBlock value
------------------------------
Smalltalk.Core defineClass: #True
 superclass: #{Core.Boolean}
 indexedType: #none
 private: false
 instanceVariableNames: ''
 classInstanceVariableNames: ''
 imports: ''
 category: 'Kernel-Objects'
------------------------------
Core.True >> not
 ^false
------------------------------
Core.True >> & alternativeObject
 ^alternativeObject
------------------------------
Core.True >> | alternativeObject
 ^self
------------------------------
Core.True >> ifFalse: alternativeBlock
 ^nil
------------------------------
Core.True >> ifFalse: falseBlock ifTrue: trueBlock
 ^trueBlock value
------------------------------
Core.True >> ifTrue: alternativeBlock
 ^alternativeBlock value
------------------------------
Core.True >> ifTrue: trueBlock ifFalse: falseBlock
 ^trueBlock value


 [cut]
ma che lavoro fai scusa, guadagni un pacco di milions al mese?
con tutti sti linguaggi  :-)
Ciao Roberto

 E` così facile?
   In effetti si`: ha una struttura molto semplice ma anche molto 
espressiva (oggetti e messaggi). Magari non e` molto richiesto nel mondo 
del lavoro (anche se, in vita mia, almeno *un* programma commerciale 
scritto in parte in SmallTalk l'ho visto).
 
http://www.smalltalk.org
-- 
Alla prossima,
Marco

scritto in parte in SmallTalk l'ho visto).
In realtà è poco usato in Italia. Ma nel mondo è il linguaggio più
diffuso dopo i soliti mainstream (cioè dopo C, C++, VB).
Prima di flames sulla posizione relativa di Java e Python vorrei fare un
distinguo.
Vi sono vari tipi di progetti.
A) Applicativi con un certo livello di complessità (gestionali, editor
specifici, CAD/CAM, newsreaders/mailreaders  etc. etc.)
B) Applicativi internet server (lato server di applicativi web enabled,
tipo home banching etc.).
C) Siti internet et simili (lato server di sistemi di web-presentation,
di solito solo siti con qualche cosa di piò di pagine statiche o
pseudostatiche ma senza la complessità di progetti grossi come la
fornitura di servizi via internet).
D) miniapplicativi, routines di servizio, scripts, batches etc. etc.
Per i prodotti di caso A i linguaggi principalmente usati sono C, C++ e
(leggermente meno) VB. Subito dietro viene Smalltalk. Ci sono anche
progetti in altri linguaggi (fra cui Java, Ada e ultimamente Python) ma
in numero molto minore.
Per i prodotti di caso B i linguaggi principalmente usati sono C, C++ e
Java. In caso di C/C++ l'applicativo ha la forma di una estensione del
server internt (si dice CGI se non mi sto fondendo la materia grigia).
Nel caso di Java si solito è un Server (il principio è comunque quasi lo
stesso). In questi casi il progetto prevede di solito dei sottoprogetti
sviluppati secondo i criteri del gruppo C o D. Altri linguaggi che
stanno emergendo o che sono parecchio diffusi sono Python, PHP, C# e
alcune implementazini smalltalk con estensioni (librerie) apposite.
Per i prodotti di caso C i linguaggi principalmente usati sono ASP, Java
Script e VB Script. Stanno emergendo anche C# e smallscript. Spesso in
questi progetti ci sono sottoprogetti sviluppati secondo i criteri del
gruppo D.
Per i prodotti del gruppo D di linguaggi molto usati ce ne sono
moltissimi. Principalmente credo che si trovino degli script di shell,
perl, Python, Java etc. etc.
Per limitarci al mondo dei prodotti della classe A, se i linguaggi in
assoluto più usati sono C e C++ (con il nuovo in C++ e il vecchio in C o
in un misto fra i due), una grossa fetta del discorso tocca anche a VB.
In questo mondo smalltalk è di casa e ha una importanza simile a quella
di VB. In generale se l'applicativo tende ad essere piccolo e limitato a
Windows VB è più diffuso. Se è grosso o se è portabile è molto più
diffuso smalltalk. Per applicativi estremamente grossi e/o complessi (e
in italia praticaemtne non se ne fanno) è persino più diffuso smalltalk
che C++.
Disclaimer: le statistiche sono dovute a me e solo a me e si basano
sulla percezione che ho io del mondo dello sviluppo SW in ambito
internazionale (soprattutto in USA).


 approfondisci il lisp (o un linguaggio simile).
Perlomeno dopo che ho imparato il lisp mi programmo emacs :-))


 Perlomeno dopo che ho imparato il lisp mi programmo emacs :-))
ROTFLOVL


dimenticavo di farti notare [...]
Lo credo guarda a che ora di notte scrivi!
Ma adesso mi domando cosa studiare per primo Lisp o Smalltalk, quale è
più diverso dal mio modo di pensare (io programmo soprattutto in
Python e C++)?
P.S. Sono contento che tu ti sia messo a frequentare anche questo ng
che sicuramente ne gioverà.


stesso)
Piccola correzione. I CGI Java non si chiamano Server ma Servlet ^_^


 Python e C++)?
Prima smalltalk che praticamente hai quasi già imparato dai miei
messaggi. Inoltre è molto molto semplice e veloce. Se ti ci dedichi
fulltime ti bastano un paio di giorni per il linguaggio. Prenditi anche
una o due settimane per realizzare un progettino semplice tanto per
farti un'idea e per capire (almeno in parte) le librerie.
Nota: la cosa che prende più tempo è imparare a usare il sistema di
sviluppo (i vari browser etc.).
Non prefiggerti di partire con GUI e cose simili. All'inizio evita
magari anche l'IO da tastiera/video. Pensa a un programma che legge da
file e scrive su file. I file di ingresso te li crei con notepad se sono
brevi e di testo o con un programmino (anche scritto in un linguaggio
che già conosci) se sono lunghi e/o binari.
Il Lisp lo guardi dopo.
Rispetto al tuo modo di pensare smalltalk è una
generalizzazione/semplificazione (la difficoltà sta nelle piccole
differenze, ma è comunque OO). Lisp è un altro mondo. Un altro modo di
pensare. Un altro paradigma.


 con tutti sti linguaggi  :-)
di lavoro faccio lo studente: primo anno di informatica. E, putroppo, 
niente mllions al mese :-(


 messaggio ELIMINO dal codice i commenti!!
in effetti, con un po' di sforzo, si riesce a capire piu' o meno come 
funziona il tutto (anche se, non conoscendo la sintassi, e' un po' 
ingarbugliato da farsi...). Devo dire che mi hai fatto venire la 
curiosita': ancora qualche mese e poi mi butto sullo smalltalk.
ciao anto


 ROTFLOVL
ehm... mi sfugge il significato di OVL...


 ehm... mi sfugge il significato di OVL...
Out Very Loud
