|
Partecipanti alla riunione: Nophiq, Inca, PieroTofy
-----------------------------------------
Nophiq scrive: iniziamo ufficialmente la riunione
Nophiq scrive: ho preparato una mezza scaletta da seguire
Nophiq scrive: prima di tutto devo informarvi e rendervi consapevole che il progetto sarà promosso sotto licenza GNU G.P.L.
Kecco scrive: nessun problema
Nophiq scrive: e pensavo di mettere una postilla dove si indicava che qualsiasi software che si sarebbe appoggiato su questa architettura sarebbe dovuto essere pubblicato anch'esso sotto licenza GNU G.P.L
Piero Tofy scrive: non serve mettere postilli... qualsiasi software che usa codice di un programma G.P.L. automaticamente diventa sotto GPL pure esso...
Piero Tofy scrive: almeno credo
Piero Tofy scrive: lol
Nophiq scrive: ma il gioco per esempio non deriva dal programma (chiamiamolo Server) si appoggia solamente
Nophiq scrive: per comunicare
Piero Tofy scrive: bu, se proprio vogliamo fare le cose per bene
Piero Tofy scrive: possiamo dettare noi una nuova licenza
Piero Tofy scrive: Bluenet License
Nophiq scrive: benissimo
Nophiq scrive: ci avevo pensato
Nophiq scrive: ma bisogna farla veramente bene
Nophiq scrive: altrimenti si rischia di perdere tutto il lavoro fatto
Piero Tofy scrive: e bisogna anche tradurla in inglese
Kecco scrive: chi è esperto di diritto informatico?
Nophiq scrive: basta scaricare un libro da internel :lol:
Piero Tofy scrive: lol
Kecco scrive: magari possiamo predere spunto da altre license ben fatte
Piero Tofy scrive: esatt
Kecco scrive: poi per la traduzione ci si arrangia
Nophiq scrive: passiamo alla presentazione del Team in base all'ordine di entrata:
- Nophiq > Ideatore/Programmatore
- Radio > Tester
- Netarrow > Programmatore
- Inca > Programmatore
- MisterKing > Programmatore
- Siaco > Programmatore
- PIeroTofy > Programmatore
Kecco scrive: cominci tu?
Nophiq scrive: tutti hanno anche la capacità di analizzare e progettare il software "a tavolino"
Nophiq scrive: [cominci tu? per cosa?]
Kecco scrive: a credevo che facessimo una presentazione per bene!
Piero Tofy scrive: si vabbè non siamo l'alcolisti anonimi
Piero Tofy scrive: "ciao io sono piero"
Nophiq scrive: ciao piero
Kecco scrive: lol
Nophiq scrive: (in coro)
Piero Tofy scrive: oggi ho bevuto un solo bicchiere di vino e ne vado fiero
Kecco scrive: di già?
Nophiq scrive: ok non andiamo troppo OT
Kecco scrive: si si
Piero Tofy scrive: esatt, procediamo
Nophiq scrive: torniamo adesso alla presentazione del progetto e della sua struttura
Nophiq scrive: ecco quel che ho pensato mentre ero a lavorare
Nophiq scrive: Innanzitutto per avviare l'architettura è necessario avviare sia il Bluetooth che il programma Base (che d'ora in poi chiameremo "Server")
Piero Tofy scrive: la rete che andiamo a creare è client-server based?
Nophiq scrive: quasi, non proprio, lo spiegherò fra poco
Piero Tofy scrive: ok
Nophiq scrive: l'utente che avvia il Server invia dei messaggi particolari (ping) a tutti gli utenti compresi nel raggio del Bluetooth alla ricerca di una rete già avviata, se così non fosse sarebbe lui il primo della rete
Nophiq scrive: cosa succede se la rete è già stata creata ed io devo aggiungermi? Che l'utente che mi risponde in modo positivo al ping mi passa anche (successivamente) la mappa della rete alla quale appartiene
Nophiq scrive: e nel caso ricevo due mappe diverse da due utenti diversi il Server mi metterà al lavoro per assemblare queste due reti perchè da adesso in poi sarei il ponte fra queste due reti
Nophiq scrive: questa è la parte di acquisizione della mappa/e
Nophiq scrive: ora osserviamo il sistema di Ping che avevo pensato (e rispondo adesso alla tua domanda Piero)
Nophiq scrive: La classe Ping invia un messaggio per ogni utente che rientra nel raggio del Bluetooth
Nophiq scrive: e chiamiamo ogni messaggio del ping "Blocco"
Nophiq scrive: però io (che sarei l'utente che si connette alla nuova rete)
Nophiq scrive: non mi connetto permanentemente agli utenti che si trovano nel raggio del Bluetooth e che hanno il Server attivo
Nophiq scrive: come farebbe un programma client/server based
Nophiq scrive: ma
Nophiq scrive: Io mi connetto, invio il messaggio avente il numero di Blocco univoco, e poi chiudo la connessione immediatamente
Nophiq scrive: cosa succede
Nophiq scrive: che se il server non è attivo nel destinatario allora riceverò un messaggio NULL
Nophiq scrive: o qualcosa del genere
Nophiq scrive: se invece è attivo aspetto una riposta
Nophiq scrive: ma fino a quando se non ho più la connessione? Aspetterò fino a quando il numero delle risposte non sarà pari al numero di messaggi Ping (Blocchi) inviati
Nophiq scrive: vi è chiaro questo passaggio? Domande?
Piero Tofy scrive: sul ping direi di no, è semplice
Kecco scrive: si ho seguito
Nophiq scrive: Questo sistema l'avevo ipotizzato per risparmiare risorse
Nophiq scrive: si memoria
Nophiq scrive: di*
Piero Tofy scrive: quello che mi sembra difficile e poco flessibile da realizzare, è il sistema di mappatura della rete e l'esistenza di un unico cellulare che fa da "server" centrale per la rete
Nophiq scrive: qui non è presente alcun server centrale
Piero Tofy scrive: e la mappatura che è?
Nophiq scrive: la mappatura
Kecco scrive: e un archittettura simile al peerTopeer?
Nophiq scrive: è un diagramma dove viene rappresentato attraverso un grafo la rete ed i suoi nodi (cellulari)
Piero Tofy scrive: e chi la assembla?
Nophiq scrive: [non so come funzioni la rete peer-to-peer]
Piero Tofy scrive: ogni cellulare per conto suo?
Kecco scrive: vuol dire punto per punto
Piero Tofy scrive: o viene ricevuta da qualcun'altro?
Nophiq scrive: facciamo un esempio
Nophiq scrive: A è il primo ad attivare il programma è c'è solo lui all'interno della rete
Nophiq scrive: B attiva il programma e vede che A è all'interno di una rete (grazie al sistema di Ping) e riceve da questo la mappa, che al momento è composta solamente da A
Nophiq scrive: una volta che B ha ricevuto la mappa deve avvisare tutti gli altri appartenenti alla rete che c'è anche lui adesso
Nophiq scrive: e lo farà attraverso un'altra classe di messaggi (non più di PIng)
Nophiq scrive: quindi al momento ci troviamo nella rete A-B
Kecco scrive: in questo modo tutti coloro che ricevono la presenza di B dovranno ricreare la mappa?
Nophiq scrive: no, diciamo che è B (il nuovo entrato) ad elaborare la nuova mappa e a passarla alla rete
Kecco scrive: ma dovr àpassarla a tutti i "membri" oppure per esempio la passa ad A che poi la passa ad A1 e cosi via
Piero Tofy scrive: è un metodo poco flessibile.. se A attiva il programma, non trova nessuno, successivamente B attiva il programma e non trova nessuno perchè è troppo distante e C attiva il programma e vede entrambi, deve elaborare nuovamente lui stesso una nuova mappa e inviarla ad A e B, ma se contemporaneamente D vede solamente B e C dovrà elaborare nuovamente un altra mappa e questo creerà un conflitto di mappe
Piero Tofy scrive: che andrebbe risolto con un algoritmo di fusione delle mappe
Nophiq scrive: allora questo è il prossimo punto critico di qui parlare
Piero Tofy scrive: ma se poi ad un certo punto qualcuno si sconnette, si dovrà nuovamente ricalcolare il tutto
Piero Tofy scrive: io ho una soluzione più flessibile e facile da implementare
Nophiq scrive: sì Piero rispondo un attimo a Inca poi ti lascio la parola
Piero Tofy scrive: ricordiamoci che il bluetooth ha comunque una capacità di trasferimento dati
Piero Tofy scrive: di quasi 1 mbps
Piero Tofy scrive: che non è poco... si vai pure avanti
Nophiq scrive: Allora Inca per quello che avevo pensato io ammettiamo l'esistenza di una grande rete
Kecco scrive: si
Nophiq scrive: F (il nuovo entrato) passerà la nuova mappa elaborata ad E il quale poi penserà lui ad inoltrarla successivamente al resto della rete attraverso lo stesso metodo, ma con un algoritmo ben preciso per evitare che un utente riceva due volte la stessa mappa
Nophiq scrive: vai Piero
Piero Tofy scrive: dunque
Kecco scrive: secondo me sarebbe una buona idea invece di una mappa di usare una lista che è più flessibile
Piero Tofy scrive: kecco è vicino alla mia idea
Kecco scrive: lol
Piero Tofy scrive: il sistema non ha nessun tipo di mappa
Piero Tofy scrive: e nessuno fa da "creatore di mappe"
Piero Tofy scrive: tutti hanno lo stesso livello di potenzialità, come una vera rete p2p
Piero Tofy scrive: e questo metodo crea anche la possibilità di fare una sorta di chat comune tra tutti gli utenti di Bluenet
Piero Tofy scrive: in pratica, quando A avvia il programma
Piero Tofy scrive: pinga su tutta la rete bluetooth in cerca di altri cellulari con il programma attivo, come nel tuo sistema nophiq
Piero Tofy scrive: e ottiene una lista di cellulari attivi
Piero Tofy scrive: (se c'è ne sono)
Piero Tofy scrive: ora supponendo che B sia anche lui connesso alla rete
Piero Tofy scrive: riceve un messaggio da A dove A informa B che anche lui c'è
Piero Tofy scrive: a questo punto B trasmette un messaggio del tipo "guardate che c'è anche A" a tutta la sua lista di cellulari
Piero Tofy scrive: quando qualcuno invia un messaggi
Piero Tofy scrive: messaggio
Piero Tofy scrive: supponendo che A invia un messaggio a C, il messaggio non è diretto solamente a C
Piero Tofy scrive: il messaggio viene inoltrato a tutti i cellulari
Piero Tofy scrive: e il primo che riesce a recapitare il messaggio a C
Piero Tofy scrive: a sua volta invia a tutti i cellulari un messaggio di conferma tipo "guardate che ho recapitato il messaggio"
Piero Tofy scrive: insomma, tutti i cellulari inviano a tutti gli altri tutti i dati
Piero Tofy scrive: dopo impostando i vari filtri si evita che i cellulari ricevano messaggi indesiderati
Piero Tofy scrive: un po' come funziona con le schede ethernet in una LAN
Nophiq scrive: non c'è un pò troppo traffico?
Piero Tofy scrive: trasmettiamo solo testo
Piero Tofy scrive: una frase non occupa pi
Piero Tofy scrive: più di 20 bytes
Piero Tofy scrive: e il bluetooth possiede una capacità di 1 mbps
Kecco scrive: cmq si potrebbe rendere la trasmissione più efficace creando una lista particolare
Nophiq scrive: Piero ma la chat non sarà il solo programma ad essere sviluppato (spero), ma pensa anche ai giochi: trasmettono più di 20 bytes
Kecco scrive: per esempio ogni membro della lista memorizza il membro a lui più vicino
Kecco scrive: solo che non so se si può fare con il bluetooth
Piero Tofy scrive: non penso che si possa sapere quanto distante è un cellulare rispetto all'altro
Kecco scrive: già
Piero Tofy scrive: no, credo di no
Piero Tofy scrive: solo col wi-fi
Nophiq scrive: vi espongo la mia idea e del perchè avevo utilizzato la mappa
Nophiq scrive: la mappa serve per tracciare il percorso più breve (attraverso un algoritmo particolare che MisterKing mi ha passato) per fa giungere a destinazione il messaggio
Nophiq scrive: il messaggio inviato contiene un insieme di stringhe particolari
Nophiq scrive: il primo sarebbe il numero del blocco, il secondo la lista di utenti per i quali il messaggio deve passare (Forwardare) ed infine il messaggio proprio
Piero Tofy scrive: si, ma non stiamo parlando di una rete tra computers via cavo, stiamo parlando di bluetooth! uno fa 3 passi e potrebbe non essere più raggiungibile! per garantire il maggior numero di probabilità che il messaggio venga recapitato inviare tutti i dati a tutti è il metodo piu sicuro
Piero Tofy scrive: non sarà il più efficente
Piero Tofy scrive: concordo
Nophiq scrive: effettivamente quello di un sistema dinamico mi aveva reso un pò la vita difficile
Kecco scrive: possiamo provare a studiare una soluzione che sia a metà strada tra le due
Nophiq scrive: magari
Nophiq scrive: hai qualche idea Inca?
Kecco scrive: bisognerebbe prima vedere come orgnizzare la lista di tutti i connessi
Piero Tofy scrive: IDCELLULARE_Nickname
Nophiq scrive: per l'ID del cellulare io avevo pensato al Numero di Cellulare (naturalmente non visibile per pricacy)
Kecco scrive: sarebbe la cosa migliore
Piero Tofy scrive: io avevo pensato che forse esiste qualche funzione di j2me
Piero Tofy scrive: che ti permette di avere il numero di serie
Nophiq scrive: meglio ancora
Nophiq scrive: ma ho letto che non comunica assolutamente in modo nativo con il S.O.
Piero Tofy scrive: o malchevada usiamo un numero casuale
Nophiq scrive: e poi Piero una domanda: attraverso il tuo metodo come fai a sapere quali utenti sono connessi alla rete Bluenet?
Kecco scrive: nella lista si potrebbe memorizzare la size
Nophiq scrive: (devi sapere il nick del destinatario per inviargli il messaggio)
Piero Tofy scrive: quando un cellulare si collega alla rete bluenet, gli altri inviano a tutti gli altri "guardate che c'è anche X"
Piero Tofy scrive: perchè quando X si è connesso ha inviato a tutti quelli che ha potuto "guardate che ci sono anch'io"
Piero Tofy scrive: lol
Nophiq scrive: quindi ogni cellulare avrebbe una lista di tutti gli utenti e basta
Piero Tofy scrive: zi
Kecco scrive: forse per iniziare possiamo utilizzare questo sistema meno efficiente ma diciamo più sicuro
Piero Tofy scrive: dopo si può implementare
Piero Tofy scrive: un sistema che viene attivato a scadenza
Piero Tofy scrive: tipo ogni minuto
Piero Tofy scrive: dove si fa "l'appello"
Nophiq scrive: un isAlive
Piero Tofy scrive: del tipo "c'è ancora A"?
Piero Tofy scrive: e tutti i cellulari chiederanno agli altri se c'è A
Piero Tofy scrive: e quando A riceve il messaggio risponde affermativamente
Nophiq scrive: una domanda: perchè prima avete detto che la lista è più flessibile di una mappa (non ho esperienza nè con l'una nè con l'altra)
Nophiq scrive: ?
Piero Tofy scrive: una lista è solo una sequenza di dati
Piero Tofy scrive: come un array
Kecco scrive: ecco
Piero Tofy scrive: la mappa è qualcosa di più, dove ci sono anche dei collegamenti e dei nodi
Nophiq scrive: quindi è molto più leggera
Piero Tofy scrive: yup
Kecco scrive: più che altro il problema sarebbe creare il grafo della mappa senza contrasti
Piero Tofy scrive: infatti
Kecco scrive: la lista è anche facile da aggiornare
Kecco scrive: visto che questo tipo di rete richiede aggiornamenti continui
Nophiq scrive: ok mi servivano delle argomentazioni per esserne convinto
Nophiq scrive: ah mi ero dimenticato di dirvi
Nophiq scrive: che tutto il progetto
Nophiq scrive: ha come priorità ASSOLUTA l'uso minimo della memoria
Kecco scrive: bravo
Piero Tofy scrive: zi
Nophiq scrive: tipo a = a +1 deve diventare assolutamente a++
Nophiq scrive: risparmiare ogni bit possibile
Kecco scrive: qualcuno ha idea di come risparmiare memoria su un cell
Piero Tofy scrive: domanda: lo dobbiamo sviluppare come libreria
Piero Tofy scrive: o come programma?
Nophiq scrive: il server?
Kecco scrive: per esempio si risparmia molto con a++
Piero Tofy scrive: bluenet in generale
Piero Tofy scrive: dev'essere una libreria di funzioni
Piero Tofy scrive: che poi possono essere richiamate da altri programmi
Nophiq scrive: allora bluenet è un programma Server
Piero Tofy scrive: perchè in questo caso è necessario astrarre molte cosette
Nophiq scrive: perchè un programma BlueChat sì collegherà al proprio server in Locale per inviare messaggi al destinatario
Nophiq scrive: quindi direi che è un programma
Piero Tofy scrive: questo presuppone che ci siano 2 apps in esecuzione?
Nophiq scrive: anche 3
Piero Tofy scrive: impozzibile :/
Nophiq scrive: ah sì?
Piero Tofy scrive: lol
Piero Tofy scrive: sicuro come la morta
Piero Tofy scrive: *morte
Piero Tofy scrive: non si può far girare più di 1 app
Piero Tofy scrive: per volta su J2ME
Nophiq scrive: allora c'è poco da fare
Piero Tofy scrive: ho anche qualche dubbio sui thread, ma mi pare che siano supportati
Piero Tofy scrive: anche se in maniera più limitata rispetto a J2SE
Nophiq scrive: dobbiamo svilupparlo come libreria, che cosa comporta questo?
Piero Tofy scrive: comporta che per testarlo bisogna fare un altro programma
Piero Tofy scrive: e che bisogna pensare in maniera più astratta possibile
Piero Tofy scrive: bho, pensandoci bene
Piero Tofy scrive: neanche tanto
Nophiq scrive: un gruppo penserà allo sviluppo di Bluenet ed un altro di BlueChat visto che mi sembra il programma più semplice
Piero Tofy scrive: mi sembra buono
Piero Tofy scrive: io posso fare bluenet?
Piero Tofy scrive: xD
Nophiq scrive: all'inizio faremo tutti un pò Bluenet perchè senza i metodi fondamentali BlueChat non può esistere
Piero Tofy scrive: l'interfaccia grafica
Piero Tofy scrive: può essere comunque sviluppata
Piero Tofy scrive: subito
Nophiq scrive: Comunque i meriti del programma sviluppato saranno suddivisi equamente per ogni Membro
Piero Tofy scrive: anzi, io di solito parto sempre da quella
Nophiq scrive: sì ho visto qualche riga di codice
Nophiq scrive: e mi sebra facile da sviluppare
Kecco scrive: per quanto riguarda il linguaggio
Kecco scrive: qualcuno conosce le differenze principali con java tradizionale
Piero Tofy scrive: io xD
Nophiq scrive: faresti prima a scaricarti dei sorgenti
Nophiq scrive: comunque Inca ho uno zip da passarti
Kecco scrive: mi dici dove posso trovarli
Kecco scrive: su cosa?
Nophiq scrive: ho trovato del materiale in generale su Java con Bluetooth ed interfaccia
Kecco scrive: vediamo
Piero Tofy scrive: ovviamente Nophiq ha pagato la licenza per distribuire l'e-book allegato e i relativi sorgenti
Piero Tofy scrive: lol
Nophiq scrive: te l'ho passato in privato
Nophiq dice: passiamo al prossimo argomento: l'invio e formattazione di messaggi
Nophiq dice: per sviluppare anche i filtri
Nophiq dice: avevo pensato a questo
Piero Tofy dice: ogni messaggio ha un ID
Nophiq dice: ogni utente che invia un messaggio (di qualsiasi natura)
Nophiq dice: contiene all'inzio
Nophiq dice: il proprio ID + il numero del messaggio
Nophiq dice: che l'utente ha inviato
Nophiq dice: per esempio il primo è 0001
Nophiq dice: il secondo 0002
Nophiq dice: e così via
Nophiq dice: in questo modo chi deve forwardare i messaggi deve innazitutto controllare l'intestazione
Nophiq dice: e se vede che ha già ricevuto quel messaggio
Nophiq dice: lo ignora
Piero Tofy dice: mm.. concordo sui punti tranne sul numero del messaggio
Piero Tofy dice: non si può usare un numero crescente
Piero Tofy dice: ma casuale
Nophiq dice: un attimo
Nophiq dice: il numero del messaggio è relativo
Nophiq dice: al cellulare che lo invia
Nophiq dice: nel senso che ogni cellulare ha un contatore personale
Nophiq dice: tanto quello che lo distingue dagli altri è l'ID
Nophiq dice: domande?
Piero Tofy dice: mm nu
Kecco dice: not
Kecco dice: a
Kecco dice: ogni messaggio non deve contenere anche il destinatario
Kecco dice: o i destinatari
Nophiq dice: ok perfetto il sistema di filtro è indispensabile per evitare che lo stesso messaggio circoli sulla rete bluenet all'infinito
Nophiq dice: sì certo Inca l'intestazione (ID+num) è solo la prima parte del messaggi
Nophiq dice: o
Kecco dice: come pensi di filtrare il messaggio
Nophiq dice: io pensavo di creare una seconda lista
Nophiq dice: contente il log dei messaggi che ha inviato/forwardato
Nophiq dice: però la sparo lì
Nophiq dice: qualcuno ha altre idee?
Kecco dice: si potrebbe usare una lista dei recapiti
Kecco dice: oppure
Kecco dice: contare il numero dei destinatari
Nophiq dice: come fai a saperlo se hai solo una lista a disposizione
Nophiq dice: e non i vari collegamenti
Nophiq dice: fra gli utenti
Kecco dice: già
Piero Tofy dice: la lista di messaggi inviati/forwardati è l'unica soluzione
Piero Tofy dice: che si puo' applicare a questo sistema
Nophiq dice: quello che dicevi tu l'avevo pensato anche io per il sistema Mappa
Piero Tofy dice: quindi va bene
Nophiq dice: perfetto
Kecco dice: ok
Nophiq dice: domanda: inseriamo anche un messaggio di ricevuta del messaggio?
Piero Tofy dice: essenziale
Nophiq dice: perfetto
Piero Tofy dice: quando il destinatario riceve il messaggio
Piero Tofy dice: (se lo riceve lol)
Piero Tofy dice: invia una conferma
Piero Tofy dice: in modo che chi l'ha inviato
Piero Tofy dice: possa sapere se è arrivato a destinazione
Nophiq dice: ok
Nophiq dice: allora direi che abbiamo parlato di tutto. Domande/Suggerimenti?
Piero Tofy dice: posso tornare a dormire?
Piero Tofy dice: lol
Kecco dice: no
Nophiq dice: un'altra cosa
Nophiq dice: Piero dove posso trovare un programma libreria?
Nophiq dice: o qualcosa del genere
Piero Tofy dice: aww... non ho idea. Comunque una libreria è in sostanza un normale programma dove non c'è un Main, ma solo una raccolta di funzioni
Piero Tofy dice: che poi vengono richiamate da un programma vero e proprio
Nophiq dice: ma scusa un attimo
Piero Tofy dice: non è una DLL eh....
Piero Tofy dice: in Java nun si può
Nophiq dice: quindi bisogna che il sistema di Chat sia il programma di base
Piero Tofy dice: zi
Nophiq dice: nel senso che
Nophiq dice: se vuoi avviare dopo uno sparattutto (per esempio) la Chat si trasforma in uno sparatutto
Piero Tofy dice: zi
Nophiq dice: oki
Nophiq dice: allora
Nophiq dice: come obiettivo del mese
Nophiq dice: - Conoscere struttura del progetto (presentato nella riunione)
Nophiq dice: - Inizio sviluppo software
Nophiq dice: direi che vada bene così
Piero Tofy dice: yup
Nophiq dice: praticamente a questo punto
Nophiq dice: ci saranno due gruppi
Nophiq dice: io che svilupperà l'architettura e l'altro che svilupperà la grafica
Nophiq dice: visto che dovrà trasformarsi nei vari programmi
Nophiq dice: alla suddivisione dei gruppi ci penserò io
Nophiq dice: ognuno del team prima dell'assegnazione dei compiti
Nophiq dice: contatterò ognuno...
Nophiq dice: aspettate aggiornamenti nel forum
Nophiq dice: la riunione si aggiorna
| 
