Newsgroup: it.comp.os.linux.development
Titolo: linguaggi

Salve, mi stavo chiedendo, esiste in giro un linguaggio con le 
caratteristiche simili a Java ma open source?
Con caratteristiche simili a Java intendo fortemente tipizzato, ad 
oggetti, con garbage collector, e cose cosi'..
Python ad esempio non mi piace perche' e' troppo lasco con i tipi..
Che mi dite ?

Ciao, {MSX}!
Il giorno 01/07/2004 alle ore 20:48 hai scritto:
 M> Con caratteristiche simili a Java intendo fortemente tipizzato, ad
 M> oggetti, con garbage collector, e cose cosi'..
http://www.mono-project.com
E' il porting di .Net, piu' simile a Java di questo...
Bye
-- 
Great warrior? Wars not make one great.
http://www.maccasoft.com

 E' il porting di .Net, piu' simile a Java di questo...
Eh l'avevo visto.. ma non fa per me.. Mono sara' anche open source, ma 
.net e' quanto meno open source ci sia (visto che c'e' in mezzo microsoft)..
Sicuramente quest'ultima fara' di tutto per avvelenare la compatibilita' 
e tutto il resto come ha sempre fatto finora.

 ha
scritto::

Che a me piacciono i linguaggi dinamici, e tu evidentemente vuoi
linguagi con tipi statici, non forti ;P
Comunque i primi linguaggi statici e con GC che mi vengono in mente
sono:
SmartEiffel: 
smarteiffel.loria.fr
OCAML: 
www.ocaml.org
Sather: 
www.icsi.berkeley.edu/~sather
Nice: 
nice.sf.net
Oberon:  
www.oberon.ethz.ch
Scala: 
scala.epfl.ch
Tecnicamente credo che esistano librerie che fanno garbage collection
automatica anche per il C++ ma non saprei dirti quali. 
Credo che anche la maggior parte dei dialetti del lisp abbiano la
possibilità di usare soft typing (nel senso che è possibile usare
dichiarazioni, nel tuo caso le useresti sempre)
HTH

Ciao, {MSX}!
Il giorno 01/07/2004 alle ore 20:57 hai scritto:
 M> Eh l'avevo visto.. ma non fa per me.. Mono sara' anche open source, ma
 M> .net e' quanto meno open source ci sia (visto che c'e' in mezzo
 M> microsoft).. Sicuramente quest'ultima fara' di tutto per avvelenare la
 M> compatibilita' e tutto il resto come ha sempre fatto finora.
http://www.ecma-international.org/publications/standards/Ecma-335.htm
Bye
-- 
Fear is the path to the Dark Side.
http://www.maccasoft.com

 
http://www.ecma-international.org/publications/standards/Ecma-335.htm
Quello è lo standard del CLI, non di .Net. E, comunque, l'ECMA può dire
quello che le pare, ma il brevetto per tutto l'ambaradàn ce l'hanno alla
Microsoft, e non è che l'azienda abbia precedenti di coerenza.
Può anche darsi che Mono diventi un sistema usato, ma non è detto che
rimanga (o possa rimanere) in parallelo con .Net.
Ciao,
 Emmanuele.
-- 
Emmanuele Bassi (Zefram)                 [ 
http://www.emmanuelebassi.net
 ]
GnuPG Key fingerprint = 4DD0 C90D 4070 F071 5738  08BD 8ECC DB8F A432 0FF4

 
Ad una conferenza su .net e compagnia M$ sproloquiava sull'open-source e sul
fatto hanno rilasciato i sorgenti delle librerie .net (si vede dalla
compatibilità di mono ... che sostanzialmente ha sempre bisogno di
ritoccate per funzionare). Se vuoi il massimo integralismo sulla visione OO
del mondo ti consiglio smalltalk 
http://www.smalltalk.org/
.
Ciao ciao
VV
-- 
Valerio Vaccaro aka TulipAn
http://vaccaro.altervista.org

del mondo ti consiglio smalltalk 
http://www.smalltalk.org/
.
Emh.. mi sono perso un msg o questo non c'entrava molto? :)
un po' meno integralista ('if' e 'while' non sono messaggi) c'è ruby.
Ma l'OP cercava linguaggi con tipazione statica. ( tipoizzazione?
tipaggio?)

> 
http://www.ecma-international.org/publications/standards/Ecma-335.htm
E da quando in qua la microsoft segue gli standard scusa ? La microsoft 
solitamente li avvelena...
E comunque un qualsiasi prodotto i cui copyright siano in mano alla 
microsoft (o a qualunque altra, per quello), puo' essere standard quanto 
vuoi, ma io non ci penso due volte a cestinarlo

 linguagi con tipi statici, non forti ;P
Cerco un linguaggio con tipizzazione statica e forte.

Cerco un linguaggio con tipizzazione statica e forte.
<flamebait>
che non è Java, gli manca il 'forte' 
</flamebait>
Mi viene in mente che forse il linguaggio D ha una forma di GC
automatica, ed è OO. Mi è sempre parso un progetto interessante. 

 automatica, ed è OO. Mi è sempre parso un progetto interessante. 
Ora guardo, grazie

Java non e' fortemente tipizzato ?
Se lo fosse non esisterebbe un eccezione apposta per gli errori di
cast :)
Non è che abbia letto A Theory of Objects, però java 1.4 aveva dei
problemi, quelli dovuti all'assenza di generic che ne limitavano sia
l'affidabilità  che l'espressività, vedi:
http://www.pragmaticprogrammer.com/cgi-local/pragprog?JavaIsUntyped
e
http://www.inf.ethz.ch/~meyer/ongoing/covariance/recast.pdf
in java 1.5 ci sono i generics, ma pare ci siano sottili fastidi anche
li:
http://www.artima.com/intv/generics2.html
e
http://www.zhangyining.net/weblog/blog_detail.html?item_id=155
ma ora basta fare il troll, mi fermo :)

 
http://www.zhangyining.net/weblog/blog_detail.html?item_id=155
Bah, questo articolo non mi dice nulla.. Sta semplicemente tentando di 
fare delle cose che non si possono, per motivi chiari che lui stesso 
esprime.

resto.
non è questione solo di collezioni, e in molti punti devi usare dei
cast (parlo sempre di pre-generics, ora nn so come funzioni).
Ed è anche un problema di espressività, come spiega il secondo link.
Io non sono a priori contro i tipi scoperti staticamente e forti,
ritengo solo 
- che quello di java non è un buon sistema
- che i pro di una tipazione stile java sono molti meno dei contro

  php, basic, e buona parte dei rimanenti linguaggi esistenti.
Mi pare che siano mischiati, in questo elenco, sia linguaggi fortemente
che debolmente tipizzati...
Ad ogni modo, hai un link o qualcosa che spieghi come java sia 
piu` fortemente tipizzato di C++ o Python?
Non e` ironia, vorrei semplicemente capire alcune cose.
-- 
Francesco Romani - Ikitt   (signature under [re]construction)
'A geek is someone who spends time being "social" on a computer.'
'In fact, users don't read /anything/'                         -- Joel Spolsky

 tipizzato e meglio e'
ne ero relativamente convinto anche io.
poi ho scoperto che mi sbagliavo.
in Python si sviluppa molto piu` alla svelta ed e` possibile usare gli
oggetti per quello che fanno, non per quello che sono. :))
-- 
RiK0
 Il sonno del teschio genera troll, e il quoting li manifesta.

 tipaggio?)
Gghghgh 
vero :)


  oggetti per quello che fanno, non per quello che sono. :))
Questo vantaggio deriva dal polimorfismo AFAIK.
Perche` python _e`_ fortemente tipato (ovvero: fa controllo sui tipi).


oggetti per quello che fanno, non per quello che sono. :))
(colpo di scena, passo dalla parte dei linguaggi statici)
però 'quello che fanno' non è appunto l'interfaccia dell'oggetto?
E considerato che in python l'uso di oggetti con metodi singleton è
piuttosto scarso, non sarebbe più conveniente controllare
quell'interfaccia a compile time?
E' vero che usando python (o smalltalk o ruby) si ottiene una grande
'produttività', ma imo si tratta di un insieme di fattori che vanno
oltre il problema dei tipi.

Perche` python _e`_ fortemente tipato (ovvero: fa controllo sui tipi).
on solo il polimorfismo. In quel senso questo:
def stampa seq
  for i in seq
    print i
è grossomodo equivalente di questo
void stampa(Sequence seq)
  for (Object i in seq)
    print(i)
Ma devi considerare anche i valori di ritorno dalle funzioni, che in
java/c++ non sono modificabili tramite ereditarietà (esempio: clone())
ed il classico esempio di new che non è polimorfico. 

 Perche` python _e`_ fortemente tipato (ovvero: fa controllo sui tipi).
yes, ma mi pareva che nel resto del thread con 'tipizzato' si intendesse
specialmente 'staticamente tipato'.


 quell'interfaccia a compile time?
forse... anche se a me da questo punto di vista piace cosi`.
Se cerco un linguaggio appena piu` statico (ma sempre parecchio
dinamico), uso per esempio ObjectiveC, dove in effetti posso tipizzare
staticamente come lasciare tutto indeterminato con 'id'.


  specialmente 'staticamente tipato'.
OK, allora torna :)


 oggetti per quello che fanno, non per quello che sono. :))
Scusa ma metti che stai sviluppando un progetto insieme ad altre 20 
persone, e che quindi conosci il 5% circa del codice totale.
Ora, hai bisogno di cambiare il tipo di un campo di una classe (perche' 
al tuo DBA di fiducia e' girata di cambiare il db).
In python, cambi il campo e subito tutto compila correttamente, e poi ti 
devi cercare gli errori a runtime ripercorrendo tutto l'applicativo, 
andando a vedere dove il campo e' usato, leggerti codice altrui, ecc 
ecc, magari col rischio, correggendo, di cambiare qualcosa che non 
dovevi senza accorgertene. Il tutto con una percentuale tuttaltro che 
bassa di generare errori.
In java, cambi il campo, ricompili e ti dice automaticamente tutti i 
posti in cui viene usato e quindi dove vanno operate le correzioni, 
senza possibilita' di errore.
E non venitemi a tirare fuori di nuovo le collezioni perche' e' la 
solita solfa, (e comunque basta crearsi delle classi con getter e setter 
tipizzati che incapsulano le collezioni generiche, e comunque ora ci 
sono i generics).

sono i generics).
La "storia delle collezioni" è un esempio, ogni altro esempio è l'uso
di un cast. Parlando di esempi, prendi il codice del J2EE tutorial
riguardo i JMS e nota quanti try/catch ci sono per gestire i typecast
e l'impossibilità di java di avere valori di ritorno multipli.
Credo valga praticamente per qualunque posto dove sia usato un factory
method. Ti piace java e va bene, ma il suo sistema dei tipi non è
perfetto.

 perfetto.
Non e' perfetto, daccordo, ma e' sulla strada giusta per la perfezione, 
sicuramente piu' degli altri.
Inoltre se mi piacesse veramente Java, non avrei chiesto che alternative 
ci sono.

sicuramente piu' degli altri.
Eiffel è su quella strada. Sather forse. OCaml in un certo modo. Mi
dicono anche Ada. 
Java è appena uscito sul pianerottolo di casa. 

 Che mi dite ?
Io terrei in considerazione php5...
-- 
--------------------------------------------------------------------
Non system disk or disk error, replace and strike any key when ready
--------------------------------------------------------------------

Io terrei in considerazione php5...
non ha i tipi forti e static come vuole l'OP

 Che mi dite ?
Esiste almeno una implementazione open source di Java; si tratta del 
compilatore GCJ che fa parte del pacchetto GCC del progetto GNU.
Vedi: 
http://gcc.gnu.org/java/
Alternativamente esiste il linguaggio C#, implementato dal progetto 
Mono. Se pensi che la Microsoft possa bloccare tale progetto, ti sbagli. 
L'unica cosa che puo' fare e' continuare a modificare la propria 
piattaforma in modo che il progetto Mono faccia fatica a starle dietro 
con gli aggiornamenti, ma se il tuo obiettivo e' la piattaforma Linux, 
il problema non si pone.
Vedi: 
http://www.mono-project.com/about/index.html
Infine, se l'unica cosa che ti manca al linguaggio C++ e' la garbage 
collection, esiste un garbage collector open source che si puo' usare 
per gestire la memoria evitando di usare le keyword "new" e "delete".
Vedi: 
http://www.hpl.hp.com/personal/Hans_Boehm/gc/
-- 
     Carlo Milanesi
 
http://digilander.libero.it/carlmila

 
scusate la mia ignoranza.
non conosco nč java nč C# ma in che senso questi sono linguaggi piů
fortmente tipizzati di altri (in particolare mi riferisco a Visual Basic e
C++)?
[cut]