Questa discussione ha avuto 78 risposte

[pio ping 34]

Si Parte con ilscritto in java

per sviluppare il codice faro' fede e riferimento a queste righe che "per quanto incomplete e scritte in una ventina di minuti" aspirerebbero ad essere una specifica per la realizzazione del programma questa e' la bozza di partenza

Spoiler

Le seguenti non sono le specifiche iniziali, ma quelle "riviste", dopo il diario di sviluppo1:
LATO UTENTE: Il Programa di Test e' composto da 1 programma di controllo chiamato CtrlP che gira su un unico computer, e da svariati programmi di test TestP, che sono connessi alla rete da testare (che potrebbe essere lo stesso computer dove gira pure CtrlP). [Vi forniro anche una guida su come usare il programma, ora non mi dilungo]

COSA FA IL PROGRAMMA: Dopo che tutti i TestP sono stati lanciati, CtrlP decide (o meglio attraverso CtrlP l'utente decide) chi invia i dati di test (pacchetti UDP ) e chi li riceve, i vari TestP che ricevono i pacchetti registrano i pacchetti arrivati, la data di arrivo, e calcolano alcune statistiche (per ora solo la velocita'). Quando tutti i pacchetti (che sono in un numero predeterminato) sono arrivati a destinazione e il test e' concluso, i vari TestP di ricezione, inviano a CtrlP le varie statistiche registrate, che le mostrera a schermo (e forse in futuro potra salvare su file in un forato facilmente leggibile [html, xml]).

COME LO FA IL PROGRAMMA: [EDIT] Ho cambiato alcune scelte implementative in corso d'opera, questo e' al momento in cui scrivo il modo attuale di agire del programma. CtrlP appena lanciato avvia un annunciatore che a intervalli regolari invia ad un determinato indirizzo IP (multicast) e ad una determinata porta, il proprio indirizzo IP e la Porta, a cui i vari TestP dovranno collegarsi se vogliono partecipare al test. Quando il servizio e' attivo, e' possibile lanciare i vari testp sui computer da testare. Automaticamente CtrlP rileva la conessione e iscrive il computer al test, chiedendo all'utente se il computer collegato sara' un computer che invia i dati oppure uno che li riceve(tipologia di tester), al momento ancora(l'ho fatto per una questione di pigrizia mia, se ho tempo rimedio) non e' possibile cambiare in modo dinamico lo stato di un TestP, una volta assegnata la tipologia. Finita la fase di iscrizione, il programma chiede di configurare le coppie invio/ricezione. Una volta assegnate le coppie, vengono eliminati dal sistema i computer spaiati(che termineranno tranquillamente da soli), poi il sistema avverte i computer che invia a chi inviare i dati, e infine chiede all'utente quando e' pronto di premere invio per avviare il test. Premuto invio, crtlP manda a tutti gli inviatori (sempre in multicast) contemporaneamente un messaggio di start. E i ricevitori incominceranno a ricevere dati calcolando la differenza tra il tempo un momento prima di ricevere il pacchetto e il momento successivo la ricezione. Conoscendo la dimensione dei pacchetti inviati e dividendo per il tempo medio di invio, viene ricavata
la velocita' di download(ricezione) dei pacchetti ricevuti, e il numero di pacchetti persi(l'invio di dati avviene tramite UDP, che non garantisce la consegna- magari espando il test con il test del TCP) per ogni coppia precedentemente creata. Il test sollecita abbastanza la rete, sicche "credo" sia naturale avere un alto numero di pacchetti persi specialmente se inviati tramite wireless.[eventuali modifiche al comportamento del programma le riportero' qui]

NOTA un interfaccia grafica sarebbe l'ideale, ma perderei tempo su dove/come posizionare bottoni e scritte pero' cerchero' di implementare il tutto in modo che possa essere facilmente estensibile

AVVERTENZE PER L'USO: Dato che credo nei programmi Open e nello scambio di idee , se avete osservazioni, migliorie, domande (postate pure.. e' un progetto di tutti per tutti e per qualche giorno sono libero da impegni)So anche che il programma fa una cosa abbastanza comune e che sotto linux sarebbe implementabile con uno script bash in 10 righe.Pero' volevo innanzitutto fare un programmino portabile su tutti i sistemi operativi.. in modo da poter eseguire il test tra un computer che magari fa girare windows e un macbook(e non solo da quelle 2-3 persone -me compreso- che utilizzano linux)E poi, mi piaceva riprendere un po' in mano java che e' da qualche mese che non lo tocco piu'..

LINK AL PROGRAMMA
http://dl.dropbox.co... case/ctrlp.jar <-- ctrlp
http://dl.dropbox.co...se/testp.jar<-- testp


DIARIO DI SVILUPPO
parte 1

Spoiler

mi sono reso conto che l'abbozzo di specifica che mi sono dato fa veramente schifo T_T: Non dice nulla di veramente utile e mi ha lasciato tante soluzioni possibili,cosi ho passato i primi giorni a prendere in considerazione varie/troppe soluzioni possibili.Alla fine (ma mi riservo di cambiare tutto di nuovo ), sono arrivato alla conclusione che chi usera' il programma per il test della velocita' di connessione(io? ), non voglia smanettare troppo con indirizzi IP, configurazioni passate per riga di comando e altre atrocita' del genere, ma si voglia limitare a lanciare il numero minimo di programmi indispensabili per far girare i test. In definitiva ci saranno tanti programmi sparsi per i vari computer che compongono la reteche "si presentano" ad un particolare programma(il centro di controllo) che girera' solo su un computer.Lo scopo di questo programma e' di creare delle coppie per la ricezione/invio dei dati di test, che faccia partire il test e che organizzie e permetta di visualizzare i dati del test su un unico computer.Per rendere piu' semplice l'installazione e la formazione di coppie di invio/ricezione , i programmi che inviano i dati ad un computer, possono allo stesso tempo anche riceverli da un (e uno solo) altro computer della rete.

parte 2

Spoiler

ho deciso che i programmi per eseguire i test sulla rete, si scambieranno pacchetti UDP, almeno si levano complicazioni inutili, che infastidiscono e basta. Inoltre per rendere il codice di piu' facile l'interpretazione del codice, ognivolta che i programmi devono scambiarsi dati attraverso la rete, i dati che si passano sono stringhe di testo:in realta' questo e' uno spreco di risorse, pero' aiuta a capire cosa sto facendo.quando due programmi si scambiano dati, si cerca di mettere i dati che si scambiano nella forma piu' compatta possibile, per non sovraccaricare troppo la rete e non occupare troppe risorse.piccolo esempio(semplice semplice):un programma A vuole comunicare ad un altro programma B che la temperatura ambiente e' 37 gradi, di solito succede che A invia solo il numero 37(con una particolare codifica), e B sa che 37 sono i gradi della stanza.Se invece A adottasse il metodo che ho usato io, invierebbe a B la frase:"A invia a B la teperatura 37 gradi prensente nella stanza."Comunque ormai manca praticamente solo il programma di controllo e gestione e poi vedo se quello che ho scritto ha un senso oppure no

parte 3

Spoiler

Dovevo iniziare il programma di controllo ma sono(ancora una volta) tornato indietro a pensare se il metodo di calcolare la velocita' di ricezione dei dati sia in qualche modo proporzionale alla velocita' di trasmissione della rete: in pratica dato che uso pacchetti UDP per l'invio e che uso una funzione che si blocca mentre aspetta che le venga recapitato un pacchetto(che hanno tutti la dimensione massima consigliata di 8192byte):

CALCOLA TEMPO CORRENTE1
RICEVI IL PACCHETTO
CALCOLA TEMPO CORRENTE2
SALVA TEMPOCORRENTE2-TEMPOCORRENTE1
FINITO IL LOOP CALCOLA
DIMENSIONE PACCHETTO X NUMERO PACCHETTI/TEMPO MEDIO RICEZIONE PACCHETTI

Ho risolto cosi il dubbio:Il programma testa in quanto tempo un computer mediamente puo' ricevere un certo numero di byte inviati attraverso una rete.
Ogni osservazione e commento su questo (e su altro) e' ben accetto

parte 4

Spoiler

fase di collaudo fallita miseramente, non mi piace l'interazione con l'utente, e altre scelte che ho fatto si sono rivelate troppo fastidiose/limitanti da portarsi dietro. Ho deciso di ridisegnare il tutto, cercando di trarre insegnamento dagli errori commessi ... ma ormai siamo in dirittura di arrivo e si incomincia a vedere qualcosa..

parte 5

Spoiler

FINITO dopo un paio di versioni di verifica delle funzionalita' ecco il primo abbozzo di programma funzionante, prossimamente posto anche le istruzioni su come provarlo, ma tanto e' facile: se vi sentite in grado \ avete voglia provatelo e ditemi difetti e suggerimenti

MINIGUIDA JAVA

Come Installare java(OpenJdk-7) da console su ubuntu

Spoiler

librerie e programmi per far girare java:
a ogni tag [ code ] corrisponde un comando seguito da invio

sudo apt-get install openjdk-7-jre

librerie e programmi per creare i programmi in java

sudo apt-get install openjdk-7-jdk

verifica:

java -version

javac -version

problemi noti:
versione di java diversa da quella scaricata

sudo update-alternativies --config java

e selezionare il numero che corrisponde alla versione desiderata

versione di javac diversa da quella scaricata

sudo update-alternativies --config javac

la verifica fallisce, chiedendo di installare pacchetti gia' installati:
occorre linkare il programma dalla directory di installazione all'interno della cartella /usr/bin, prima si cerca dove il programma e' stato installato(nome programma e' puo' essere java o javac ):

sudo find / -name nome_programma 2>/dev/null

si annota il percorso_completo (se e' presente piu' di un percorso chiedete qui quale usare ), e infine si scrive

ln -s percorso_completo /usr/bin/nome_programma

e alla fine si effettua di nuovo la verifica per vedere se tutto funziona

Breve (e traumatica ) INTRO - tutto(ma proprio tutto) quello che serve per scrivere 3 righe di codice

Spoiler

Dopo aver installato NetBeans(la configurazione di default va bene almeno mi pare di ricordare cosi..) aperto il programma, e creato un nuovo progetto(buttate un occhio a dove lo salvate, cosi con esplora risorse ce lo avete subito a portata di mano), ci si trova di fronte a un po' di scritte a caso:

/* To change this template, choose Tools | Templates and open the template in the editor.*/
package pacchetto;
/** @author Ciccio Pasticcio*/
public class Test {
/** @param args the command line arguments*/
public static void main(String[] args) {
// TODO code application logic here
}
}

Le parti che iniziano con /* e finiscono con */ sono commenti su piu' linee. Le parti che iniziano con // sono commenti su un unica linea.Le parti che iniziano con /** e finiscono con */ sono commenti per la documentazione JAVA e che verranno utilizzate (in modo automatico) per generare dei documenti carini tipo questi:http://docs.oracle.c...ractAction.htmle che sono istruzioni per chi migliorera' o ri-utilizzera' il nostro codice per fare altri programmiI commenti sono un aiuto alla comprensione per chi legge il programma(e sono particolarmente utili a chi tende a dimentcarsi le cose )dopo i commenti si nota: un' intestazione

package pacchetto;

il package e' una struttura che raccoglie funzionalita' simili del programma, e serve per realizzare grandi progetti in modo modulare, semplificando la vita ai poveri programmatoriche altrimenti dopo 4000-5000 di codice fitto fitto letteralmente impazzirebbero e non riuscirebbero a fare i programmi. ( di fatto e' una cosa che non ci serve direttamente a noi perche' il nostro programma di prova e' piccolo piccolo , pero' serve' ad un meccanismo di NetBeans che permette di poter realizzare(compilare) il programma per poter essere correttamente eseguito su qualunque macchina java )il nome dell'autore che ha scritto il programma.. u_ue poi inizia il codice vero e proprio con una scritta oscura:

public class Test {}

iniziamo dalla fine: le parentesi graffe

{ }

denotano un blocco di codice JAVA, tutte i nomi delle variabili che usiamo all'interno del blocco sono invisibili all'esterno del blocco anche se sono scritte nello stesso file. Inoltre le variabili all'esterno del blocco definite nello stesso file SONO visibili all'interno del blocco.

class Test

invece indica che stiamo realizzando una classe: siamo in un linguaggio ad oggetti: i file che scriviamo possono essere classi o interfacce, le classi sono dei modelli che vengono utilizzati per creare gli oggetti (delle interfacce non parlo ora, che non ci servono)esempio scemo: Nella realta' esiste il concetto di Bottiglia, tutte le bottiglie si ispirano a questo concetto: hanno una data capacita' (quanto liquido contengono) e hanno la possibilita' di essere riempite, oppure di poter essere svuotate di una parte del contenuto. Una classe in pratica e' il modello ideale.Quando nel programma mi servera' una bottiglia, creero' quell'oggetto(in un particolare modo che spieghero' piu' avanti) partendo dal modello che sto definendo

public

indica chi puo' accedere a questa "struttura" cioe' tutti in questo caso.la classe che stiamo scrivendo ora pero', non da la possibilita' di creare oggetti, ma e' solo un involucro per una serie di azioni che il nostro programma dovra' eseguire una volta lanciato:in particolare l'unica azione da eseguire sara' questa

public static void main(String[] args) {
/* TODO code application logic here*/
}

cioe' tutto quello che scriveremo qui dentro verra' eseguito dal nostro programmaQuesto aggeggio che si trova dentro al blocco classe e' un METODO,ovvero un azione che un oggetto o una classe puo' compiere(ritornando all'esempio di prima della bottiglia, versare e/o riempire)la parola

static

denota che il metodo e' legato non all'oggetto ma alla classe(ritornero' in futuro sul significato di queste parole e sulle conseguenze che ha mettere o non mettere la parola static).la parola

void

invece indica cosa restituisce l'azione(il metodo) che andiamo a fare.in questo caso "void" sta a indicare che l'azione non restituisce niente

main

e' il nome del metodo: main e' come detto prima il punto di inizio del nostro programma, e' un metodo predefinito e per forza non deve restituire nullae per forza deve essere static e public.la parte tra parentesi tonde invece

(String[] args)

sono i dati che il nostro metodo riceve interpreta e trasforma,dato che il metodo main e' un metodo speciale,sono tutte le informazioni che vogliamo che il nostro programma usi per poter svolgere il suo lavoro: in questo caso e' una serie(indicata dalle parentesi quadre) di stringhe (parole) di testo.Ora abbiamo un nucle minimo di informazioni con il quale poter iniziare a programmare

JAVA non OO -

Spoiler

Nella intro ho scritto di quello che sono le strutture di contorno per poter iniziare a scrivere i programmi:
riassumendo se volete scrivere un programma che non fa niente, ma che comunque possa venire tradotto nel linguaggio dei computer (compilato) correttamente dovete scrivere come minimo

public class PrimoProgramma{
public static void main(String[] args){}
}

in un editor di testo qualsiasi. Se salvate questo file come PrimoProgramma.java (occhio alle estensioni)e poi digitate

javac PrimoProgramma.java

verificate che non vengano fuori errori: e' successo che il comando javac ha prodotto un file PrimoProgramma.class. Se scrivete

java PrimoProgramma

, non succede niente cioe' abbiamo scritto il nostro primo programma che non fa assolutamente nulla( ). Per fargli fare qualcosa, e' necessario disporre di dati e di diversi comandiche un programma java puo' capire.
I dati base(tipi di variabile di base) che java riconosce sono:

boolean/*in cui si memorizzano il valore true(vero) o false(false)*/
byte/*in cui si memorizzano valori interi da -128 a 127*/
short/*in cui si memorizzano interi da -32.768 a 32.767*/
char/*in cui si memorizzano interi da 0 a 65535 utili per memorizzare caratteri*/
int /*in cui si memorizzano interi da -2miliardi fino a 2miliardi e qualcosa*/
long/*in cui si memorizzano in cui si memorizzano interi da -9,223,372,036di miliardi a 9,223,372,036 di miliardi*/
float /*in cui si memorizzano numeri a 32 bit con la virgola(mobile)*/
double/*in cui si memorizzano numeri a 64 bit con la virgola(mobile)*/

i dati base possono essere organizzate in tabelle dette array, che sono indicati mediante le parentesi quadre [], i valori che gli array possono assumere vengono scritti in parentesi graffe e sono separate da una virgola. Questi dati base possono essere estesi con dati piu' complessi ma che rientrano nella parte Orientata agli Oggetti di cui non si parla per il momento.
I comandi sono separati da ; (a dire la verita' si dovrebbe scrivere tutto in BNF, ma me ne frego , rinunciando a un bel po di rigore matematico.. ) i piu' importanti sono

(dato base) nome_variabile /*dichiarazione*/
nome_variabile=val /*assegnamento di una variabile*/
+ * / - /*sono operatori matematici che producono un valore partendo da due valori o dati di un determinato tipo, il risultato dipende dal tipo*
* coinvolto nell'operazione:ad esempio se sommo un double con un int *
*ottengo un double, se sommo un int con un int ottengo un int */
> < == <= >= /*test di condizione tra due valori(o variabili contenenti un valore): producono un valore boolean(e possono essere messi dove ci vuole un true o false) */
while(cond){/*codice che fa qualcosa*/}
/*ciclo che continua fintanto che cond (una valore boolean o una *
variabile con dentro un valore boolean)dentro le parentesi tonde e' true *
* esempio while(4==5){/*esegui qualcosa*/} non verra' mai eseguito */
for(variabile;cond;op){/*esegui qualcosa*/} /*loop che viene eseguito finche cond
e vera op e' un operazione che viene eseguita prima di iniziare un nuovo loop
(cioe' alla fine di ogni iterazione) */
do{/*qualche comando*/}while(cond)/*come while ma viene fatta almeno una iterazione*/

questi sono i comandi base, che possono essere mescolati a caso mantendo pero'
della regole:
1- alla fine di ogni comando deve esserci il punto e virgola.
2- una variabile non puo' essere definita due volte nello stesso blocco(parte con le parentesi graffe non si puo' scrivere {int i=5;int i =6} ):
...(ce ne sono altre ma non mi vengono in mente u__u queste sono le principali..)
Per poter rendere i programmi piu' interessanti occorre dire un ultima cosa, che non riguarda java ma il sistema operativo:
Per ogni programma che viene avviato il sistema operativo assegna tre "canali" di comunicazione verso l'esterno(altri programmi):

1. Standard Input (cioe' un canale in entrata)
2. Standard Output(un canale in uscita)
3. Standard Error(un canale per gli errori/i log)

A questi canali possono essere collegati dei file dal quale ricevera' o al quale inviera' i dati. Normalmente il comportamento predefinito del sistema operativo e' quello di collegare la tastiera allo standard input(generalizzando un po' si puo' dire che ogni periferica viene visto come un file), mentre lo standard output e lo standard error per default vengono collegati alla riga di comando dove si e' lanciato il programma java(con il comando java nomeprogramma).
Questi file speciali predefiniti possono essere richiamati mediante una funzionalita speciale:
esiste un elemento chiamato System che contiene al suo interno questi tre file, per potervi accedere occorre scrivere
System.in che permette di connettersi allo standard input
System.out che permette di connettersi allo standard output
System.err che permette di connettersi allo standard error
Questi file dispongono di operazioni speciali, per leggere(standard input) e per scriverci su(gli altri due ).


detto questo dovremmo essere in grado di scrivere il nostro programma di test(mi raccomando sotto windows mettete le estensioni visibili dei file):
supponendo che nel nostro programma abbiamo una sequenza(array) di numeri prefissata di cui vogliamo fare la somma.

public class Esempio{

public static void main(String[] args){
/*supponiamo che la sequenza di numeri data sia di 4 numeri e sia 65.345 21.65 2.12 8.214 */

float[] var={65.345f,21.65f,2.12f,8.214f};
/*per prima cosa definiamo(definire=assegnamento +dichiarazione) una variabile di tipo sequenza di float*/
/*e assegnamo staticamente alla variabile la sequenza di numeri: (siamo costretti a fare assegnamento e dichiarazione in una volta
a causa del metodo che abbiamo scelto per creare la sequenza, non mi dilungo troppo, nella parte Java OO sara tutto piu' chiaro )
il bello della sequenza e' che possono essere accedeute per posizione: ad esempio in prima posizione (pos. numero 0)
e' presente il numero 65.345 e cosi via. Occorre aggiungere la f perche' abbiamo definito la variabile come sequenza di float
un numero scritto semplicemente con un punto nel mezzo, viene assunto che sia di tipo double e occorre dichiarare a java che invece noi
vogliamo considerare quel valore come float */
/*ora viene la parte "difficile": dobbiamo scorrere la sequenza dal primo all'ultimo elemento questa cosa si puo' fare in diversi modi:*/
int i;
float risultato;
risultato=0;/*dobbiamo inizializzare la variabile risultato ad un valore,perche' quando la dichiariamo, la variabile non ha nessun valore
sappiamo solo che c'e'*/
/*il metodo piu' immediato e' con un ciclo for, se avete voglia provate a scriverlo in un altro paio.. ma ce ne sono molti */
for(i=0;i<4;i=i+1){/*notare che ci sono solo due punto e virgola */
/*IMPORTANTE: la prima posizione di una sequenza di n posizioni e' la posizione 0, l'ultima la 3
(e' dal 1200 che conosciamo lo zero ma ancora potrebbe risultare strano utilizzarlo correttamente)*/
risultato=risultato+var;/*dato che ad ogni giro viene aggiornata la variabile i
la utilizzo per accedere alla posizione corrispondente nella sequenza*/
}
System.out.println(risultato);/*System.out ha un operazione speciale chiamata print che scrive sul file collegato
tutto quello che e' dentro le parentesi tonde(detto in informatichese: "System.out ha un metodo print")
la parola ln attaccata a print e' un abbreviazione per dire che dopo che ha scritto il testo deve andare a capo*/
}
}

abbiamo scritto il nostro programma. Lo salviamo con lo stesso nome che compare dopo la scritta class, nel nostro caso dobbiamo salvare il file come Esempio.java se blocco note non ci permette di salvare con l'estensione java, occorre rinominare il file una volta creato.
(se il percorso a java fa parte delle variabili globali e' sufficiente digitare da linea di comando, una volta collocati nella cartella dove abbiamo salvao il file)
javac Esempio.java
verificare che non ci siano errori, e alla fine eseguire il comando con
java Esempio
e gustarci il risultato dei nostri sforzi

in continuo aggiornamento

Modificata da pio ping 34, 05 October 2012 - 02:44 AM.

[Metallingus 91]

ehm io non so nulla di programmazione, o pochissimo... se ti posso aiutare (e tu insegni qlc a me) a disposizione

[pio ping 34]

@METALLINGUS sei il benvenuto..
se proprio non hai mai visto nulla di programmazione e vuoi iniziare a scrivere qualche programmino in java, la cosa migliore che puoi fare e' andare sul sito della Oracle e scaricarti NETBEANS, (oppure ECLIPSE, che secondo me e' piu' leggero e piu' versatile)

quello che mi piacerebbe fare, sarebbe anche una introduzione alla programmazione, per neofiti...
pero' mi sembra che questo argomento (rete / concorrenza), siano forse un po' avanzati per chi si avvicina per la prima volta alla programmazione
sicche mi limito a postare lo status dello sviluppo del programma e qualche riga di codice,
cercando di spiegare quello che sto facendo, tando per rendere familiari concetti che sono all'ordine del giorno per chi programma.

AVVERTIMENTI
sono uno studente e non conosco in superdettaglio tutti i meccanismi che stanno sotto alle API, e dato che mi piacerebbe espandere le mie conoscenze, se vedete qualche imprecisione/generalizzazione di troppo o avete qualche osservazione fatevi avanti..

..
io intanto ne approfitto per ripassare un po' di programmazione

Modificata da pio ping 34, 17 September 2012 - 08:05 AM.

[Tiagullo]

non è cosi facile socio! Fidati io java l'ho studiato alle superiori per un anno e fare un topic solo per insegnare la programmazione è molto complicato!

[pio ping 34]

diario di sviluppo.. #1

mi sono reso conto che l'abbozzo di specifica che mi sono dato fa veramente schifo T_T: Non dice nulla di veramente utile e mi ha lasciato tante soluzioni possibili,
cosi ho passato i primi giorni a prendere in considerazione varie/troppe soluzioni possibili.

Alla fine (ma mi riservo di cambiare tutto di nuovo ), sono arrivato alla conclusione che chi usera' il programma per il test della velocita' di connessione(io? ), non voglia smanettare troppo con indirizzi IP, configurazioni passate per riga di comando e altre atrocita' del genere, ma si voglia limitare a lanciare il numero minimo di programmi indispensabili per far girare i test.

In definitiva ci saranno tanti programmi sparsi per i vari computer che compongono la rete
che "si presentano" ad un particolare programma(il centro di controllo) che girera' solo su un computer.

Lo scopo di questo programma e' di creare delle coppie per la ricezione/invio dei dati di test, che faccia partire il test e che organizzie e permetta di visualizzare i dati del test su un unico computer.
Per rendere piu' semplice l'installazione e la formazione di coppie di invio/ricezione , i programmi che inviano i dati ad un computer, possono allo stesso tempo anche riceverli da un (e uno solo) altro computer della rete.

-------------------------------------------------------------------------------------------------------------------------

problema 1. ( ancora prima di cominciare iniziano i problemi )

dato che non volete e non voglio stare a smanettare con interfacce di rete varie, indirizzi IP e altre simili amenita' occorre creare un meccanismo che nasconda a chi utilizza il programmino tutta una serie di dettagli, che potrebbero confonderlo e complicare le cose..

la soluzione proposta e' questa:

Ogni programma di invio/ricezione cerca quali sono gli indirizzi IP disponibili nel computer dove gira. Se ne e' presente uno, nessun problema, si usera' quello, se ce ne sono piu' di uno si chiedera' all'utente quale si vuole utilizzare..
----------------------------------------------------------------------------------------------------------
E ora LA PRATICA

sotto spoiler c'e' una introduzione per chi non sa nulla di java/netbeans e/o linguaggi a oggetti, e vuole provare a capire qualcosa senza limitarsi a ricopiare bovinamente
il codice

Spoiler

Dopo aver installato NetBeans(la configurazione di default va bene almeno mi pare di ricordare cosi..) aperto il programma, e creato un nuovo progetto(buttate un occhio a dove lo salvate, cosi con esplora risorse ce lo avete subito a portata di mano), ci si trova di fronte a un po' di scritte a caso:

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package pacchetto;

/**
*
* @author Ciccio Pasticcio
*/
public class Test {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
}
}

Le parti che iniziano con /* e finiscono con */ sono commenti su piu' linee
Le parti che iniziano con // sono commenti su un unica linea.
Le parti che iniziano con /** e finiscono con */ sono commenti che fanno parte della documentazione JAVA e che verranno utilizzate (in modo automatico) per generare dei documenti carini tipo questi: http://docs.oracle.c...ractAction.html
e che sono istruzioni per chi migliorera' o ri-utilizzera' il nostro codice per fare altri programmi

I commenti sono un aiuto alla comprensione per chi legge il programma(e sono particolarmente utili a chi tende a dimentcarsi le cose )

dopo i commenti si nota: un' intestazione

package pacchetto;

il package e' una struttura che raccoglie funzionalita' simili del programma, e serve per realizzare grandi progetti in modo modulare, semplificando la vita ai poveri programmatori
che altrimenti dopo 4000-5000 di codice fitto fitto letteralmente impazzirebbero e non riuscirebbero a fare i programmi. ( di fatto e' una cosa che non ci serve direttamente a noi perche' il nostro programma di prova e' piccolo piccolo , pero' serve' ad un meccanismo di NetBeans che permette di poter realizzare(compilare) il programma per poter essere correttamente eseguito su qualunque macchina java )

il nome dell'autore che ha scritto il programma.. u_u

e poi inizia il codice vero e proprio con una scritta oscura:

public class Test {

}

iniziamo dalla fine: le parentesi graffe

{ }

denotano un blocco di codice JAVA, tutte i nomi delle variabili che usiamo all'interno del blocco sono invisibili all'esterno del blocco anche se sono scritte nello stesso file. Inoltre le variabili all'esterno del blocco definite nello stesso file SONO visibili all'interno del blocco.

class Test

invece indica che stiamo realizzando una classe: siamo in un linguaggio ad oggetti: i file che scriviamo possono essere classi o interfacce, le classi sono dei modelli che vengono utilizzati per creare gli oggetti (delle interfacce non parlo ora, che non ci servono)

esempio scemo: Nella realta' esiste il concetto di Bottiglia, tutte le bottiglie si ispirano a questo concetto: hanno una data capacita' (quanto liquido contengono) e hanno la possibilita' di essere riempite, oppure di poter essere svuotate di una parte del contenuto. Una classe in pratica e' il modello ideale.
Quando nel programma mi servera' una bottiglia, creero' quell'oggetto(in un particolare modo che spieghero' piu' avanti) partendo dal modello che sto definendo

public

indica chi puo' accedere a questa "struttura" cioe' tutti in questo caso.


la classe che stiamo scrivendo ora pero', non da la possibilita' di creare oggetti, ma e' solo un involucro per una serie di azioni che il nostro programma dovra' eseguire una volta lanciato:

in particolare l'unica azione da eseguire sara' questa

public static void main(String[] args) {
// TODO code application logic here

}

cioe' tutto quello che scriveremo qui dentro verra' eseguito dal nostro programma
Questo aggeggio che si trova dentro al blocco classe e' un METODO,
ovvero un azione che un oggetto o una classe puo' compiere(ritornando all'esempio di prima della bottiglia, versare e/o riempire)
la parola

static

denota che il metodo e' legato non all'oggetto ma alla classe(ritornero' in futuro sul significato di queste parole e sulle conseguenze che ha mettere o non mettere la parola static).

la parola

void

invece indica cosa restituisce l'azione(il metodo) che andiamo a fare.
in questo caso "void" sta a indicare che l'azione non restituisce niente

main

e' il nome del metodo: main e' come detto prima il punto di inizio del nostro programma, e' un metodo predefinito e per forza non deve restituire nulla
e per forza deve essere static e public.
la parte tra parentesi tonde invece

(String[] args)

sono i dati che il nostro metodo riceve interpreta e trasforma,
dato che il metodo main e' un metodo speciale,
sono tutte le informazioni che vogliamo che il nostro programma usi per poter svolgere il suo lavoro: in questo caso e' una serie(indicata dalle parentesi quadre) di stringhe (parole) di testo.

Ora abbiamo un nucle minimo di informazioni con il quale poter iniziare a programmare

Il programma che andremo a scrivere dentro il main, ci mostra tutti gli indirizzi IP
con i quali viene identificato il computer che fa girare il programma.

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package pacchetto;



import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;

/**
*
* @author Ciccio Pasticcio
*/
public class Test {

public static void main(String[] args) throws SocketException{
/*la parte throws indica gli errori/eccezioni che il metodo puo' sollevare, ci si ritorna in seguito */

Enumeration<NetworkInterface> interfacceRete=NetworkInterface.getNetworkInterfaces();
/*la frase sopra definisce un oggetto di tipo Enumeration, un insieme di oggetti che possono essere restituiti uno a uno, la parte con le parentesi angolate dice che ogni elemento che fa parte del tipo Enumeration a sua volta e' un oggetto di tipo NetworkInterface. interfacciaRete e' il nome con il quale chiamo l'oggetto Enumeration in seguito. L'uguale rappresenta l'assegnamento, cioe' a cosa associo il nome [b]interfacceRete[/b].
In questo caso ho associato interfacciaRete a il valore restituito da un metodo di tipo "static" della classe NetworkInterface (che e' una classe predefinita di java che definisce delle azioni e dei parametri delle schede di rete dei computer ).*/

System.out.println("Ricerca indirizzi IP del computer");
/*questo comando serve per scrivere su schermo andando a capo: invoco il metodo println() sull'oggetto out nella classe System*/
while(interfacceRete.hasMoreElements()){

/*fin quando interfacce rete contiene un elemento*/
NetworkInterface cursore=interfacceRete.nextElement();
/*prendi un elemento, e lo chiamo cursore, rimuovilo deall'insieme*/
Enumeration<InetAddress> listaIndirizzi=cursore.getInetAddresses();
/*e ricava la listadi indirizzi IP associato al cursore*/
while(listaIndirizzi.hasMoreElements()){
/*fin quando lista indirizzi contiene un elemento*/
System.out.println(listaIndirizzi.nextElement().getHostAddress());
/*stampa indirizzo*/
}
}
}
}

se da dentro netbeans premiamo il triangolo verde,in alto sotto la barra degli strumenti,
otteniamo il seguente risultato(compare in fondo in una finestrella con su scritto output)

Ricerca indirizzi IP del computer
fe80:0:0:0:201:2eff:fe27:973f%2
1.1.1.4
0:0:0:0:0:0:0:1%1
127.0.0.1

nel mio caso ha trovato 4 indirizzi
(in realta' dovrebbero essere due gli altri due in piu' sono la traduzione nel nuovo standard ip6 degli indirizzi ip4 della mia scheda di rete )

/*FINE*/

Se avete dubbi /domande /commenti chiedete pure.. io porto avanti il programmino..
P.S. Caso mai postate i vostri risultati o cose strane che vi sono capitate.. (che tanto succedono sempre )

P.P.S non trovo il modo di editare il titolo..se non riesco a trovarlo editatelo pure !!

Modificata da pio ping 34, 21 September 2012 - 06:24 PM.

[kracaos]

sto topic capita proprio a fagiolo

volevo chiedere su off-topic, ma visto questo tread... bando alle ciance, vorrei eseguire programmi java (esercizi piuttosto semplici niente di che) però non so quale versione scaricare e sopratutto dove.

il mio pc è un pentium 4 e con os da 32bit, sono andato sul sito di oracle, ma non so questa vers va bene?

Linux x86 (32-bit) jdk-7u3-linux-i586.rpm

magari anche da altre fonti

[kracaos]

comunque grazie a me stesso ho scaricato il jdk per linux 32bit

è un file zip, non riesco a capire come si installa però

[Elnor]

comunque grazie a me stesso ho scaricato il jdk per linux 32bit

è un file zip, non riesco a capire come si installa però

Ti basta seguire, sono pochi comandi da terminale, una qualunque guida che trovi in rete. Vedi qui se hai ubuntu http://www.sparkblog...a-ubuntu-12-04/

Dopo di che ti basta scaricare un qualunque Ide ed iniziare. Personalmente consiglio Eclipse.

Modificata da Elnor, 21 September 2012 - 09:51 AM.

[pio ping 34]

si vanno bene tutti..
secondo me eclipse pero' e' leggermente piu' da "esperti" (e per questo molto piu' versatile)

con netbeans non ti devi preoccuare di nulla (o quasi ) per quanto riguarda java e sei da subito pronto a scrivere e testare programmi,
cioe' ti scarichi netbeans e lui ti scarica e configura automaticamente da solo l'ultimo jdk disponibile..

per eclipse ci sono tantissime versioni di partenza (che poi possono essere integrate)
e per un neofita potrebbe essere spiazzante.

addirittura potresti fare tutto a mano (invece che usare l'ide usare: usi blocco note per scrivere il programma (e lo salvi con un nome tipo nome_file.java )
e poi da riga di comando scrivi javac nome_file.java
e vedere se il programma compila,
comunque se non hai esperienza di compilazione, e di riga comando
utilizzare un ide rimane la cosa piu' semplice e immediata..

/*******/

Diario di sviluppo #2

ho deciso che i programmi per eseguire i test sulla rete, si scambieranno pacchetti UDP, almeno si levano complicazioni inutili, che infastidiscono e basta. Inoltre per rendere il codice di piu' facile l'interpretazione del codice, ognivolta che i programmi devono scambiarsi dati attraverso la rete, i dati che si passano sono stringhe di testo:
in realta' questo e' uno spreco di risorse, pero' aiuta a capire cosa sto facendo.

quando due programmi si scambiano dati, si cerca di mettere i dati che si scambiano nella forma piu' compatta possibile, per non sovraccaricare troppo la rete e non occupare troppe risorse.

piccolo esempio(semplice semplice):

un programma A vuole comunicare ad un altro programma B che la temperatura ambiente e' 37 gradi

di solito succede che
A invia solo il numero 37(con una particolare codifica), e B sa che 37 sono i gradi della stanza

se invece A adottasse il metodo che ho usato io, invierebbe a B la frase "A invia a B la teperatura 37 gradi prensente nella stanza "

Comunque ormai manca solo il programma di controllo e gestione e poi vedo se quello che ho scritto ha un senso oppure no

Modificata da pio ping 34, 21 September 2012 - 11:41 AM.

[kracaos]

non so per quale motivo ma dal terminale non sono riuscito a scaricare i pacchetti, ho quindi scaricato un file zip, jdk-7u7-linux-i586.tar.gz, però non capisco come fare ad installare java

ma javac è compreso nel jdk vero?

[pio ping 34]

hai scaricato il codice sorgente? secondo me se hai ubuntu
ti conviene installare tutto con sudo apt-get install java, sul forum di ubuntu dovrebbero esserci delle guide

[kracaos]

eh ma non funziona.... conosco il comando sudo apt-get install ma quando cerco di usarlo con java mi dà errore, però in compenso ho scaricato il jdk in formato zip (peso 92 MB circa) e il problema sta nel fatto che non so cosa farci con questo file zip, cioè si può usare per installare java, ma non so come farlo...

[pio ping 34]

qui c'e' la guida..
http://shinephp.com/...dk-7-on-ubuntu/

una volta che installi il jdk devi linkare le librerie sull'ide che usi..

se ci riesci acquisci un po' di esperienza con linux, ma imho se il tuo interesse e' scrivere da subito qualche riga di codice
la via piu' veloce e' quella di scaricarsi netbeans o dai repository ufficiali o diretamente dal sito oracle..

Modificata da pio ping 34, 21 September 2012 - 04:09 PM.