Newsgroup: it.comp.lang.c++
Titolo: Robustezza in C++

Ho da scrivere un programma molto robusto dove non devono assolutamente
verificarsi blocchi, orbene volevo farlo i C++ ma mi dicono che farlo in
Java č 100000000 piů robusto ed efficiente. Personalmente non so, voi cosa
dite a riguardo?
Grazie dell'attenzione.
-----------------------------------------------------------------
Francesco Fassi
frances...@libero.it
-----------------------------------------------------------------

 dite a riguardo?
Il rapporto e` esagerato, ma, se devi a tutti i costi scrivere un
programma molto portabile, oltre che robustissimo, Java ha in
effetti dei vantaggi sostanziali.
La mancanza di puntatori, e di operazioni di "delete", elimina
d'acchito la principale causa di bug di programma.  Operazioni
che in C++ (portabile, cioe` in mancanza di soluzioni tipiche
solo di una data piattaforma) possono causare abort che non
puoi controllare, in Java possono essere "catturabili" con il
meccanismo delle exception.  Non puoi inoltre fare l'errore di
programmazione di trascurare le possibilita` di exception per
distrazione, in quanto il compilatore Java e` tenuto a verificare
che tu catturi, o esplicitamente propaghi, tutte le possibili
eccezioni.
Sull'altro piatto della bilancia devi porre pesi minori, ma non
del tutto trascurabili, come il fatto che NON puoi *assolutamente*
contare sui "finalize" in Java (succedono se vogliono, e quando
vogliono, e ci puoi fare poco o nulla) come puoi invece contare
sui distruttori in C++, e quindi tante operazioni di terminazione
(rilascio risorse, ecc) che in C++ automatizzi con il meccanismo
dei distruttori in Java devi programmarle invece esplicitamente
con un try/finally.
Comunque, al netto di tutto, il bilancio di produttivita` e` con
alta probabilita` a favore di Java (sempre che la portabilita`
serva piu` dell'estrema efficienza/prestazioni in esecuzione,
ovvero che la piattaforma per il programma non offra soluzioni
specifiche/proprietarie da te usabili in C++).
Alex

>con un try/finally.
Avevo gia' scritto un messaggi ma non mi sembra di averlo visto e quindi mi accodo qui.
Io aggiungerei che per quanto rigaurda la robustezza bisogna anche considerare che con Java hai la Java Virtual Machine di mezzo e quindi ti "becchi" anche i suoi bug.
Antonio

Antonio Donatiello <ant...@REMOVETHISgeminisoft.com> wrote in message
news:10lnkgn$rkh$1...@fe2.cs.interbusiness.it...
    ...
Io aggiungerei che per quanto rigaurda la robustezza bisogna anche
considerare che con Java hai la Java Virtual Machine di mezzo e quindi ti
"becchi" anche i suoi bug.
...mentre con C++ ti "becchi" i bug del compilatore, librerie di run-time, e
eventuali altre librerie addizionali che tu usi.  Mediamente, patta.  (Se
non
credi al numero INCREDIBILE di bug di compilatori, librerie, ecc, del C++,
leggi un po' il Windows Developer Journal, che ha una regolare feature
"Bugs++" che ogni mese ne analizza qualcuno, tutti mostruosi).
Alex

 
IMHO e' altamente improbabile che Java diventi piu' efficiente di una
buona implementazione di C++, per le caratteristiche intrinseche del
linguaggio (vedi ad esempio la mancanza della possibilita' di allocare
su stack e la presenza forzata del garbage collector).
AFAIK allo stato attuale (cioe' date le CPU e gli algoritmi odierni),
cio' e' addirittura impossibile.
Per quanto riguarda la sicurezza, AFAIK Java non garantisce in
assoluto una sicurezza maggiore del C++, ma piuttosto rende piu'
semplice (e probabile) la scrittura di programmi corretti.
Ciao,
-- 
Diego    | Per le repliche elimina dal mio indirizzo le 
Dainese  | `x' e inverti le due parole intorno alla `@'

alta probabilita` a favore di Java
Questo sicuramente...
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

 ti permette di curare meglio certi dettagli o sbaglio?
Si`, ma non e` chiaro che questo (a parte i distruttori, che ho
nominato) possa sostanzialmente essere usato per aumentare
la robustezza del proprio software (le _prestazioni_, certo).
Alex

>"Bugs++" che ogni mese ne analizza qualcuno, tutti mostruosi).
Ci credo eccome. Qualche tempo fa beccai un bug di Visual C++ su espressioni del tipo
(x << 2)  | (y << 4)
compilando con le ottimizzazioni (mannaggia a loro, portano sempre problemi) dava risultati sbagliati.
In una successiva MSDN Library venne segnalato e mi sembra nella SP3 e' stato correetto.
Antonio

>eventuali altre librerie addizionali che tu usi.  Mediamente, patta.
: Certamente. Pero' questi li becchi anche con Java. Semplicemente JVM
essendo uno strato in
: piu' "teoricamente" porta piu' problemi.
Non e` solo una questione di numero di strati, ma di complessita` di
ciascuno strato.  Il C++ e` un linguaggio piu` complesso (supporto
del generic programming, compatibilita` molto ampia col vecchio C,
controllo molto piu` fine da parte del programmatore di vari aspetti)
quindi c'e` ragione di aspettarsi piu` bug nelle infrastrutture che lo
supportano, non meno!, rispetto ad un linguaggio meno complesso,
come Java.
: Inoltre puoi avere problemi diversi a seconda delle diverse
implementazioni della JVM. Naturalmente hai il
: vantaggio della portabilita' del progamma... (per chi ci crede!).'
In C++ devi ricompilare su ciascuna piattaforma che ti interessa, quindi
incontrerai bug diversi (di sicuro nel generatore di codice e nelle
librerie di run-time, che variano per piattaforma; e se non usi lo
stesso identico compilatore su tutte le piattaforme, anche negli
altri strati).  In Java, varia solo la JVM (non occorre ricompilare),
che rappresenta una parte non maggiore dell'infrastruttura.
"Teoricamente", dunque, non vi e` nessuna ragione di aspettarsi
che le infrastrutture per Java portino piu` problemi relativi alla
robustezza di quelle per C++.
Pragmaticamente, bisogna scegliere specifiche implementazioni
e provare empiricamente.  Ma nella mia esperienza in merito non
ho riscontrato problemi sostanziali (Java e` maturato rapidamente
da questo punto di vista).
Alex

che ne dite di quelli che decidono di utilizzare Visual Basic invece di Java o
C++?
sono gradite opinioni e pareri su pro e contro...
Saluit

 C++?
Puo` essere la soluzione piu` rapida ("quick and dirty") a tanti problemi
di programmazione, ma non e` neppure da prendere in considerazione
se l'obbiettivo primario, come e` stato specificato in questo caso, e` la
*robustezza* del codice risultante.
Alex

 dite a riguardo?
Se la robustezza dell'applicazione è il criterio che verrà utilizzato per 
la scelta del linguaggio[1], molto dipende dalle caratteristiche 
dell'applicazione[2].
In ogni caso, secondo me, limitarsi solo a C++ o Java è... molto 
limitativo.
[1] Nella mia esperienza spesso limitazioni di altro tipo (disponibiltà 
del know-how all'interno della struttura in cui operi o 
desiderio/interesse a investire in un nuovo linguaggio, disponibilità dei 
tools o possibilità di investire in nuovi strumenti, ecc.) hanno molta 
influenza nella scelta del linguaggio stesso.
[2] Ad esempio, se devo sviluppare il sistema di controllo dei sistemi di 
un aereo, con grande probabilità non sceglierò Java.
-- 
Roberto Lupi
IT Consultant
Software Developer

> dite a riguardo?
Dirò una cosa scontata e ovvia, ma nessuno l'ha detta finora (almeno credo).
Prima ancora di essere un problema di linguaggio, la robustezza è innanzitutto
una questione di design. E non di un po', ma di gran lunga! Spesso si finisce
per ritenere di aver risolto la gran parte dei guai soltanto per aver scelto il
linguaggio "giusto". Non è così, almeno per applicazioni non banali.
Non che, poi, non sia necessario fare una scelta mirata del linguaggio di
programmazione, tutt'altro. Però ho l'impressione che _troppo spesso_ la
faccenda si sposti frettolosamente al livello di codifica, lasciando che la
struttura venga da sè, durante lo sviluppo. Questa, a mio modesto parere, è una
delle più colossali incomprensioni che possa viziare lo sviluppo del software.
AB
--
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Andrea Baruzzo
Via Circonvallazione, 26
Muzzana del Turgnano (UD) - Italy
e-mail: 
andrea....@ud.nettuno.it
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 delle più colossali incomprensioni che possa viziare lo sviluppo del software.
E' possibile passare quanto prima possibile al livello di codifica, è 
stata elaborata una metodologia, l'Extreme Programming (XP), che fa 
proprio questo (passare il più rapidamente possibile in "modalità 
manutenzione") - tuttavia ciò significa adottare pratiche che nella quasi 
totalità dei casi sono ignorate nei progetti passati prematuramente alla 
scrittura del codice.
-- 
Roberto Lupi

Roberto Lupi
