Da sempre, vicini

Da sempre, vicini


Interminabile la nostr'attesa,
obbligata distanza duratura
ha fermentato ancor più di prima
il desiderio e la certezza
d'un intreccio a maglie strette,
un ricco ricamo variopinto
che sulla tela della nostra vita
prende forma mostrando l'armonia
di ciò ch'assieme siamo e saremo.

Ritrovo, abbraccio, le pennellate
d'un rosso vivo or ci dipingono
su uno sfondo rosa permanente;
coricati in un campo di grano
ammirando l'orizzonte aperto:
scorgiamo serena retta linera
ch'immersi c'accompagnerà entrambe
fra carezze d'oro e alto cielo.


Gabriele Lombardi

Side effects in Matlab

Come tutti i "matlabbisti" sanno, in Matlab l'assegnamento ed il passaggio dei parametri è virtualmente per copia, ovvero virtualmente ogni volta che si assegna una variabile ad un'altra o che si passa una variabile a una funzione questa viene copiata per intero in maniera tale da non avere side effects. In pratica ovviamente non viene sempre fatta la copia: viene utilizzata una politica di lazy-evaluation sulle copie in maniera da utilizzare la variabile originale fin tanto che non vengono fatte modifiche e di copiarla in una nuova variabile solamente a fronte di una richiesta di modifica della stessa (questo solamente per una questione di efficienza).

Ma è possibile ottenere in Matlab i side effects?

Ovviamente è possibile ottenerli utilizzando Java o creando MEX-files in C o in FORTRAN. E' però possibile ottenere i side effects anche in Matlab puro sfruttando i workspaces temporanei creati durante le chiamate a funzione. Nel post Programmare OOP in Matlab è stato spiegato come costruire una classe in Matlab utilizzando solamente le funzioni. Ora, si ipotizzi di istanziare la classe counter, descritta in quel precedente post, e crearne una copia come segue:

c1 = counter(1); % Istanziazione:
c2 = c1; % Copia:

Ora l'oggetto c1 e l'oggetto c2 sono esattamente lo stesso oggetto. Le modifiche su uno hanno side effects sull'altro, infatti:

c1.next()
ans = 1
c2.next()
ans = 2
c1.next()
ans = 3
c2.next()
ans = 4

Inoltre realizzando una funzione come la seguente:

function incrementa(c)
c.next();

E richiamandola come segue:

c =counter(1);
incrementa(c);
incrementa(c);
c.next()
ans = 3

E' possibile appurare che l'oggetto passato alla funzione può essere modificato dall'interno della stessa generando side-effects.

SPIEGAZIONE: Le classi realizzate come spiegato nel post precedente sfruttano la creazione di un workspace locale (WL) per ogni chiamata a funzione Matlab, quando una funzione Matlab viene richiamata un workspace temporaneo viene creato ex-novo in cui "vivono" le variabili locali della funzione, alla terminazione dell'esecuzione tale WL viene lasciato in pasto al garbage collector che normalmente lo rimuove, nel caso però in cui vengano restituiti i puntatori a funzioni innestate, che possono quindi accedervi, il WL non viene rimosso perchè esistono ancora delle variabili che vi possono accedere. Il WL viene eliminato quando anche l'oggetto istanziato diviene irraggiungibile. A differenza delle normali variabili però il WL è legato all'istanza dell'oggetto in maniera indiretta, non fa parte della variabile, questo significa che copiare la variabile non copia il WL. L'oggetto rappresenta in maniera indiretta un puntatore al WL, passare quindi questo "puntatore" a una funzione o copiarlo non provoca la replica del WL che rimane lo stesso e soffre quindi dei side-effects.

Questo comportamento non deve essere visto come un "baco" ma come una "feature": infatti è un modo efficace per ottenere i side-effects quando e se servono.

Ovunque

Ovunque


Stupendi luoghi, che ci circondano,
sanno attarr'attenzione per poco:
sbalordit'osserviamo, sentiamo
l'arte con ogne brandello d'anima.

Fra imponenti volte, capitelli,
dipinti e sculture, chiese, ponti,
vasti sentieri lungo freschi boschi,
scintillanti laghi, montagn'e mari;

in tutto questo, aprendo i sensi,
non possiamo che scorger noi stessi:
opera d'arte certo non umana,
che più ci scalda, tanto da sciogliere.

Distanti; ovunqu'io poss'andare,
ricordo fatti, medito sorprese,
vedo 'l tuo viso, cerco tuoi occhi:
ovunque, dentro me, ci sei sempre tu.


Gabriele Lombardi

Fluttuazioni

Fluttuazioni


L'onda,
piatta ma grintosa,
in vista delle rive,
si gonfiava maestosa
e troppo sicura di sé.

La spuma sorrideva,
correva veloce nel vento;
senza accorgersene
finalmente raggiungeva
l'agognata bianca meta.

Improvviso il crollo,
spariva l'acqua sotto i piedi:
parte di se veniva a mancare,
ciò che la componeva, mischiata,
l'abbandonava tradendo sicurezza.

Riflusso silenzioso
trasportava nuovamente,
nell'oceano tumultuoso,
disgregate parti
per restituire vigore pieno.

Altra meta, quella giusta,
sà meglio accogliere:
onda splendente, gioiosa;
scorgendoci, d'istinto,
ci siam corsi incontro.

Fluido, armonioso scontro
d'imponenti masse,
ch'impazienti son mischiate
in ogni minima goccia:
profondo abbraccio.


Gabriele Lombardi

C++: se lo conosci non ti uccide...

...e io stavo per rimanerci secco!!! ;)

Posto questo post (scusate la cacofonia) per gli "ignoranti" come me che ignorano.. o semplicemente dopo anni non si ricordano più.. della seguente "finezza" del C++.. che tanto fine non è in realtà: in C++ alla creazione di un oggetto i costruttori vengono richiamati dalle classi base alle classi derivate in catena secondo l'ordine con cui sono dichiarati nella sintassi del costruttore dopo l'operatore ':'. I distruttori invece vengono richiamati automaticamente in ordine inverso (notare, in ordine inverso anche rispetto a strani ordinamenti nel grafo aciclico ottenibile tramite l'ereditarietà multipla).
A parte il discorso del chaining, che ai più è noto, la finezza sta nelle operazioni che possono essere svolte all'interno dei costruttori e dei distruttori: chi di voi per caso volesse utilizzare il noto pattern "Abstract method" se lo scordi pure perchè all'interno di costruttori e distruttori non è possibile richiamare metodi virtuali puri relativi alla classe stessa, nemmeno se si ha a che fare con l'istanza di una classe derivata che li implementa concretamente. In sostanza niente "Abstract method" all'interno di costruttori e distruttori.. vi lascio un pezzettino piccolo piccolo di codice con cui giocare.

// The abstract superclass:
class A {
public:
// The constructor:
A() {
// Try to call but cannot dispatch:
virtualMethod();
}
// The virtual pure method:
virtual void virtualMethod()=0;
};

// My subclass
class B : public A {
public:
// The implementation:
virtual void virtualMethod() {};
};

// Using them:
int main(int argc, char *argv[]) {
// Instantiating:
B b;
b.virtualMethod();
return 0;
}