[Python] Dubbi organizzazione progetto

[enrico franchi]

On Nov 25, 2007 3:11 PM, Mr. SpOOn <mr.spoon21 a gmail.com> wrote:

> Quando dici due oggetti intendi due classi, no?

No. Nella fattispecie intendo due oggetti. Questi saranno istanze di
due classi. Il punto è che al limite l'encoder e il decoder potrebbero
anche essere funzioni. Sono rispettivamente aggeggi cui passi il
messaggio iniziale e lui te lo encoda e l'altro è quello che prende il
messaggio trasmesso e lo decodifica

Come ti ho mostrato questi oggetti possono essere 'composti' dentro la
classe Channel (nel qual caso intendi un canale con già capacità
'estese' di codifica e decodifica) oppure un canale 'ridotto' (cui
passi i messaggi già encodati e il cui risultato viene lavorato poi
dal decoder.

Io sono un matematico e non un ingegnere telecom, ma generalmente il
'canale' non ha proprietà di codifica e decodifica (visibili
dall'esterno, se è roba sua, fatti suoi). Per cui il design più pulito
che vedo è quello che non 'setta' encoder e decoder. Questo sulla base
di una mia comprensione limitata e teorica della materia (teoria
dell'informazione ne ho fatta, ma più da un punto di vista matematico,
appunto, che ingegneristico).

Tuttavia l'ingegnere del software che è in me vede la soluzione in cui
usi i setEncoder e compagnia come più pragmatica e comoda da
programmare. Questo ammesso (e non concesso) che tu voglia avere
encoder e decoder 'pluggabili'. Per esempio per fare vedere che se
spari dentro il canale rumoroso una cosa compressa con huffman puro
(per dire) quello che esce è spazzatura (mi aspetto), se invece
reintroduci della ridondanza, ricostruisci il messaggio.

Direi che è un design ragionevole per giochinare con i codec. E'
quindi un design in qualche modo conscio dell'implementazione
ragionevole delle cose.

Nulla ti vieta di avere un NoiseChannel che mette solo il rumore e un
più generico Channel che contiene il NoiseChannel e ha i famosi
setEncoder e compagnia.

> In effetti adesso con una classe Channel mi si risolvono un po' di
> problemi, credo.

I think so. :)

> Posso usarla per gestire degli oggetti che servono durante tutto il
> processo, come ad esempio il messaggio codificato e il tipo di
> codifica scelto.

Ah, io direi no. Il canale fa *una* cosa. Simulare il rumore e basta.
Il tipo di codifica la sanno la coppia encoder-decoder. Che in uno dei
due design sono messi pure dentro il canale, quindi in questo senso
si, vediamo il canale in modo esteso e amen.

> Quindi penso di definire il metodo che codifichi il messaggio
> all'interno della classe Encoder.

Attenzione, l'encoder potrebbe anche essere una funzione. Molto più pratico.
A questo punto se è un'istanza di una classe custom usi __call__ e hai
un oggetto function-like.

> Questo metodo lo chiamo dalla classe
> principale Channel (in un altro metodo tipo setEncodedMessage) che
> andrà a modificare il valore di encodedMessage presente in Channel.

Non mi piace vederla così. Per me un canale è un oggetto dove la roba
*passa*. Usare un concetto di 'setMessage' mi piace davvero poco. Un
canale non è una scatola: è un tubo. Io userei proprio read e write.
In primo luogo lo rendono un oggetto file like (il che non guasta), in
secondo luogo rendono bene l'idea.

Dentro il NoiseChannel avrai una lista che tiene i messaggi (gestita
come una coda). E poi resta da decidere se prendi il messaggio pulito
e lo sporchi quando lo tiri fuori dalla coda perchè te lo hanno
chiesto oppure se sporchi appena ti entra un messaggio, lo salvi in
coda sporco e lo tiri fuori (ovviamente così come è).


Io farei qualcosa di simile a questo (con i due noise channel che
mostrano due diverse implementazioni incomplete):

class NoiseChannel_1(object):
	def write(self, message):
		fuzzed_message = self.fuzz(message)
		APPEND(fuzzed_message)
		
	def read(self):
		return POP_FRONT()
		
class NoiseChannel_2(object):
	def write(self, message):
		APPEND(message)

	def read(self):
		return self.fuzz(POP_FRONT())
		
		
class Channel(object):
	encoder       = property(...)
	decoder       = property(...)
	noise_channel = property(...)
	
	def __init__(self, noise_channel, encoder, decoder):
		self.encoder = encoder
		self.decoder = decoder
		self.noise_channel = noise_channel
		
	def write(self, message):
		self.noise_channel.write(self.encoder(message))
		
	def read(self):
		return self.decoder(self.noise_channel.read())

Nota che il codice sopra non è testato, non è manco valido
sintatticamente forse (e certamente non semanticamente). E' una
traccia che ho scritto in pseudo-Python per motivi di rapidità.

-- 
-enrico