“Il vostro nemico è Mario Monti”

“Il vostro nemico è Mario Monti. E’ un traditore della nazione italiana, dovrebbe essere messo in prigione”
lo dice Daniel Estulin, ma già lo pensano tutti gli italiani, ad eccezione dei politici ed industriali conniventi (che certamente hanno il loro tornaconto personale, dato che in Italia sono tutti corrotti).

Daniel Estulin ha parlato nel programma tv “L’ ultima parola” condotto da Gianluigi Paragone:

Estulin è autore del libro Il Club Bilderberg, in cui riporta 15 anni di indagini:

La minaccia che l’umanità di oggi si trova ad affrontare proviene dall’usurpazione del potere da parte di leader di terrorismo finanziario; la folle fase finale di un progetto che dura da secoli e si propone di neutralizzare lo sbalorditivo successo delle conquiste del Concilio di Firenze del 1439-1440, che aveva provvisoriamente riunificato i riti orientali e occidentali della Chiesa cristiana.

La dettagliata opera di Estulin dimostra come il Club Bilderberg sia stato coinvolto nei maggiori misteri della storia recente, dal Piano Marshall allo scandalo Watergate e come in questa élite emergano le figure chiave dello scacchiere internazionale, presidenti USA, direttori di agenzie come CIA o FBI, vertici delle maggiori testate giornalistiche. Estulin colpisce questa organizzazione proprio dove fa più male: la priva della segretezza, della discrezione e dell’ombra di cui si è sempre servita e di cui necessita per attuare i suoi piani.

Non è difficile collegare queste affermazioni a testate come “la repubblica” che dal lontano 1994 bombarda i cervelli (che da parte loro sono purtroppo eccessivamente recettivi) di certe persone con notizie costruite ad arte, giornalaccio collegato ad un imprenditore ambiguo come debenedetti che è in guerra aperta contro Silvio Berlusconi che gli ha messo i bastoni fra le ruote in più di un’ occasione: prima con il caso SME, guardacaso anche contro un elemento sospetto come Prodi (invischiato nella lista Mitrokhin, nella commissione europea, nelle svendite di risorse italiane, in politiche sciagurate, ecc….), poi con la sua discesa in politica che ha portato ad attacchi unilaterali da parte della repubblica (il giornale!) e debenedetti sfociati poi nella sentenza Mondadori (con la complicità di una “giustizia” sempre meno indipendente).
Fa riflettere anche il successivo “passo indietro” di Berlusconi per lasciare il postoal delinquente mario monti: forse in cambio di tutele giudiziarie ? Infatti proprio oggi 27 ottobre 2012 Berlusconi reagisce alla condanna per i fondi neri Mediaset con un ritorno in politica contro la UE e monti. Un caso ? Secondo me, no: troppi punti di contatto con le vicende sopra descritte.

Incapsulazione con Javascript

Definizione diretta di classi

http://www.dafishinsea.com/blog/2012/02/23/encapsulation-in-javascript/

Introduzione

Per prima cosa bisogna tenere conto che javascript è “function scoped”: una variabile è visibile ovunque all’ interno della funzione in cui è definita, anche all’ interno delle funzioni che sono definite nello stesso scope. E’ la proprietà delle closures.

Altra cosa importante da ricordare è che javascript non ha le “classi”, ma funzioni “costruttore”:
quando si istanzia un oggetto con new viene chiamata la funzione costruttore dell’ oggetto, con this impostato sul prototype. Questo non è altro che un oggetto Object vuoto, ma è possibile dichiarare delle proprietà:

Dog.prototype = {
        bark: function () { }
}
dog = new Dog();
dog.bark() // viene chiamata la funzione

Incapsulazione delle variabili

Definendo una proprietà all’ interno di una funzione si ha una variabile privata; per renderla disponibile all’ esterno si definisce un metodo privilegiato:

function Dog (name) {
// la variabile name è definita come in "var name"
    this.getName = function () { return name; }
}

var fido = new Dog("Fido");
console.log(fido.getName());  //"Fido"
console.log(fido.name);       //undefined

Per definire una variabile privata che non sia un argomento del costruttore, basta dichiararla nel costruttore:

function Dog (name) {

    var age = 0;

    this.getName = function () { return name; }
    this.getAge = function () { return age; }

    //example of setter:
    this.setAge = function (newAge) { age = newAge; }
}

Si può operare in questo modo per tutte le variabili e funzioni private che si vuole, ma sorge un problema di efficienza: ogni volta che il costruttore viene chiamato (quando si istanzia un oggetto) le funzioni vengono ricreate sprecando memoria.

Prevenire lo spreco di memoria

Una soluzione al problema, non definitiva, dato che qualche funzione deve essere pur sempre ricreata, è quella di definire le variabili private con i loro getters/setters (solitamente leggeri) nel costruttore, e poi aggiungere nel prototype i metodi pubblici che fanno uso dei getters/setters: in questo modo si mantiene la protezione dei dati incapsulati e si beneficia dell’ ereditarietà prototipale.

In questo caso, bisogna ricordare di richiamare esplicitamente il costruttore del prototipo:

function Daschund(name) {
    //...
    Dog.call(this, name);
}

Daschund.prototype = new Dog();

Metodi privati

Vengono definiti nel costruttore:

function Dog (name) {

    var age = 0;

    //private function
    function scratch() { console.log("scratch"); }

    this.getName = function () { return name; }
    this.getAge = function () { return age; }

    //example of setter:
    this.setAge = function (newAge) { age = newAge; }
}

La principale limitazione delle funzioni così dichiarate è che sono disponibili nella funzione contenitrice (il costruttore), ma non sono visibili dalle funzioni prototipali.
Per accedere a simli funzioni private si potrebbero dichiarare i metodi pubblici nel costruttore, ma perderemmo i benefici di prototype.

Un sistema per superare questa limitazione è quello del module pattern: definire il costruttore e prototype all’ interno di una funzione closure che contenga anche le funzioni private.
Ma bisogna fare attenzione: i metodi nel modulo sono statici.

Incapsulazione con classe proxy

http://effprog.blogspot.it/2011/10/compact-and-efficient-javascript.html

function class(options){
    var     constructor = options.constructor,
        public = options.public,
        private = options.private,
        key;
        

    function hiddenClass(){}

    var hp = hiddenClass.prototype = {};

    function publicClass(){
        var obj = new hiddenClass();
        constructor && constructor.apply(obj, arguments);
        Object.defineProperty(this, 'obj', {value : obj});
    }

    var pp = publicClass.prototype = {};

    for(key in private){
        if(private.hasOwnProperty(key)){
            hp[key] = private[key];
        }
    }    

    for(key in public){
        if(public.hasOwnProperty(key)){
            var val = public[key];
            hp[key] = pp[key] = val;

            if(typeof val === 'function'){
                pp[key] = function(){
                    return hiddenClass.prototype[key].apply(this.obj, arguments);
                }    
            }
        }        
    }

    return publicClass;
}
/*
 * Esempio
 */
var c = class({
    
    constructor : function(a, b){
        this.a = a;
        this.b = b;
    },

    private: {
        helpMe : function(){
            console.log(this.a);
        }    
    },

    public: {
    
        c : 30,
        help : function(){
            console.log('Hello');
        },
        print : function(){
            this.help();
            this.helpMe();
            console.log(this.b);
            console.log(this.c);
        }
    }

});

var o = new c(10, 20);

o.print();

Javascript: proprietà delle tabelle HTML

Ecco un elenco di proprietà appartenenti agli oggetti HTML che riguardano le tabelle.

Un elemento table, insieme agli elementi thead e tbody, è un contenitore di elementi tr: la proprietà rows viene inizializzata come array di riferimenti agli oggetti tr contenuti.

Analogamente, le righe sono dei contenitori di elementi td: i loro riferimenti sono contenuti nella array cells dell’ oggetto tr.
La proprietà rowIndex contiene la posizione della riga; bisogna fare attenzione all’ header: anche questo è un tr, e quindi è identificato da tbody.rows[0] e il suo rowIndex è posto a 0; di conseguenza, le righe dei dati della tabella partono da 1.
Ma se l’ header manca, allora anche le righe dei dati partono da 0.

Infine, l’ elemento td: la sua proprietà cellIndex contiene la sua posizione nella riga partendo da 0.
Il testo contenuto da td può essere modificato o tramite innerHTML (da alcuni deprecato), o con i comandi javascript per accedere al nodo di testo figlio, o ancora con la proprietà textContent.

Ricette con scampi e patate

Gnocchetti di patate con scampi

http://www.atavolaweb.it/ricette/portata/primi/item/gnocchetti-di-patate-con-scampi.html

  • Preparazione: 40 minuti
  • Cottura: 65 minuti
  • Persone: 4
  • Difficoltà: Media
  • Calorie per porzione: 478

Ingredienti

PER GLI GNOCCHI:
600 g di patate
80 g di farina tipo “00”
1 uovo

sale
PER IL SUGO:
800 g di scampi freschi
300 g di pomodori ramati
1 bicchierino di vodka secca
una manciata di origano fresco
olio extravergine di oliva
peperoncino macinato
1 spicchio di aglio
1 rametto di prezzemolo
sale

Preparazione

Per gli gnocchi, far bollire le patate per 30 minuti, sbucciarle ancora calde, passarle nello schiacciapatate e poi impastarle con la farina, l’uovo e 1 cucchiaino di sale; infine stendere l’impasto e tagliarlo a pezzettini fino a formare dei piccoli gnocchetti; tenere in frigorifero.

Per il sugo, sgusciare gli scampi; cuocere i pomodori a vapore per 10 minuti, togliere la pelle e tritare nel mixer la polpa; far soffriggere 3 cucchiai di olio con l’aglio tritato, aggiungere gli scampi puliti, far cuocere per 3 minuti e poi sfumare con la vodka e lasciarla evaporare a fiamma viva.

Unire la polpa di pomodoro frullata, un pizzico di sale e di peperoncino e l’origano fresco; far cuocere per circa 15 minuti fino a quando il sugo si sarà addensato.

Cuocere gli gnocchi in abbondante acqua salata e scolarli con un mestolo forato quando vengono a galla; trasferirli direttamente nella padella del sugo e farli mantecare per pochi minuti; servire subito aggiungendo un pizzico di prezzemolo tritato.

Tortini di patate e gamberi

http://www.cucinaricette.org/tortini-di-patate-e-gamberi/

Ingredienti (per 6 persone)

  • 4 patate di media grandezza
  • 600 g di gamberi sgusciate
  • 1 cipolla
  • 1 mazzetto di erba cipollina
  • Latte
  • Farina
  • 150 g di burro
  • Sale e pepe q.b.

Preparazione

Lessate le patate, sbucciatele e tagliatele a pezzi. Prendete uno schiacciapatate e schiacciatele facendo cadere il purea in una terrina piuttosto grande. Su di un tagliere sminuzzzate la cipolla, prendete una padella antiaderente e fate appassire la cipolla tritata in un cucchiaino di burro.
Lavate i gamberetti sotto acqua corrente, asciugateli e tritateli poi grossolanamente. Prendete la terrina con il purea di patate, unitevi la cipolla rosolata e l’erba cipollina tagliuzzata. Aggiustate di sale e pepe nella quantità desiderata, aggiungete poi il latte fino ad ottenere un composto omogeneo. Amalgamate per bene gli ingredienti e lasciate raffreddare.
Dividete il composto in sei porzioni e con le mani umide formate dei tortini non troppo spessi. Passate uniformemente i tortini nella farina e friggeteli poi nel burro spumeggiante fino a quando saranno dorati da entrambe le parti. Servite i tortini caldi.

Ròsti di patate e gamberetti

http://buongustaio.over-blog.it/article-tortino-di-rosti-di-patate-e-gamberetti-51581233.html

Ingredienti (per 4 persone)

  • 400 gr. di patate
  • 1 cipollotto
  • guanciale
  • 3 uova
  • panna liquida
  • 1 confezione da 300 gr. di gamberetti surgelati
  • olio extravergine di oliva
  • 100 gr. di guanciale
  • sale e pepe.

Preparazione

Lavate e asciugate le patate, sbucciatele e grattugiatele con la grattugia a fori larghi. In una padella antiaderente con 4 cucchiai d’olio, fate ammorbidire il cipollotto tagliato finissimo, aggiungte le patate grattugiate e fatele cuocere per alcuni minuti, aggiustando di sale e pepe. Unite i gamberetti scongelati, lavati e asciugati. Fateli insaporire al composto, infine aggiungete il guanciale tagliato a dadolini piccoli. Fate una sorta di tortino e compattatelo bene. Versate dentro 3 uova sbattute con un cucchiaio di panna liquida e fate rassodare e rosolare da entrambe le parti. Rigirate il tortino, aiutandovi con un piatto. Servite caldo o tiepido con Falanghina Campana.

Pasta al nero di seppia

Sciacquate tutte le seppie così pulite e tagliatele a quadretti o a listarelle.
In una padella capiente mettete l’olio e aggiungete l’aglio e lo scalogno tritati, quindi a fuoco basso, fate diventare trasparente lo scalogno (ci vorranno 10-15 minuti).
Unite in padella le seppie, mescolate per 5 minuti e poi unite 3 cucchiai di prezzemolo tritato.

Sfumate con il vino bianco, salate, pepate e lasciate cuocere per 10-15 minuti a fuoco dolce coprendo con un coperchio. Trascorso il tempo suddetto, aggiungere i sacchetti di nero, avendo cura di romperli con il mestolo e farli sciogliere completamente in padella.

Lessate le linguine al dente in abbondante acqua salata, quindi scolatele e aggiungetele al sugo di nero di seppia; saltate le linguine al nero di seppia qualche secondo in padella e poi impiattate spolverizzando con il restante prezzemolo.

Appunti JavaScript

Una ottima guida è questa: http://killdream.github.com/blog/2011/10/understanding-javascript-oop/

Variable scope

Le variabili sono visibili nello scope della funzione in cui sono definite (eventualmente nello scope global). Non c’è un block statement:

// la variabile x è visibile al di fuori del blocco if: infatti lo scope è quello globale,
// non essendoci una funzione definita.
if (true) {
  var x = 5;
}
console.log(x);

Variabili Globali

Nelle pagine web l’ oggetto globale è l’ oggetto window: quindi le variabili di una finestra sono accessibili da altre finestre.

Function scope

Le variabili definite all’ interno di una funzione non sono accessibili dall’ esterno: sono membri privati.
Ma una funzione può accedere alle variabili e alle funzioni definite nello stesso scope in cui essa è definita:

  • Una funzione definita nello scope globale può accedere a tutti i membri globali
  • Una funzione definita all’ interno di una funzione può accedere a tutti i membri definiti nella funzione genitrice, e ai membri a cui la funzione genitrice ha accesso

Da questo comportamento deriva quello delle closures.

Closures

Le funzioni “esterne” non hanno accesso alle variabili definite nelle funzioni in esse annidate: è una sorta di protezione dei dati.
Una closure si realizza quando viene esposta all’ esterno una funzione interna, che sappiamo avere accesso alle variabili interne.

var pet = function(name) {          // Il parametro name definisce una variabile interna !!
      var getName = function() {
        return name;                // La funzione privata ha accesso alla variabile esterna "name"
      }

      return getName;               // Restituisce la funzione interna, esponendo la variabile "name"
    },
    myPet = pet("Vivie");

myPet();                            // Returns "Vivie"

Esempio più complesso: il costruttore ritorna un oggetto con 4 funzioni che realizzano alcune closures:

var createPet = function(name) {    // name è una variabile protetta
  var sex;                          // anche sex è una variabile protetta

  return {                          // Restituisce un oggetto definito tramite "object literals"
    setName: function(newName) {    // I membri restituiti sono pubblici !!!
      name = newName;
    },

    getName: function() {
      return name;
    },

    getSex: function() {
      return sex;
    },

    setSex: function(newSex) {
      if(typeof newSex == "string" && (newSex.toLowerCase() == "male" || newSex.toLowerCase() == "female")) {
        sex = newSex;
      }
    }
  }
}

var pet = createPet("Vivie");
pet.getName();                  // Vivie

pet.setName("Oliver");
pet.setSex("male");
pet.getSex();                   // male
pet.getName();                  // Oliver

Object Literals vs. Constructed Objects

riterimento: http://www.zebrakick.com/object-literals-vs-constructed-objects-in-javascript/

Object literals – ogetti statici

La notazione object-literal definisce oggetti Singleton:

var OggettoStatico = {
    prop1: "val 1",
    prop2: "val 2"
};

var Oggetto2 = OggettoStatico;  // Ad Oggetto2 viene assegnato un riferimento ad OggettoStatico !!
console.log(OggettoStatico, Oggetto2); //({prop1:"val 1", prop2:"val 2"}) ({prop1:"val 1", prop2:"val 2"})
Oggetto2.prop2 = "altro";
console.log(OggettoStatico, Oggetto2); //({prop1:"val 1", prop2:"altro"}) ({prop1:"val 1", prop2:"altro"})

Gli oggetti statici possono essere utili per creare delle librerie senza utilizzare il global scope.

IMPORTANTE: tutti i membri definiti con notazione object-literals sono necessariamente pubblici.

Constructed objects – oggetti istanziati

Questo metodo è l’ unico ad offrirela posibiltà di definire membri privati grazie alle closure.
Si è già visto come dichiarare membri pubblici e privati, con this e var rispettivamente.

Un discorso a parte va fatto per i metodi privati: in essi this assume il valore Window

var oggetto = function() {
	var prv = function() { console.log(this); };
	this.cns = function() {
		prv.call();
	}
}

var xxx = new oggetto();
xxx.cns();           // Sulla console si avrà [object Window]

Un buon metodo per avere un riferimento all’ oggetto dall’ interno di un metodo privato è quello di dichiarare una variabile privata con un riferimento a this: il metodo privato può accedere a questa nuova variabile.

var oggetto = function() {
	var self = this;
	var prv = function() { console.log(self); };
	this.pub = "something";
	this.cns = function() {
		prv();
	}
}

var xxx = new oggetto();
xxx.cns();

Un altro metodo, che però non mi piace, è quello di definire una funzione pubblica che faccia da wrapper al metodo privato:

var oggetto = function() {
	var prv = function() { console.log(this); };  //metodo privato
	this.pub = "something";
	this.cns = function() {  //wrapper che chiama prv passandogli this
		prv.call(this);
	}
}

var xxx = new oggetto();
xxx.cns();

E’ interessante notare l’ output sulla console:

({pub:"something", cns:(function () {prv.call(this);})})

è un oggetto in notazione letterale, di cui vediamo i soli membri pubblici: prv non è riportato.

Classi con la notazione object-literal

riferimento: http://www.gabordemooij.com/jsoop.html

Vediamo ora come creare e gestire classi in javascript considerando solo la notazione object-literal, senza i prototipi delle classi.

Object oriented

A differenza di altri linguaggi, JS opera direttamente su oggetti, e non su classi.
In PHP o Java si scrivono le classi e poi si istanziano gli oggetti, in JS invece si scrive direttamente un oggetto.

Costruttore

Rimanendo in ambito object-literal, in cui ogni membro è necessariamente pubblico, possiamo pensare ad un factory method:

Cat = {
    createNew: function(){
        var cat = { "name":"Silvester" }
        return cat;
    }
}

questo metodo pubblico crea un oggetto cat e lo restituisce.

Classi

Approfondiamo l’ analisi: mancando le classi in JS, possiamo realizzare un oggetto per creare altri oggetti; questo oggetto è un builder.
Nel builder si possono aggiungere i membri:

Cat = {
    createNew: function() {
        var cat = {}; //create an empty object
        cat.makeSound= function(){ //add logic
            alert("meow");
        }
        return cat; //return the fabricate
    }
}

var cat = Cat.createNew();
cat.makeSound();

Membri privati

Come visto in precedenza, lo scope delle variabili all’ interno delle funzioni offre la protezione dei dati.
Quindi dichiarare variabili all’ interno del costruttore le rende “locali” ad esso:

Cat = {
    createNew: function() {
        var cat = {};
        var sound = "meow"; //sound is local
        cat.makeSound= function(){
            //can reach sound from here
            alert( sound );
        }
        return cat;
    }
}

var cat = Cat.createNew();
cat.makeSound();
// ma non possiamo accedere a sound direttamente:
alert(cat.sound); // undefined

Notare che se si aggiungono successivamente altri metodi privati, questi non possono accedere alle proprietà private anche se fanno parte dello stesso oggetto.

Ereditarietà

Bisogna chiamare il costruttore della classe genitrice:

Animal = {
    createNew: function() {
        var animal = {};
        animal.eat = function(){ alert("eating"); }
        return animal;
    }
}

Cat = {
    createNew: function() {
        var cat = Animal.createNew(); // Chiama il costruttore: abbiamo la classe genitrice
        var sound = "meow";
        cat.makeSound= function(){
            alert( sound );
        }
        return cat;
    }
}

var cat = Cat.createNew();
cat.makeSound();
cat.eat();

Linux: LSB init scripts

Per modificare i link simbolici nelle directories /etc/rc*.d si usa il comando update-rc.d.

Gli script responsabili dell’ avvio/arresto dei demoni sono in /etc/init.d: modificando l’ header di uno di essi, bisogna aggiornare le rc*.d.
Se ad esempio si vuole modificare i runlevel in cui far partire un demone, bisogna modificare l’ header dell script in /etc/init.d: (vedere Default-Start e Default-Stop)

#!/bin/sh
### BEGIN INIT INFO
# Provides:          foobar
# Required-Start:    $local_fs $remote_fs $network $syslog $named
# Required-Stop:     $local_fs $remote_fs $network $syslog $named
# Default-Start:     3 4 5
# Default-Stop:      0 1 2 6
# X-Interactive:     true
# Short-Description: Start/stop foobar daemon
### END INIT INFO

Se il demone è pre-esistente, bisogna prima rimuovere i link simbolici in /etc/rc*.d/

update-rc.d foobar remove

quindi lo si re-installa:

update-rc.d foobar defaults

Adesso lo script relativo a foobar dovrà avere i link simbolici corretti ( Kill in rc0-1-2-6 e Start in rc3-4-5).