La nostra situazione attuale

La dittatura perfetta avrà le sembianze di una democrazia, una prigione senza muri nella quale i prigionieri non segneranno mai di fuggire.

Un sistema di schiavitù dove, grazie al consumo e al divertimento, gli schiavi ameranno la loro schiavitù. 

Annunci
Pubblicato in Pensieri | Contrassegnato | Lascia un commento

Beccacce al ginepro

http://www.buonissimo.org/lericette/8312_Beccacce_al_ginepro

Il vino da abbinare a questa ricetta è un Sassicaia o un barolo.

Ingredienti

  • 2Beccacce pulite da 400 g l’una
  • 100 gBurro
  • 12Bacche di ginepro
  • 1 dlAcquavite di ginepro
  • 2 ramettiTimo
  • q.b.Sale
  • q.b.Pepe

Preparazione

Pestate le bacche di ginepro nel mortaio riducendole in poltiglia. Amalgamatene 1/3 con 40 g di burro ammorbidito, a temperatura ambiente e formate 2 palline; mettetene 1 dentro ogni beccaccia. Aggiungete anche 1 rametto di timo lavato per insaporire.

Mettete il restante burro in un tegame e, a fuoco vivo, fate rosolare uniformemente le beccacce, girandole delicatamente con l’aiuto di 2 cucchiai.

Continuate la cottura a fuoco moderato e dopo circa 10 minuti insaporite con un pizzico di sale e una generosa macinata di pepe e spolverizzate con il resto delle bacche pestate.

Proseguite per altri 10 minuti e, a fine cottura, scaldate l’acquavite, versatela sulle beccacce, fiammeggiate e portate a tavola.

Pubblicato in Enogastronomia, Ricette | Contrassegnato , , , | Lascia un commento

Troppa elettronica in MotoGP

Finalmente qualcuno ne parla: i giornalisti TV ovviamente non sputano nel piatto dove mangiano e non lo dicono, ma l’ elettronica è una rovina per lo spettacolo della MotoGP.

E’ molto interessante il discorso di Wayne Gardner:
http://www.autosport.com/news/report.php/id/123028

Electronics technology has overtaken the ‘gladiatorial’ element of riders doing battle in MotoGP
….
when you raced the four-strokes compared to the two-strokes, it was 70 per cent easier.
So straight away, that’s an easy way to go racing, and safer.
Then you add in the electronics, which brings the safety aspect up a lot higher, but also takes away a lot of the thrill.
I think it’s lost a little bit of its touch with the public, and the thrill and the excitement, and seeing the gladiators out there, fighting.

MotoGP’s new-for-2016 ECU has been dubbed a “step backwards” by some riders, but Gardner – who has been reunited with 500cc bikes in the World GP Bike Legends series – feels more could still be done.

However, he concedes that is unlikely, based on the manufacturers’ interests.
“In my opinion, take all of the electronics off them,”

“They’ve got electronics, anti-wheelie and clutch and launch control, all of the other gizmos.

“We have no control over it, because it’s what the manufacturers want, but it’d be nice if they threw the electronics off all of the four-strokes.

Molto simile il discorso di Casey Stoner:
https://motorlands.eu/2016/08/04/electronics/

Electronics: Everyone must have the same driving style.
in qualifying all must brake late. Open the throttle again and so it does the rest. There isn’t finesse.

Electronics helps a lot of pilots, who are not able to control the bike, to fight with the best.

For Stoner the electronics have unified riding styles: […] No one can make a difference in output. It all depends who brakes later and who is willing to take more risks.

Praticamente le moto fanno tutto da sole…..

TOGLIETE L’ ELETTRONICA DALLA MOTOGP !!!!!!!

Pubblicato in Pensieri, Uncategorized | Contrassegnato , , , , , , , , , | Lascia un commento

VirtualBox Video Mode Hint

per modificare le dimensioni della finestra di una VM, nel Gestore andare in File->Preferenze (CTRL+G) poi in Schermo: impostare larghezza e altezza (per esempio 1600×900).

vedere https://fcel2008.wordpress.com/2014/07/25/virtualbox/

Pubblicato in Debian | Contrassegnato , , , , , | 1 commento

Crema pasticcera

http://www.cremapasticcera.it/

Ingredienti

Latte, 500 ml
Zucchero, 150 g
Farina, 50 g
Uova, 6
Vanillina, 1 bustina

Ricetta per 4 persone
  • Prima di tutto prendete un pentolino medio e mettetevi dentro tutto il latte mettendone da parte solo mezzo bicchiere, vi servirà nella fase finale.
    Versateci dentro anche la vanillina, ma se avete un baccello di vaniglia estraetene i semini interni e metteteli dentro il latte.
    Fate scaldare a fiamma media e spegnete non appena comincia a bollire.
  • Nel frattempo in una ciotola mettete dentro solo il rosso delle uova insieme allo zucchero e, aiutandovi con un frustino elettrico, sbattete per bene il tutto.
  • Continuate a sbattere fino a quando non avete ottenuto una crema omogenea e spumosa.
  • Il latte nel frattempo si è raffreddato un po’, prendetene un terzo e versatene piano piano dentro la ciotola con la crema di uova e zucchero che avete appena fatto e continuate a mescolare col frustino.
    Versate il latte molto lentamente altrimenti rischiate di rovinare la crema prima ancora di finirla.
  • Adesso potete setacciare la farina e unirla poco alla volta dentro la crema. Mescolate ancora il tutto.
  • A questo punto siamo quasi al termine dell’opera…
    Versate la crema ottenuta dentro la pentola con il latte fatto bollire in precedenza. Accendete il fuoco e fate portare ad ebollizione non dimenticando assolutamente di continuare a mescolare manualmente con un frustino o con qualcosa di simile, volendo anche un cucchiaio di legno.
  • Non appena bolle, abbassate la fiamma e continuate a mescolare altri per 2-3 minuti.
    Prendete quindi il mezzo bicchiere di latte messo da parte e aggiungetelo a filo dentro la pentola continuando a mescolare per bene per evitare di formare dei bruttissimi grumi.
    Versato tutto il latte, spegnete il fuoco perchè la vostra crema è finalmente pronta!
  • Lasciatela raffreddare e, per evitare che ci si formi sopra una pellicina, copritela con una pellicola trasparente.
Pubblicato in Enogastronomia, Ricette | Contrassegnato , , | Lascia un commento

Appunti: parser

function processText(testo) {
	var myArray = testo.split('\n');
	for(var i in myArray) {
		var re = /^(\d\d)\/(\d\d)\/(\d\d\d\d), (\d\d\:\d\d) - ([^:]*): (.*)/;
		var op = re.exec(myArray[i]);
		if(op) { console.log(re.exec(myArray[i]));}
		else { console.log(myArray[i]);}
	}
}
Pubblicato in Ajax, Programmazione | Contrassegnato , , | Lascia un commento

Leggere file locali con JavaScript

http://www.html5rocks.com/en/tutorials/file/dndfiles/?redirect_from_locale=it

Le specifiche forniscono diverse interfacce per accedere ai file locali:

  • File – an individual file; provides readonly information such as name, file size, mimetype, and a reference to the file handle. Riferimento MDN: File()
  • FileList – an array-like sequence of File objects. (Think or dragging a directory of files from the desktop). Riferimento MDN: FileList()
  • Blob – Allows for slicing a file into byte ranges.

Vedere inoltre i riferimenti MDN di: DataTransfer() e FileReader().
Usare file da web app: Tutorial MDN.

Verifica del supporto da parte del browser:

// Check for the various File API support.
if (window.File && window.FileReader && window.FileList && window.Blob) {
  // Great success! All the File APIs are supported.
} else {
  alert('The File APIs are not fully supported in this browser.');
}

Usare un form per scegliere i file:

<input type="file" id="files" name="files[]" multiple />
<output id="list"></output>

<script>
  function handleFileSelect(evt) {
    var files = evt.target.files; // FileList object

    // files is a FileList of File objects. List some properties.
    var output = [];
    for (var i = 0, f; f = files[i]; i++) {
      output.push('<li><strong>', escape(f.name), '</strong> (',
                   f.type || 'n/a', ') - ', f.size, ' bytes,
                   last modified: ', f.lastModifiedDate ? f.lastModifiedDate.toLocaleDateString() : 'n/a',
                  '</li>');
    }
    document.getElementById('list').innerHTML = '<ul>' + output.join('') + '</ul>';
  }
document.getElementById('files').addEventListener('change', handleFileSelect, false);
</script>

Usare il drag&drop:

<div id="drop_zone">Drop files here</div>
<output id="list"></output>
<script>
  function handleFileSelect(evt) {
    evt.stopPropagation();
    evt.preventDefault();

    var files = evt.dataTransfer.files; // FileList object.

    // files is a FileList of File objects. List some properties.
    var output = [];
    for (var i = 0, f; f = files[i]; i++) {
      output.push('<li><strong>', escape(f.name), '</strong> (', f.type || 'n/a', ') - ',
                  f.size, ' bytes, last modified: ',
                  f.lastModifiedDate ? f.lastModifiedDate.toLocaleDateString() : 'n/a',
                  '</li>');
    }
    document.getElementById('list').innerHTML = '<ul>' + output.join('') + '</ul>';
  }

  function handleDragOver(evt) {
    evt.stopPropagation();
    evt.preventDefault();
    evt.dataTransfer.dropEffect = 'copy'; // Explicitly show this is a copy.
  }

  // Setup the dnd listeners.
  var dropZone = document.getElementById('drop_zone');
  dropZone.addEventListener('dragover', handleDragOver, false);
  dropZone.addEventListener('drop', handleFileSelect, false);
</script>

In entrambi i casi si ottiene una FileList() di oggetti File().
Con FileReader() si può leggere un file:

  • FileReader.readAsBinaryString(Blob|File) – The result property will contain the file/blob’s data as a binary string. Every byte is represented by an integer in the range [0..255].
  • FileReader.readAsText(Blob|File, opt_encoding) – The result property will contain the file/blob’s data as a text string. By default the string is decoded as ‘UTF-8’. Use the optional encoding parameter can specify a different format.
  • FileReader.readAsDataURL(Blob|File) – The result property will contain the file/blob’s data encoded as a data URL.
  • FileReader.readAsArrayBuffer(Blob|File) – The result property will contain the file/blob’s data as an ArrayBuffer object.

Chiamando questi metodi, si ottiene una lettura asincrona, con gli eventi onloadstart, onprogress, onload, onabort, onerror, e onloadend.

Esempio: carichiamo immagini da una selezione utente, chiamiamo reader.readAsDataURL() sulle immagini, disegniamo una thumbnail usando l’ attributo ‘src’ con la URL.

<style>
  .thumb {
    height: 75px;
    border: 1px solid #000;
    margin: 10px 5px 0 0;
  }
</style>

<input type="file" id="files" name="files[]" multiple />
<output id="list"></output>

<script>
  function handleFileSelect(evt) {
    var files = evt.target.files; // FileList object

    // Loop through the FileList and render image files as thumbnails.
    for (var i = 0, f; f = files[i]; i++) {

      // Only process image files.
      if (!f.type.match('image.*')) {
        continue;
      }

      var reader = new FileReader();

      // Closure to capture the file information.
      reader.onload = (function(theFile) {
        return function(e) {
          // Render thumbnail.
          var span = document.createElement('span');
          span.innerHTML = ['<img class="thumb" src="', e.target.result, '" title="', escape(theFile.name), '"/>'].join('');
          document.getElementById('list').insertBefore(span, null);
        };
      })(f);

      // Read in the image file as a data URL.
      reader.readAsDataURL(f);
    }
  }

  document.getElementById('files').addEventListener('change', handleFileSelect, false);
</script>

Slicing a file

File() permette di leggere range di byte:

var blob = file.slice(startingByte, endindByte);
reader.readAsBinaryString(blob);

Esempio: notare che si usa onloadend e si controlla evt.target.readyState

<style>
  #byte_content {
    margin: 5px 0;
    max-height: 100px;
    overflow-y: auto;
    overflow-x: hidden;
  }
  #byte_range { margin-top: 5px; }
</style>

<input type="file" id="files" name="file" /> Read bytes: 
<span class="readBytesButtons">
  <button data-startbyte="0" data-endbyte="4">1-5</button>
  <button data-startbyte="5" data-endbyte="14">6-15</button>
  <button data-startbyte="6" data-endbyte="7">7-8</button>
  <button>entire file</button>
</span>

<div id="byte_range"></div>
<div id="byte_content"></div>

<script>
  function readBlob(opt_startByte, opt_stopByte) {

    var files = document.getElementById('files').files;
    if (!files.length) {
      alert('Please select a file!');
      return;
    }

    var file = files[0];
    var start = parseInt(opt_startByte) || 0;
    var stop = parseInt(opt_stopByte) || file.size - 1;

    var reader = new FileReader();

    // If we use onloadend, we need to check the readyState.
    reader.onloadend = function(evt) {
      if (evt.target.readyState == FileReader.DONE) { // DONE == 2
        document.getElementById('byte_content').textContent = evt.target.result;
        document.getElementById('byte_range').textContent = 
            ['Read bytes: ', start + 1, ' - ', stop + 1,
             ' of ', file.size, ' byte file'].join('');
      }
    };

    var blob = file.slice(start, stop + 1);
    reader.readAsBinaryString(blob);
  }
  
  document.querySelector('.readBytesButtons').addEventListener('click', function(evt) {
    if (evt.target.tagName.toLowerCase() == 'button') {
      var startByte = evt.target.getAttribute('data-startbyte');
      var endByte = evt.target.getAttribute('data-endbyte');
      readBlob(startByte, endByte);
    }
  }, false);
</script>

Monitorare il processo di lettura

Si usano gli eventi onloadstart e onprogress.
Esempio: barra di progressione

<style>
  #progress_bar {
    margin: 10px 0;
    padding: 3px;
    border: 1px solid #000;
    font-size: 14px;
    clear: both;
    opacity: 0;
    -moz-transition: opacity 1s linear;
    -o-transition: opacity 1s linear;
    -webkit-transition: opacity 1s linear;
  }
  #progress_bar.loading {
    opacity: 1.0;
  }
  #progress_bar .percent {
    background-color: #99ccff;
    height: auto;
    width: 0;
  }
</style>

<input type="file" id="files" name="file" />
<button onclick="abortRead();">Cancel read</button>

<div id="progress_bar">
<div class="percent">0%</div>
</div>

<script>
  var reader;
  var progress = document.querySelector('.percent');

  function abortRead() {
    reader.abort();
  }

  function errorHandler(evt) {
    switch(evt.target.error.code) {
      case evt.target.error.NOT_FOUND_ERR:
        alert('File Not Found!');
        break;
      case evt.target.error.NOT_READABLE_ERR:
        alert('File is not readable');
        break;
      case evt.target.error.ABORT_ERR:
        break; // noop
      default:
        alert('An error occurred reading this file.');
    };
  }

  function updateProgress(evt) {
    // evt is an ProgressEvent.
    if (evt.lengthComputable) {
      var percentLoaded = Math.round((evt.loaded / evt.total) * 100);
      // Increase the progress bar length.
      if (percentLoaded < 100) {
        progress.style.width = percentLoaded + '%';
        progress.textContent = percentLoaded + '%';
      }
    }
  }

  function handleFileSelect(evt) {
    // Reset progress indicator on new file selection.
    progress.style.width = '0%';
    progress.textContent = '0%';

    reader = new FileReader();
    reader.onerror = errorHandler;
    reader.onprogress = updateProgress;
    reader.onabort = function(e) {
      alert('File read cancelled');
    };
    reader.onloadstart = function(e) {
      document.getElementById('progress_bar').className = 'loading';
    };
    reader.onload = function(e) {
      // Ensure that the progress bar displays 100% at the end.
      progress.style.width = '100%';
      progress.textContent = '100%';
      setTimeout("document.getElementById('progress_bar').className='';", 2000);
    }

    // Read in the image file as a binary string.
    reader.readAsBinaryString(evt.target.files[0]);
  }

  document.getElementById('files').addEventListener('change', handleFileSelect, false);
</script>
Pubblicato in Ajax, Programmazione | Contrassegnato , , , | Lascia un commento