/* Non ho capito che cosa aveva in mente..
   né ho voglia di capirlo! o_O
*/

[01:48] <r41n80w> cazzuola...come si fà un prog in ASM che ti genera numeri random per almeno 2 o 3 
  orette e...
[01:48] <^Spider^> mmm
[01:48] <^Spider^> la difficoltà sta nei random o nelle 2 orette? =)
[01:48] <r41n80w> entropicamente parlando (ma che cazzo dico?)..produce alta entropia?
[01:48] <r41n80w> e...
[01:48] <active85k> :D
[01:48] <r41n80w> un pò tt e due
[01:48] <r41n80w> facciamo le
[01:49] <r41n80w> 2 orette prima come si fà un loop serio?
[01:50] <r41n80w> prendo un comando a caso e calcolo quanto impiega il micro per eseguirlo..poi
[01:50] <r41n80w> divido questo comando..prob il più lungo pos per 2 ore?
[01:50] <r41n80w> :-???
[01:50] <active85k> guarda...
[01:50] <active85k> io direi
[01:51] <active85k> di stabilire direttamente
[01:51] <active85k> un processo intercomunicativo
[01:51] <active85k> tra il comando e il processore
[01:51] <active85k> e tra il processore e l'utente
[01:51] <active85k> mi sembra la strada migliore
[01:51] <active85k> alla fine con una polisincronizzazione delle istruzioni nel thread
[01:51] <active85k> puoi farlo tranquillamente
[01:52] <r41n80w> bene..mi suicido!
[01:52] <active85k> dai nn è difficile
[01:52] <active85k> basta che utilizzi le caratteristiche binarie delle istruzioni
[01:52] <active85k> se prendi un'istruzione e la dividi in tanti bit quanti sono i secondi di un'ora
[01:53] <r41n80w> si
[01:53] <active85k> puoi eseguire un bit per ogni secondo
[01:53] <active85k> così alla fine dell'ora hai eseguito l'intera istruzione
[01:54] <active85k> non trovi che sia il modo + semplice?
[01:54] <r41n80w> non tanto
[01:54] <active85k> hmm.. eppure credo sia la strada migliore
[01:54] <r41n80w> io pensavo di fare dei loop
[01:54] <active85k> no spido?
[01:54] <active85k> dei loop? ammazza e quanto processore consumi
[01:54] <active85k> per qualche istruzione? :\
[01:55] <r41n80w> io
[01:55] <r41n80w> devo
[01:55] <r41n80w> fare in modo che il processore lavori
[01:55] <r41n80w> il più possibile!
[01:55] <^Spider^> in effetti i loop consumano pareccio :/
[01:55] <active85k> beh
[01:55] <active85k> allora se devi farlo lavorare il + possibile
[01:55] <active85k> ti consiglio
[01:55] <r41n80w> si
[01:55] <active85k> di fargli fare qualche divisione
[01:55] <active85k> cn parekkie cifre decimali
[01:55] <active85k> alla fine se gli mandi
[01:56] <active85k> tante divisioni
[01:56] <active85k> lo tilti..
[01:56] <r41n80w> mmmh..nooo
[01:56] <active85k> la divisione è l'operazione + complessa delle 4
[01:56] <r41n80w> no tilt
[01:56] <active85k> e che vuoi fare?
[01:56] <r41n80w> si divisione si
[01:56] <r41n80w> nel frattempo deve calcolare
[01:57] <r41n80w> una formula e..il risultato
[01:57] <r41n80w> lo deve restituire al termine delle 2 o 3 ore
[01:57] <active85k> cazz.. guarda che è un lavoro assurdo.. nn so se un processore intel ce la fa..
[01:57] <active85k> o se ce la fa penso che ci mette 2 giorni nn due ore..
[01:57] <r41n80w> io ho un amd..
[01:57] <r41n80w> :-)))
[01:57] <r41n80w> che scemo
[01:57] <active85k> un amd? noooooo! come fai scusa.. stressi troppo il coprocessore matematico!
[01:58] <^Spider^> ci vuole un buon dissipatore però
[01:58] <active85k> riski di fondere!
[01:58] <active85k> :\
[01:58] <^Spider^> altrimenti puoi surriscaldare il processore
[01:58] <active85k> eh.. appunto..
[01:58] <active85k> + che dissipatore suggerirei un impianto di raffreddamento a liquido
[01:58] <r41n80w> sicuro ?
[01:58] <active85k> li ho visti ma kissà quanto costano
[01:58] <active85k> skerzi r41n80w?
[01:58] <active85k> parli di operazioni accavallate a 32 bit cn nessuno scarto!
[01:58] <r41n80w> ne vale la pena però!
[01:58] <active85k> eh appunto
[01:59] <r41n80w> se intanto tra oggi e domani
[01:59] <r41n80w> preparo il prog qualcuno
[01:59] <active85k> o_O tra oggi e domani? sei un genio!
[01:59] <r41n80w> eventualmente ci darebbe un occhiata?
[01:59] <active85k> ma skerzi!
[01:59] <active85k> lo guardo subito io!
[01:59] <r41n80w> ???
[02:00] <r41n80w> perche tu quanto ci metteresti?
[02:00] <DJK> notte all!
[02:00] <active85k> beh per fare una cosa così complessa fatta bene, rispettando un fattore di 
  compressione dei processi in memoria come si deve..
[02:00] <r41n80w> il devo solo fare una parte
[02:00] <active85k> circa un mese
[02:00] <r41n80w> che mi calcola delle frequenze relative sui numeri
[02:00] <r41n80w> poi quella dei loop
[02:01] <active85k> ghhg
[02:01] <r41n80w> e poi quella dell'entropi..ma..
[02:01] <active85k> azz..
[02:01] <active85k> vuoi scrivere
[02:01] <active85k> un analizer per un'entropia?
[02:01] <active85k> cazz.
[02:01] <active85k> se vuoi un mio parere
[02:01] <r41n80w> no...
[02:01] <active85k> non riskierei..
[02:01] <r41n80w> quello è facile
[02:01] <r41n80w> meglio con
[02:01] <active85k> vabè ma hai sempre a che fare cn lìentropia
[02:02] <active85k> riski di fondere la ram e il bios
[02:02] <r41n80w> un linguaggio ad alto livello..ma una via di mezzo
[02:02] <r41n80w> non fà nulla..il mio pc è un pallottoliere
[02:02] <active85k> beh
[02:02] <active85k> almeno
[02:02] <r41n80w> Mark-one :-)
[02:02] <active85k> io utilizzerei
[02:02] <active85k> un linguaggio
[02:02] <active85k> a bassissimo livello
[02:02] <active85k> in modo
[02:03] <active85k> da ottimizzare al massimo.
[02:03] <active85k> altrimenti
[02:03] <active85k> il processore fonde sul serio :\
[02:03] <active85k> ti suggerirei di scriverlo direttamente in codice binario
[02:03] <active85k> è da prendere sul serio l'idea
[02:03] <active85k> :\
[02:03] <r41n80w> secondo me lo stressi meno con uno ad alto livello...perche
[02:03] <r41n80w> se ottimizzi tutto nn è peggio?
[02:04] <active85k> no ti stressi di meno tu perché è + semplice ma le elaborazioni sn + complesse
[02:04] <active85k> eh no..
[02:04] <active85k> tanto guarda
[02:04] <active85k> la cosa importante
[02:04] <active85k> è scrivere un controllo dell'orologio di sistema
[02:04] <active85k> però
[02:04] <active85k> se lo fai
[02:04] <active85k> ad alto livello
[02:04] <active85k> il compilatore
[02:04] <active85k> ci mette dentro roba
[02:04] <active85k> a mio avviso inutile
[02:04] <active85k> che appesantisce di parekkio
[02:04] <r41n80w> vero
[02:04] <active85k> l'interscambio dei dati tra i registri
[02:04] <active85k> caput?
[02:05] <active85k> quanto meno.. potresti tentare di farlo cn un hard disk scsi..
[02:05] <active85k> ma io non riskierei di bruciare un controller..
[02:05] <active85k> secondo me in codice binario è la soluzione migliore
[02:05] <r41n80w> !!!in che senso?
[02:06] <active85k> ti spiego
[02:06] <active85k> al posto di scrivere le istruzioni mnemoniche
[02:06] <active85k> per ogni istruzione
[02:06] <active85k> ti conviene
[02:06] <active85k> risalire al suo codice binario
[02:06] <active85k> e scrivere direttamente quello
[02:06] <r41n80w> ok
[02:06] <active85k> fai un po' + di fatica
[02:06] <active85k> ma alla fine
[02:06] <active85k> ottieni un risultato
[02:06] <active85k> sbalorditivo
[02:06] <active85k> e, credimi, ne vale davvero la pena
[02:06] <active85k> ;)
[02:06] <r41n80w> cosi mi ci vuole un mese
[02:06] <active85k> no..
[02:06] <active85k> se ti fai uno skema
[02:06] <active85k> come si deve
[02:07] <active85k> e ti costruisci un bell'albero skematico
[02:07] <active85k> vedi subito dove piazzare il codice
[02:07] <active85k> alla fine diventa automatico
[02:07] <active85k> e fai anche un ottimo esercizio che nn fa mai male :=
[02:07] <active85k> :)
[02:07] <active85k> e poi
[02:07] <active85k> c'è da dire
[02:07] <active85k> che nessuno riuscirà a modificare il tuo codice :)
[02:07] <active85k> sarà troppo compatto e ottimizzato
[02:07] <active85k> per chiunque
[02:08] <active85k> a me viene la pelle d'oca solo a pensare
[02:08] <active85k> ..
[02:08] <r41n80w> ok...ma poi mi correggi tu il code?
[02:08] <active85k> beh.. si magari dopo gli esami
[02:08] <active85k> posso correggerlo io..
[02:08] <active85k> sempre se mi lasci qualche buco per capirlo ^^
[02:08] <r41n80w> quali?
[02:09] <r41n80w> esami?
[02:09] <r41n80w> hai?
[02:09] <active85k> maturità
[02:09] <active85k> ma nn pensarci
[02:09] <active85k> se no mi fai sentire male :D
[02:09] <Ntoskrnl> rain ecco lasciagli il tuo buco
[02:09] <Ntoskrnl> tanto a active interessa quello
[02:09] <active85k> :D
[02:09] <active85k> come mai sei intervenuto quando si parla di buchi? :D
[02:10] <Ntoskrnl> eh guarda state parlando voi
[02:10] <Ntoskrnl> mica io
[02:10] <active85k> cmq rain
[02:10] <active85k> l'idea è davvero bella
[02:10] <Ntoskrnl> io facevo solo notare le tue intenzioni
[02:10] <active85k> :)
[02:10] <r41n80w> vado a tirare giù un diagramma di flusso
[02:10] <active85k> si nt ci siamo :D
[02:10] <master^shadow> behehe :)
[02:10] <active85k> OTTIMO!
[02:10] <active85k> con un diagramma di flusso
[02:10] <active85k> sei a cavallo!
[02:10] <r41n80w> ok
[02:10] <active85k> ottima scelta!
[02:10] <r41n80w> allora a dmn
[02:11] <r41n80w> (io la vedo brutta)
[02:11] <active85k> ok
[02:11] <active85k> mi raccomando
[02:11] <active85k> il diagramma
[02:11] <r41n80w> Buona notte a tutti
[02:11] <active85k> per interpolazione
[02:11] <r41n80w> si
[02:11] <active85k> se no coi bit
[02:11] <active85k> non si capisce neanche quello
[02:11] <active85k> ok?
[02:12] <r41n80w> no..ho
[02:12] <r41n80w> un mio metodo anche per
[02:12] <r41n80w> quello..allo stesso
[02:12] <active85k> ..cazz... ma cosa sei?
[02:12] <active85k> un genio?
[02:12] <active85k> una makkina?
[02:12] <active85k> una lampada? o_O
[02:12] <r41n80w> modo di come suono il basso..
[02:12] <r41n80w> il pentagramma è troppo brutto
[02:12] <active85k> hehehe
[02:13] <r41n80w> cosi anche i diagrammi vanno
[02:13] <r41n80w> speriamo bene! Ciao Grazie
[02:13] <r41n80w> a domani
[02:13] * r41n80w has quit IRC (Quit: )
[02:13] <active85k> HAAAAAAAAAAAAAAAAAAAAAHAHAHAHAHAHAHAHA
End of #crack-it buffer    Sun Jun 20 02:15:12 2004