Newsgroup: it.comp.java
Titolo: Maledetto Java! [newbie che rimpiange il C - Lungo]

Salve a tutto il NG!
Vi seguo da qualche tempo, anche se capisco molto poco di ciò che si dice!
Sono iscritto ad ingegneria informatica e sono al secondo anno ma, 
proveniendo da un liceo scientifico, non ho avuto alcuna esperienza di 
programmazione prima dell'università.
Ci hanno insegnato il C al primo anno, e solo nel secondo semestre di 
ques'anno stiamo imparando la programmazione ad oggetti (quanta informatica, 
eh?! ma c'è taaaaaaanta matematica!! Maledetta 3+2! ).
Non son qua per niente, ora vi espongo subito il problema che un po' mi sta 
facendo rimpiangere il C.
Ci hanno dato da realizzare il gioco del monopoli per il laboratorio di 
java.
Chiariamo che non sono qua in cerca di magici codici risolutivi, ma 
semplicemente per ricevare dritte da persone più esperte e realizzarlo da 
me!
Le specifiche parlano di una "logica del gioco" indipendente 
dall'interfaccia utente (infatti dapprima ci è chiesta una realizzazione 
testuale, poi una interfaccia grafica e, ovviamente, la logica non deve 
essere toccata).
Le funzioni che l'interfaccia Deve avere sono quelle base, cioè "startgame" 
"endgame" "addplayer" e così via; tale interfaccia deve essere implementata 
da una classe UserInterfaceText che deve "prendere gli oggetti della logica" 
e restituire stringhe; dualmente, la classe interfaccia grafica che 
implementerà l'interfaccia dataci da specifica, prenderà sempre gli stessi 
oggetti e restituirà "altra roba" (non so esattamente cosa perchè non ci 
hanno spiegato ancora la grafica).
Io ho diligentementa fatto il diagramma delle classi UML con l'eclipse, 
creando caselle (acquistabili e non;tra le acquistabili ho messo i terreni, 
le stazioni e le società.. tutti gli attributi corretti, i prezzi, gli 
affitti, i metodi "compra", "vendi"! etc etc), creando dadi, crando il 
tabellone etc etc etc.
Nell'implementazione delle funzioni, viene il bello: la cosa che non 
digerisco, è che i metodidi una classe, vanno applicati agli oggetti di 
quella classe (ovvio).
Il problema, è che a compile-time, non esiste alcun oggetto e l'eclipse mi 
restituisce errori a manetta!
Mi spiego: creo una classe Tester, e inizio a scrivere ciò che farei per 
giocare: nel main ci metto "UserInterface U= new UserInterfaceText; 
u.startGame(parametri).
startgame non farà altro che creare un tabellone ed inizializzarlo quindi 
scrivo tabellone t= new tabellone(parametri);
ora mi servirà aggiungere un giocatore (ho implementato il tabellone come 
arraycaselle+arraygiocatori+arraycarte) e, quindi, faccio u.addPlayer(); 
l'implementazione di addplayer prevede di chiamare la "addplayer" definita 
come metodo di tabellone, quindi di fare t.addplayer.
L'ultima chiamata mi viene segnalata come errore dall'eclipse, ed è ovvio!
Il tabellone a compile-time non esiste!
Verrà creato a run-time dalla chiamata di inizializzazione fatta da 
startGame!
E allora che si fa?
Risposta: Boh!!!
Chi mi dà una mano?
Grazie a tutti solo per essere arrivati fino in fondo con la lettura, spero 
di essere stato abbastanza chiaro!

 java.
[CUT]
 > UserInterface U= new UserInterfaceText;
 > u.startGame(parametri)
java è case sensitive: U != u
bye!

 Risposta: Boh!!!
Cerco di esserti utile ma da esterno è un po' difficile.
In qualsiasi modo sia fatto, il tabellone sarà una struttura dati 
implementata in un particolare modo scelto.
Dovresti creare questa struttura dati in fase di inizializzazione e, 
più precisamente (se ho ben capito) nell'inizializzazione del gioco 
(della classe GiocoMonopoli)
L'interfaccia utente UserInterface dovrebbe essere una interfaccia del 
gioco che quindi ti permette di interagire con un oggetto / serie di 
oggetti che puoi identificare come "il gioco".
Se il tutto fosse, come nell'esempio di prima, la classe 
GiocoMonopoli()
allora dovresti creare il tabellone nel costrutture di GiocoMonopoli()
ciao
andrea

 java è case sensitive: U != u
sì, lo so, ho solo sbagliato a battere!
Cmq grazie per l'interessamento! 

 allora dovresti creare il tabellone nel costrutture di GiocoMonopoli()
mmm...forse ho capito cosa intendi..provo a ragionarci stanotte.. fortuna 
che ho ancora un bel po' di tempo!
Grazie per la disponibilità. 

 Grazie per la disponibilità.
Nel mio esempio, la classe GiocoMonopoli è la classe di tutto il gioco 
del monopoli che dovrebbe avere Tabellone() come membro privato e, per 
esempio, si potrebbe utilizzare tipo in questo modo:
GiocoMonopoli gioco = new GiocoMonpoli()
giocatore = new Giocatore("marco", "rossi");
gioco.aggiungiGiocatore ( giocatore );
ecc.
ma al 99,9999% non corrisponderà al tuo progetto :) mi serviva solo x 
farti un esempio.
ciao
andrea

 farti un esempio.
In realtà, quanto da te detti rispecchia abbastanza la verità, che ora cerco 
di spiegarla meglio.
Quello che tu chiami "giocomonopoli" per me è il tabellone! Infatti è sul 
tabellone che si articola la totalità delle fasi del gioco tant'è che 
nell'interfaccia è presente una funzione "getTabellone" che dovrà restituire 
lo stato attuale della partita.
Il mio problema, però, è un altro, proprio dovuto all'interfaccia!
una volta che l'interfaccia ha chiamato "startGame", il codice eseguito è 
quello che dici tu, cioè l'inizializzazione del tabellone (con la crezione 
dell'array di caselle,la creazione di un array di carte preventivamente 
mescolato, e la creazione dell'array di giocatori, vuoto: ad es, farà 
Tabellone tab=new Tabellone (parametri che ora non ci interessano)).
Quando l'interfaccia chiama addPlayer, bisognerà scrivere un codice che 
chimi una funzione del tabellone che modificherà l'array di giocatori, 
chiamando, ad esempio, un metodo AggiungiGiocatore del tabellone, facendo 
"t.AggiungiGiocatore".
Solamente che eclipse lo segnala come errore, perchè, difatti, il tabellone 
t a compile-time non esiste!
Non esiste nello heap una parte di memoria puntata da t che rappresenta il 
tabellone, essa verrà creata solo a run-time!
Una possibile soluzione è quella di mettere "statico" il tabellone, in modo 
che appunto, esista staticamente, solo che,p eronalmente, mi sembra 
solamente un astuto metodo per mettere una pezza ad una marte del java che 
ancora non mi è molto chiara..
Grazie ancora per l'interessamento. 

 tabellone t a compile-time non esiste!
non "t", in realtà volevo dire "tab" 

 tabellone t a compile-time non esiste!
Ok, allora implementa una versione iniziale di Tabellone, seguendo ad 
esempio le dritte date da Andrea (che, al di là delle specifiche che ti 
hanno dato i prof, mi sembrano suggerimenti assolutamente validi), magari 
fornendo implementazioni iniziali *stupide* per i metodi 
dell'interfaccia.... dove per stupide intendo cose del tipo
metodoX() {
    // TO DO: implementare il metodo
}
Scorpio.

 Scorpio.
Si infatti anche io ti consiglierei lo stesso. quello che si fa 
solitamente quando costruisci un progetto e vuoi iniziare a compilarlo 
/ vederlo all'opera per testare porzioni operative, solitamente si 
creano dei finti oggetti che permettono solo di superare i "vincoli" di 
compilazione / runtime ma di fatto non fanno nulla (come dire, tengono 
buono il compilatore e nel frattempo ti concentri su altro..)
ciao
andrea

 writes:
N> Salve a tutto il NG!  Vi seguo da qualche tempo, anche se capisco
N> molto poco di ciò che si dice!  Sono iscritto ad ingegneria
N> informatica e sono al secondo anno ma, proveniendo da un liceo
N> scientifico, non ho avuto alcuna esperienza di programmazione prima
N> dell'università.  Ci hanno insegnato il C al primo anno, e solo nel
N> secondo semestre di ques'anno stiamo imparando la programmazione ad
N> oggetti (quanta informatica, eh?! ma c'è taaaaaaanta matematica!!
N> Maledetta 3+2! ).
Non hai idea di quanta matematica  c'è dietro la teoria su cui si basa
l'informatica :) :), i migliori  hacker (in senso classico, non pirati
informatici)   di  cui  sono   a  conoscenza   sono  molto   forti  in
matematica...
Per il tuo problema del monopoli, cercati la documentazione del pattern
Model-View-Controller.
Tu devi infatto  fare un model (logica di  gioco) che sia indipendente
dalla view.  Dovresti riuscire  ad usare un  solo controller,  fai uso
delle interfaccie.
-- 
 /\           ___
/___/\_|_|\_|__|___Gian Uberto Lauri_____
  //--\| | \|  |   Integralista GNUslamico
\/                 e coltivatore diretto di Software
A Cesare avrei detto di scrivermi a 
fn...@rat.vg

 }
Certo, questo mi è ben chiaro, e lo fa anche l'eclipse in automatico quando 
si fa il diagramma UML delle classi.
Forse non sono riuscito a spiegare bene il problema, posto un po' di codice 
chiarificatore:
--------------------------------------------
package monopoli;
public class UserInterfaceImplemented implements UserInterfaceConnector {
public void startGame() {
Tabellone tab= new Tabellone();
}
public void addPlayer() {
tab.aggiungiGiocatore();
}
public void endGame() {
// TODO Auto-generated method stub
}
public void getGiocatore() {
// TODO Auto-generated method stub
}
public void getTabellone() {
// TODO Auto-generated method stub
}
public void getTurno() {
// TODO Auto-generated method stub
}
}
----------------------------
Il problema è che l'eclipse mi dà errore di compilazione nella addPlayer 
dell'interfaccia: infatti, staticamente, non esiste il tabellone "tab"! sarà 
creato a runtime dalla chiamata "startgame()"!
Ora non capisco come impostare il porgetto visto che non so come riferirmi 
al tabellone corrente sul quale voglio lavorare!
grazie a tutti per le risposte

 creato a runtime dalla chiamata "startgame()"!
No, non c'entra niente.
Il problema e' che per Eclipse questo "tab" nel metodo addPlayer non vuol dire assolutamente niente... infatti la dichiari nella startGame. Ovvero, rivedere la parte sulle regole di visibilita' (scope rules).
Intanto, per risolvere:
public class UserInterfaceImplemented implements UserInterfaceConnector {
    private Tabellone tab;
    public void startGame() {
        tab= new Tabellone();
    }
ecc ecc.
Saluti
CarMas

 package monopoli;
anche se è un po' OT...
stai seguendo il corso di Ingegneria del Software al poli di milano?

 ha scritto nel messaggio 
news:f2a1uf$vv$1...@news.cineca.it...
No, non c'entra niente.
Il problema e' che per Eclipse questo "tab" nel metodo addPlayer non vuol 
dire assolutamente niente... infatti la dichiari nella startGame. Ovvero, 
rivedere la parte sulle regole di visibilita' (scope rules).
Intanto, per risolvere:
public class UserInterfaceImplemented implements UserInterfaceConnector {
    private Tabellone tab;
    public void startGame() {
        tab= new Tabellone();
    }
ecc ecc.
---------------------------------
Grazie per la risposta.
In effetti, non aveva senso ciň che ho scritto io.. ma allora non mi č 
chiaro in che senso l'interfaccia č solo un tramite tra utente e logica..

 stai seguendo il corso di Ingegneria del Software al poli di milano?
Sě ^_^
Siamo colleghi? 

 delle interfaccie.
In effetti + quello lo scopo, ma ci hanno chiesto esplicitamente solo il 
diagramma delle classi in uml + il sorgente :-( 

 diagramma delle classi in uml + il sorgente :-(
Ma non sarebbe una cosa in + :). E' solo un approccio che segui..

 Ma non sarebbe una cosa in + :). E' solo un approccio che segui..
E' potente la mia ignoranza, eh :-D
Cmq vedrò di cosa si tratta, se non è troppo difficile imparare, lo 
seguirò..grazie.. 

> riuscire ad usare un solo controller, fai uso delle interfaccie.
N> In effetti + quello lo scopo, ma ci hanno chiesto esplicitamente
N> solo il diagramma delle classi in uml + il sorgente :-(
Appunto.
Nel tuo diagramma ci saranno  interfaccie, il cui compito è rendere di
uno stesso  tipo classi  di tipo diverso  (view testuale e  grafica ad
esempio), attraverso la garanzia  che rispetteranno un certo contratto
- nota,  se   ci  metti  un  pizzico  di   pattern  delegation  arrivi
all'ereditarietà multipla per Java-.


> Ma non sarebbe una cosa in + :). E' solo un approccio che segui..
N> E' potente la mia ignoranza, eh :-D Cmq vedrò di cosa si tratta, se
N> non è troppo difficile imparare, lo seguirò..grazie..
Posso essere cattivo ? Se è troppo difficile da imparare forse non sei
sulla tua strada...


 sulla tua strada...
Infatti non è che mi piaccia molto la programmazione pura, eh.. 

 all'ereditarietà multipla per Java-.
Mi dispiace ma sei troppo avanti per adesso.
Con due mesi di programmazione OO non riesco proprio a capire.


si, con due anni di differenza, stessi problemi incontrati nella stessa 
fase, ci capirai di piů quando avrai 6 mesi di java alle spalle. Quando 
ne avrai 12 ed andrai a rivedere il codice dirai "ma che me**a di codice 
che ho scritto".
Il problema nasce dal fatto che ti fanno imparare java insieme a 
infsoftI mentre personalmente avrei preferito se avessero fatto come per 
info 1 e info 2 con il C: impari l'architettura client/server quando sai 
il C non imparare il C mentre ti spiegano come leggere da un socket..
ciao.

 imparare il C mentre ti spiegano come leggere da un socket..
Quotissimo.
Hai centrato il punto. 

 Hai centrato il punto.
Io ho fatto ingegneria del software al Polimi con il vecchio ordinamento, 
nel "lontano" '97 o '98, non mi ricordo; esame tosto, non c'è che dire, si 
lavorava in C++ e Java più un bel po' di teoria... però il professore era 
davvero in gamba. I concetti di ingegneria del software e la loro 
applicazione erano il fulcro del corso, non la grammatica di questo o quel 
linguaggio. E secondo me una simile impostazione è estremamente saggia.
Perchè scrivi "imparare l'architettura client / server quando sai il C" ? 
Imparala a prescidere dal linguaggio, ragionando per algoritmi, problemi, 
soluzioni, pattern....Certo, non voglio sminuire il peso dell'esame, ma se 
volete essere ingegneri del software dovete esserlo al di là della 
tecnologia che usate. Sennò che fate, un domani il treno-Java deraglia e voi 
ne seguite il destino ?
Coraggio e in bocca al lupo !!
Scorpio.

 Coraggio e in bocca al lupo !!
Crepi, grazie! 

 
quello che hai detto č esatto, tuttavia preciso meglio quello che volevo 
dire:
1) per passare l'esame č obbligatorio fare il laboratorio
2) per passare il laboratorio occorre conoscere java
3) esiste solo un appello per il laboratorio e non č possibile 
recuperarlo in altre sedute
4) java non lo si impara in 2 mesi con altri 5 esami da dare (EDO ...)
quindi il nostro amico si trova nella condizione di dover montare un 
accrocchio che funzioni, in un tempo abbastanza ristretto, altrimenti 
"no lab, no exam, next year!" (o almeno quando l'ho fatto io erano cosě 
le regole)
ne consegue che il lab ha la prioritŕ su tutto (a.k.a. puoi dare l'esame 
anche a settembre ed imparare realmente cosa intendono per covarianza e 
cotrovarianza, ma il lab lo vogliono subito...)
personalmente avrei preferito se si fossero concentrati piů sulla 
sostanza, magari utilizando ancora il C invece di buttare tutta questa 
carne al fuoco e sacrificare la parte di testing e di pattern 
(quest'ultima quasi inesistente).
Inoltre non hanno nč la voglia nč il tempo di controllare il codice per 
vedere se hai applicato i concetti in modo appropriato (iteratori ecc.) 
quindi la valutazione del lab č piů un'abilitazione a poter dare l'esame.
Questo non mi sembra in modo migliore per insegnare ingegneria del 
software I perché premia piů chi conosce giŕ java ed č smanettone 
rispetto a chi prima di scrivere del codice vuole capire come č meglio 
scriverlo.
senza offesa per gli smanettoni :-)
sv.

 teoricamente approfondite.
neppure più approfondite di tanto, un po' di analisi di requisiti, ma 
non molto di più, l'80% è uguale a quello che si fa in ingsoftI e non ti 
nascondo la delusione provata...
personalmente ritengo che se togliessero la parte di java da ingsoftI, 
magari mettendo al primo sementre info3 con java ed unissero i corsi di 
ingsoftI e II in un unico corso sarebbe molto meglio.
sv.

> contratto
N> Mi dispiace ma sei troppo avanti per adesso.  Con due mesi di
N> programmazione OO non riesco proprio a capire.
Una interfaccia è una interface di Java.
Se  tu fai  in modo  che i  vari moduli  interagiscano non  con classi
concrete ma  con loro interfaccie,  allora tu potrai cambiare  al volo
una  classe  con  un'altra,   fatto  salvo  che  ambedue  implementino
l'interfaccia.
Se  il controller  deve parlare  al model  farà uso  di metodi  di una
interfaccia.
Idem se  il controller deve avvertire  la view. E la  view accederà ai
dati del model attraverso una  interfaccia (non servirebbe, ma già che
ci siamo... Ad una domanda del prof giocati qualcosa di plausibile sul
poter mettere intelligenze di gioco differenti :) ).


 senza offesa per gli smanettoni :-)
Naturalmente ! Ma mi viene spontaneo chiedere: a che serve ?? Parliamoci 
chiaro: una persona che sa programmare ed ha una solida conoscenza degli 
algoritmi, dei pattern etc è più  valida di una persona, IMHO, che saprebbe 
scrivere il bytecode del progetto d'esame a mano ma, richiestogli un parere 
sulla complessità di un algoritmo, non saprebbe neppure a spanne dire di che 
si sta parlando...
Scorpio.

 4) java non lo si impara in 2 mesi con altri 5 esami da dare (EDO ...)
Sai qual è il bello?
da quest'anno hanno avuto la felice idea di accorpare l'esame di economia di 
questo semestre con quello di organizzazione del prossimo semestre, con il 
risultato di un bel corso di economia ed organizzazione da 10 crediti 
(ingegenria del software è da 7.5, a titolo informativo) e da 8 ore 
settimanali di cui 6 il martedì!
Per passare la prima prova in itinere è richiesto il sapere redigere un 
bilancio oltre ad altri 3 argomenti minori.
E noi dobbiamo imparare a fare sto cazzo di bilancio (fatto a cristiano, 
all-inclusive), noi che non abbiamo mai sentito parlare d'economia, noi che 
odiamo i gestionali, noi che prima di qeusto corso non sapevamo nemmeno cosa 
fosse un socio accomandatario di una società!
Non sai quanto tempo porta via...
...e contemporaneamente impari il java....
:-((

 l'interfaccia.
non ci avevo pensato in effetti... uno dei due tutor di laboratorio ci ha 
portato fuori starda allora, con una soluzione che ora pian piano sto 
sviluppando..
Quando finisco posto il giochino, a patto che non mi insultate per le 
"banalità programmative" che, inevitabilmentem ci saranno ;-)
Grazie a tutti per la collaborazione. 

 "banalità programmative" che, inevitabilmentem ci saranno ;-)
Sarebbe assurdo insultarti: nessuno impara qualcosa senza commettere errori.
E' quello che si chiama esperienza.
Scorpio. 

 
from Soft Computing
solo commettendo errori si impara...
sv.


1) l'odio per i gestionali è salutare, vuol dire che sei normale.
2) nel mondo del lavoro purtroppo sono loro che decidono il tuo stipendio*
3) forse è l'unica cosa che hanno fatto di buono, meglio un solo esame 
da 10cr che 2 da 5, perdi meno tempo e te lo levi subito dalle scatole 
(prova a pensare di trovartelo quando farai la tesi...)
* ecco la motivazione:
Engineers and scientists can never earn as much as business executives 
and sales people.
----------------------------------------------------------------------------------------
This theorem can now be supported by a mathematical equation based on 
the following two postulates: (which we all accept as true)
Postulate 1: Knowledge is Power.
Postulate 2: Time is Money.
As every engineer and scientist knows:
Power = Work/Time
Since: Knowledge = Power and Time = Money
Then: Knowledge = Work/Money
Solving for Money, we get: Money = Work/Knowledge.
Thus, as Knowledge approaches zero, Money approaches infinity, 
regardless of the amount of work done.
Conclusion: The less you know, the more you make.
sv.

> programma č corretto...
N> define #programma corretto# Per me, se risponde a ciň che č
N> chiesto, e funziona in modo soddisfacente, č corretto.
Molti  parlavano cosě. Salvo  vedere che,  nel caso  migliore, c'erano
input per  cui il  programma si arrestava.  In quelli  peggiori veniva
sottratto al controllo del programma il flusso di esecuzione (i famosi
buffer overflow exploit).
Un programma  č corretto se non  si arresta *MAI* in  modo anomalo con
qualsiasi input  riceva (segnala casomai che l'input  non č corretto),
ma una  cosa simile non  č possibile da  ottenere in generale  per via
teorica, non rimane altro che redigere un piano di test che valuti una
serie di input in grado di  far percorrere al programma tutte le parti
del codice e  verificare che funzionino per un  insieme ragionevole di
input.
La conosci la storia di Arianne 5, vero ?


 solo commettendo errori si impara...
E si puoņ applicare tranquillamente ad altri campi, secondo me.. 

 La conosci la storia di Arianne 5, vero ?
Uhm...qualche vago ricordo di una sonda spaziale che fece il botto in 
partenza una decina di anni fa scarsi..
Maggiori info?
Non mi dire che lanciava eccezioni a go-go ^_____^
Sarebbe assurdo..
Grazie. 

 
il testing serve per scovare gli errori, la loro assenza non garantisce 
la correttezza del programma.
Non è possibile fare testing in maniera esaustiva (= per tutti i 
possibili ingressi) in quanto sarebbe troppo dispendioso 
computazionalmente ed in molti casi la maggior parte degli ingressi è 
raggruppabile in classi di equivalenza, quindi non serve provarli tutti 
sempre.
la ricorsione è una caratteristica tipica nell'informatica, per es. i 
compilatori sono i programmi con cui facciamo programmi...
sv.

 a pensare di trovartelo quando farai la tesi...)
Indubbiamente, ma imho non è il semestre più appropriato!
C'è anche il primo esame della certificazione Cisco da fare e, sebbene non 
obbligatorio, è consigliatissimo! 

 compilatori sono i programmi con cui facciamo programmi...
Il concetto, però, è prettamente matematico! 

 
java non è complicato, è solo immenso in quanto la gran parte delle 
azioni di medio-basso livello sono già state implementate e devi usarle 
come dei mattoncini lego. Ti consiglio di dare un occhio alla 
documentazione in linea per swing e I/O console:
http://java.sun.com/javase/6/docs/api/
e qui forse troverai qualche consiglio utile:
http://www.java-tips.org/java-se-tips/
sv.

 
http://www.java-tips.org/java-se-tips/
Grazie per i link penso torneranno utili ;-)

> La conosci la storia di Arianne 5, vero ?
N> Uhm...qualche vago ricordo di una sonda spaziale che fece il botto
N> in partenza una decina di anni fa scarsi..  Maggiori info?
Arianne è il vettore Europeo.
Quando fecero il 5, il team che si occupava del sw di navigazione disse:
"Il nostro software è corretto e testato, non occorre spenderci su soldi"
E quindi Arianne 5 prese il sw di navigazione di Arianne 4.
Peccato che  la dinamica dei due  vettori sia ben diversa  e quando il
software, terminata l'inizializzazione, disse:
"Bene siamo a quota 0 a velocità 0" 
I sensori risposero
"Nope, siamo a quota X e la velocità è di svariate centinaia (migliaia
?) di Km/ora"
Al che  la povera  routine di controllo  uscì dall'area  di stabilità,
causò un eccezione aritmetica (non  trappata) ed i programma vomitò il
core.  Peccato  che, mancando  dischi rigidi, il  dump venne  fatto in
memoria  sovrascrivendo   alcuni  registri  il  cui   compito  era  di
controllare  la posizione degli  ugelli, un  qualcosa del  tipo "barra
tutta  a sinistra".  Gli  effetti di  una  cosa simile  sull'integrità
strutturale del missile sono  facilmente intuibili, e quindi entrarono
in azione  prima l'autodistruzione automatica  e poi il  bottoncino di
autodistruzione...


 Personalmente, eh!
Ciao secondo me la vera soddisfazione di un programmatore non è quella
di passare le notti senza dormire con gli gli occhi incollati al
monitor perchè non trovo un errore stupidissimo... quella è paranoia!
Certo anche Java nella sua completezza non segna tutto (non a caso mi
sono visto bocciare in un esame di informatica solo perchè la JVm non
s'è accorta di un overflow con un int...); credo che java vada molto
bene per quato riguardi i programmi che non possano mettere a rischio
la sicurezza e la vita di persone ma credo che C ed il fratellino C++
andrebbero leggrmente rivisti.
Si le sue performance mostruose sono date dal fatto che il
programmatore che ha scritto il codice viene considerato come una
divinità dal compilatore, colui che decide quale dato o oggetto può
continuare ad esistere e quale deve sparire nell'oblio della
cancellazione,
Le macchine che abbiamo adesso non sono quelle degli anni '60, allora
si poteva dire abbiamo solo pochi MHz di clock e pochi KB di RAM per
eseguire le applicazioni. E adesso invece chi dispone di un Desktop,
per quanto arretrato possa essere, ha a disposizione almeno 1,5 o 2
GHz di clock e 128 o 256MB di RAM e credo che sia molto + conveniente
seguire la filosofia WORE (Write Once, Run Everywhere) seguendo la
strada della portabilità oltre alla via delle sole performance...
Se ci si preoccupa solo delle performance perchè non si continua più a
scrivere in assembly???
Scusate se sono uscito dal seminato
Ciao a tutti
Marco

ciao november17 guarda posso esserti più di aiuto se magari posti il
diagramma delle classi in Uml così magari riesco a capirti meglio.
ciao

ciao november17 posso esserti più d'aiuto se magari posti il diagramma
delle classi in uml così capirei molto meglio. ciao!

 "Il nostro software è corretto e testato, non occorre spenderci su soldi"
Brrrr....terribile... ma non è uscita mai fuori, questa cosa, in versioni 
"ufficiali", vero?
Non si puo' ammettere una cosa dle genere!
E il genio che ha detto la frase che ho quotato, che fine ha fatto?
Spero che per guadagnarsi da vivere sia costretto a scavare le patate a mano 
per tutta la sua vita

 
si sono perse delle sonde anche per molto meno tipo:
EU "misure in metri"
USA "misure in yard"
PROCESSORE "sono solo numeri => esegui l'operazione"
risultato sonda dispersa nello spazio.
sv.

 PROCESSORE "sono solo numeri => esegui l'operazione"
Sarebbe? 

 delle classi in uml così capirei molto meglio. ciao!
Grazie per il supporto, ma ormai ho quasi finito, mi manca solo qualche 
metodino secondario e la gestione di qualche bug da tappare qua e là.
Una domandina: l'acquisizione da tastiera la faccio con la scanner e il 
metodo nextInt, che, però, ovviamente, solleva una eccezione se si inserisce 
una lettera o stringa.
Qualcuno ha qualche idea su come risolvere la cosa senza rivoluzionare 
troppo il codice?
Grazie 

 ha scritto nel messaggio 
news:1179754641....@z28g2000prd.googlegroups.com...
Se ci si preoccupa solo delle performance perchè non si continua più a
scrivere in assembly???
-------------
Infatti, imho, è stato molto interessante studiare l'assembly in info2!
Cmq, per far capire il concetto che era intenzione mia esprimere:
Il programmatore C è come un meccanico di 20 anni fa, al quale portavi la 
macchina esponendogli il problema, e lui provava ad accelerare, provava il 
minimo, lo regolava, verificava che la battria funzionasse... dopo mezza 
giornata ti aveva risolto il problema (ma anche no ^_^).
Il programmatore Java è un meccanico di adesso, attacca il portatile alla 
presa OBD e legge gli errori della centralina.. 

> Arianne è il vettore Europeo.
N> Ma gli Americani non ci ridono mai dietro?  Qualche annetto fa
N> abbiamo perso il beagle2 nello spazio..
Gli americani stanno zitti per aver scritto questo statement FORTRAN (+ o -)
DO 10 X = 1.10
invece di 
DO 10 X = 1,10
(lo statement può essere diverso quanto  a numeri e alla lettera X, ma
la storia non cambia).


 presa OBD e legge gli errori della centralina..
forse perchè come hai appena scritto tu, i tempi sono cambiati.
se paragoni un programma ad una macchina sai ora puoi partire da una
base che garantisce
una certa affidabilità e che l'unico punto che può "fallire" è la
centralina perchè difettosa o
semplicemente contiene un dato sbagliato e quindi sono errati i tempi
o la quantità di iniezione,
oppure l'apertura di una valvola, ecc.....
Certo poi può esserci sempre il caso anomalo in cui sia la base a dare
problemi, ma rispetto
a prima questa probabilità è crollata in modo pauroso.
Che con il linguaggio C siano state fatte cose spettacolari non lo
metto in dubbio, ma resto del
parere che è molto meglio qualità. Anche perchè come già detto da
altri in questa discussione
"il linguaggio è relativo, quello che conta è l'algoritmo".
Se mi sono espresso male nel post precedente chiedo scusa, cmq per
restare in tema di auto
java e C possono essere visti come 2 auto, il C come una Ford GT degli
anni 60 e Java
la Ford Gt 2005. Sai qual'è l'unica differenza?
Con la prima o a guidare sei un figo oppure ti schianti già nel
tirarla fuori dal garage, con la
seconda puoi non essere così figo, questo perchè riesci a fare le
stesse cose della prima ma
hai delle tecnologie che ti supportano in ogni momento
Ciao Marco

 Sarebbe?
Vale a dire che per il processore km e miglia sono solo numerini che
possono cambiare.
per farti un esempio stupido
se prendi una macchina americana (quindi con strumentazione in miglia)
e circoli in un
qualsiasi posto dove i cartelli stradali hanno come come unità di
misura per le velocità
km (ad esempio Italia). Se vedi un cartello che indica il limite di
velocità e leggi 50 non
perdere tempo a presentare ricorso se ti danno la multa per eccesso di
velocità anche
se l'ago della tua strumentazione segnava 50..
questo perchè 50mp/h è circa 80km/h...
il processore questa leffera non la capisce perchè procesa solamente
il valore,
fregandosene della misura di riferimento... un po come se tenti di
sommare 10 mele con
8 limoni, non ottieni 18 meloni o 18 lime...
O mi sbaglio?
Ciao Marco

 ha scritto nel messaggio 
news:1179838633.9...@a26g2000pre.googlegroups.com...
O mi sbaglio?
-------------------------
Ah, ok, lo sapevo già, perchè, ripeto, ce lo accennò un esercitatore di 
fisica.
Non mi era chiaro che la terza affermazione era una conseguenza delle altre 
due ^_^

 Sarebbe?
Vale a dire che per il processore km e miglia sono solo numerini che


 Opportunity che, però, sono giunti regolarmente su Marte?
beagle (2) era il lander "british" della missione ESA "mars express"
se vuoi vedere una persona dell'esa al poli, con una presentazione da 10 
e lode, cerca sul corso di IMAD (bittanti) quando arriva Enrico Vassallo 
dell'ESOC, assolutamente da non perdere.
sv.

 input.
Effettivamente esistono anche altre strade. Dimostrare la correttezza
delle parti critiche (il problema della terminazione dice che non esiste
un algoritmo *generale*, non che non possa *manualmente* dimostrare la
correttezza di *un* programma). Oppure dimostrare la correttezza
'ristretta' a determinate parti della semantica.
L'esempio piů banale č la tipizzazione. Un compilatore č in grado di
*dimostrare* la correttezza di tipizzazione (a seconda del linguaggio).
Qui penso specialmente ad un linguaggio della famiglia di ML, per dire.
Anche staticamente si possono dire diverse cose in campo statico.
Bisogna ovviamente limitarsi ad essere conservativi [ che vuole dire che
esisteranno programmai corretti che non prendono il bollino verde ]. 
-- 
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.

 compilatori sono i programmi con cui facciamo programmi...
I compilatori sono programmi che traducono un programma da un linguaggio
L ad un linguaggio L'.


 presa OBD e legge gli errori della centralina.. 
Dai, a me Java non č simpatico, ma non insultare cosě i programmatori
Java.


> un insieme ragionevole di input.
E'OF> Effettivamente esistono anche altre strade.
8 righe  piů sopra c'č  scritto "...  non  č possibile da  ottenere in
generale per via teorica ...".                                      ^^
^^^^^^^^
Mi sono espresso  male a quanto pare. Quella frase  vuole dire che non
puoi trovare  la dimostrazione di correttezza per  TUTTI gli algoritmi
(ma per alcuni  si, come ben sai il contrario di  "per ogni" č "esiste
uno" non "nessuno").


 writes:
E'OF> Effettivamente esistono anche altre strade. Dimostrare la
E'OF> correttezza delle parti critiche (il problema della terminazione
E'OF> dice che non esiste un algoritmo *generale*, non che non possa
E'OF> *manualmente* dimostrare la correttezza di *un*
E'OF> programma)
Una  tiratina  di  orecchie.   La  dimostrazione  manuale  prevede  un
procedimento. E quindi una dimostrazione.
Guarda, non la ho vista personalmente, ma sono disposto a scommetterci
che la tipizzazione è stata dimostrata per via teorica prima di essere
implementata.
BTW, il fatto  che il LISP funzioni -o meglio,  sia equivalente ad una
macchina di Turing- è stato  dimostrato teoricamente. O meglio, LISP è
l'implementazione di un qualcosa che  è stato dimostrato. Ma siamo nei
"casi  fortunati". Già  con  la divisione  iniziano  problemi, se  non
ricordo male :).


> portatile alla presa OBD e legge gli errori della centralina..
E'OF> Dai, a me Java non è simpatico, ma non insultare così i
E'OF> programmatori Java.
Java  come ogni  linguaggio ha  cose buone  e meno  buone. A  me piace
abbastanza, lo preferisco a  molti altri (i.e. l'indentazione è sacra,
ma darle una  funzione sintattica... BRRRRR, mi tornano  in mente cose
del tipo "Se in colonna 5 c'è..." :) ).
Sui programmatori poi, anche qui ci sono casi e casi. Vedo gente usare
Java come il Cobol, e gente usare Java in modo molto intelligente.


 ricordo male :).
Dipende anche cosa intendi con divisione...


 uno" non "nessuno").
Su questo sono d'accordo (anche se preferisco specificare sempre, mi
rendo conto che la gente ha un sacco di problemi sia con la negazione
dei quantificatori, sia con la negazione delle implicazioni[0]).
La mia obiezione era al fatto che l'unica soluzione fosse pianificare i
test. Che poi non sono certo io a sminuirne l'importanza (per le cose
piů profane lavoro principalmente in TDD, per cui :P). 
Ma diciamo che visto che mi interesso parecchio di verifiche formali
volevo fare notare che spesso ci sono anche altre strade per
complementare i test.
"Beware of bugs in the above code; I have only proven it correct, not
tried it."
----
[0] ricordo i test di ingresso di un corso di laurea in informatica dove
venne chiesto di negare la proposizione
'se c'č il sole non prendo l'ombrello'
e nessuno dei 70 partecipanti imbroccň la soluzione (peraltro mi pare
fosse pure a crocette).


 writes:
E'OF> Ma diciamo che visto che mi interesso parecchio di verifiche
E'OF> formali volevo fare notare che spesso ci sono anche altre strade
E'OF> per complementare i test.
Uuuuuu, che argomento interessante!
E'OF> "Beware of bugs in the above code; I have only proven it
E'OF> correct, not tried it."
Grande!


> Già con la divisione iniziano problemi, se non ricordo male :).
E'OF> Dipende anche cosa intendi con divisione...
Divisione  intera.   Ma  essendo  cosa   di  un  paio  di  decenni  fa
probabilmente il  prof faceva un esempio  sull'halting problem, almeno
questa è  stata l'impressione  appena ho provato  a tradurre  in defun
quello che (ricordo) essere l'algoritmo indicato.


 Grande!
Adoro quella citazione.


 quello che (ricordo) essere l'algoritmo indicato.
Confesso che non mi viene in mente quello che vuoi dire. La divisione
intera dovrebbe essere una funzione totale (definendo anche la divisione
per 0).
