Rösti

“Rubo” la ricetta da questo blog 😉 : http://ilmondodiluvi.blogspot.it/2011/07/rosti-di-patate-e-cipolle.html

Rösti
Da Wikipedia, l’enciclopedia libera.

Il Rösti (IPA: [ˈrøs.ti] in tedesco, Röschti IPA: [ˈrøːʃ.ti] in tedesco alemanno) è un piatto della cucina svizzera a base di patate.

Originariamente i contadini del canton Berna lo mangiavano per colazione; ora è diffuso in tutto il paese al punto da essere considerato uno dei piatti nazionali. Viene solitamente servito come contorno.
Anche se la ricetta base prevede solo patate, spesso vengono aggiunte cipolle, pancetta, formaggio, erbe aromatiche o anche mele. A volte è servito come contorno, ad esempio per accompagnare lo sminuzzato di vitello cotto in padella con panna, piatto tipico del Canton Zurigo e per questo definito “alla zurighese”.

Il rösti si prepara con patate grattugiate e mescolate con burro o olio, o in alternativa grattugiate e poi fritte leggermente in olio. Con le patate grattugiate si formano dei tondi dal diametro di 5-20 cm e alti 1-2 cm; spesso la forma del rösti è data semplicemente dalla padella usata per friggere.

Le opinioni sono diverse riguardo a come cucinare un perfetto rösti.
In particolare, le principali divergenze si hanno riguardo all’utilizzo di patate crude o lessate “al dente” come ingrediente principale; solitamente si usano le patate lesse se il rösti è servito come contorno, quelle crude se è il piatto principale. Anche il tipo di patata da utilizzare è un argomento molto discusso. In generale bisogna utilizzare patate che non si disfino lessandole.

Torniamo a noi, io ho seguito le indicazioni date a una trasmissione del Gambero rosso. Le dosi sono molto indicative.
INGREDIENTI

3 patate
1 cucchiaio di farina
1 cipolla piccola

burro per ungere la padella antiaderente
sale, pepe
anello di metallo

PROCEDIMENTO

Sbucciate le patate e grattugiatele subito son una grattugia di metallo a fori non piccoli.
Fate lo stesso con la cipolla.

Prendete un canovaccio sottile , mettetelo a doppio e versate nel centro il composto di patate e cipolla, chiudetelo a caramella e strizzate ben bene.

Continuate finchè esce liquido.

Versate quindi il tutto in un contenitore e aggiungete un cucchiaio di farina, con le mani mescolate e lasciate riposare qualche minuto.

Nel frattempo scaldate una padellina antiaderente con del burro e posizionate un anello di metallo nel centro.

Aiutandovi con due cucchiai prendete una porzione abbondante di filini di patate/cipolle e pressatele dentro l’anello.

Cuocete a fiamma medio alta, togliete l’anello, facendo attenzione a non scottarvi e aiutandovi con una spatola girate il rosti fino a completare la cottura.

Cuocete tutti i rosti e poco prima di servirli scaldateli a fiamma viva o in forno per creare la crosticina croccante, Salate e pepate a gradimento.

CONSIDERAZIONI

Sicuramente non è un piatto estivo ma può essere una originale alternativa d’uso delle patate. A noi, grandi consumatori e amanti del tubero, è piaciuto!
Cercando informazioni in giro ho scoperto anche che le patate migliori sono quelle più vecchie che fanno meno liquido.

Che prezzi fa l’ Alitalia ?

Vorrei sapere chi è quel genio che stabilisce i prezzi dei biglietti Alitalia: sicuramente ci sarà un pool di laureati in un posto di così grande importanza nell’ azienda.

Tariffe Alitalia

A volte ho visto prezzi per un Roma Parigi che da 150 euro sono schizzati a 700 per la stessa classe economica non -flessibile.

Ma quello in figura è un capolavoro: la economica che costa più della business !

Contemporaneamente ho fatto un altro preventivo con la British Airways: un volo multi-tratta Roma – Los Angeles – New York – Roma costa 1690 euro tutto compreso: meno della sola tratta Roma – Los Angeles in economica.

Poi che non vengano a dirci sui mass-media che l’ Alitalia non riempie i voli, che sta fallendo, che c’è la crisi: con questi prezzi chi, sano di mente, acquisterebbe un biglietto Alitalia ?

Approfondimenti sull’ Assembly

Nell’ assembly per il DOS, la maggior parte delle azioni sono fatte chiamando l’ int 21h dei servizi del DOS, oppure chiamando gli analoghi del BIOS come ad esempio int 10h e int 16h.

Con Linux, tutte queste funzioni sono gestite dal kernel tramite kernel system calls, e il kernel viene chiamato con int 80.

Linux è un sistema operativo protetto a 32 bit: non bisogna preoccuparsi dei segmenti di memoria, le cose sono di molto semplificate.

Le parti di un programma

  • Sezione .data: contiene le dichiarazioni di inizializzazione dei dati, i quali non potranno essere modificati successivamente, cosicchè non potranno essere considerati delle vere e proprie variabili.
    Esempio:

    section .data
    	message:    db 'Hello world!'     ; dichiara un dato che contiene bytes (caratteri ASCII)
    	msglength:  equ 12                ; dichiara una costante
    	buffersize: dw 1024               ; dichiara un dato di tipo word
    
  • Sezione .text: è la sezione in cui scrivere le istruzioni; deve iniziare obbligatoriamente con global _start, che è l’ analogo del main() in C: il kernel cercherà questo punto di inizio.
    section .text
    	global _start
    
    _start:
    	pop    ebx
            ...
    
  • Sezione .bss: vi si possono dichiarare le variabili, riservando uno spazio non inizializzato di memoria per ciascuna di esse.
    section .bss
    	filename:   resb    255           ; 255 bytes
    	number:     resb    1             ; 1 byte
    	bignum:     resw    1             ; 1 word (1 word = 2 bytes)
    	realarray:  resq    10            ; array of 10 reals
    

Linux System Calls

Per effettuare una chiamata, di norma si pone il numero della chiamata in EAX e gli argomenti nei restanti registri (nell’ ordine di utilizzo: EBX, ECX, EDX, ESI, EDI, EBP), si chiama l’ interrupt del kernel 80h. Il risultato è generalmente ritornato in EAX.
Ecco una tabella con le system calls: http://www.cin.ufpe.br/~if817/arquivos/asmtut/syscalls.html.

Concetti avanzati

Calcolo della lunghezza di una stringa:

section .data
	hello:     db 'Hello world!',10    ; 'Hello world!' plus a linefeed character
	helloLen:  equ $-hello             ; Length of the 'Hello world!' string

la costante $-hello si legge in questo modo: NASM (o YASM) sostituisce al simbolo $ la posizione dell’ assembly all’ inizio della riga che lo contiene, il che equivale alla fine della riga precedente. Sottraendogli la posizione iniziale di una variabile, si ottiene la lunghezza della variabile stessa.
La documentazione di NASM contiene altri trucchi simili.

Argomenti sulla linea di comando

Passando degli argomenti ad un programma assemblato e linkato, li ritroviamo nello stack, quindi per ottenerli basta un semplice pop: ad esempio

# supponiamo di avere ./mioprogramma foo bar 42
section .text
	global _start

_start:
	pop	eax		; Get the number of arguments
	pop	ebx		; Get the program name....lo sovrascrivo con la seguente
	pop	ebx		; Get the first actual argument ("foo")
	pop	ecx		; "bar"
	pop	edx		; "42"....attenzione: è una stringa, non un intero !

	mov	eax,1
	mov	ebx,0
	int	80h		; Exit

Label e jump

In assembly non esistono “procedure”, ma si usano etichette e salti.
Con i test condizionali si può “saltare” ad un’ etichetta.
Invece con il comando call si può “chiamare” un’ etichetta.

Pretare molta attenzione a questa differenza: se si salta ad un’ etichetta che contiene ret si avrà un segmentation fault (con Linux).
Viceversa, se dopo un’ etichetta c’è ret, allora bisogna chiamarla con call.

Per chiarire, vediamo come si scrive un banale if-then-else in assembly:

/*
 * Si vuole scrivere in assembly il seguente test:
 *
 * if (AX == 'w') {
 * 	   writeFile();
 * 	} else {
 * 	   doSomethingElse();
 * 	}
 */
cmp	AX,'w'		; Does AX contain 'w'?
jne	skipWrite	; If not, skip writing by jumping to another label, and doSomethingElse there...
call	writeFile	; ...else call the writeFile procedure...
jmp	outOfThisMess	; ...and jump past all of this spaghetti

skipWrite:
	call	doSomethingElse
outOfThisMess:
	...			; The rest of the program goes on here

; proc fileWrite - write a string to a file
fileWrite:
   mov eax,4               ; write system call
   mov ebx,[filedesc]      ; File descriptor
   mov ecx,stuffToWrite
   mov edx,[stuffLen]
   int 80h
   ret
; endp fileWrite

Assembly

Dalla pagina http://www.tortall.net/projects/yasm/manual/html/objfmt-elf32.html

The Executable and Linkable Object Format is the primary object format for many operating systems including FreeBSD or GNU/Linux. It appears in three forms:

Shared object files (.so)
Relocatable object files (.o)
Executable files (no convention)

Yasm only directly supports relocatable object files. Other tools, such as the GNU Linker ld, help turn relocatable object files into the other formats. Yasm supports generation of both 32-bit and 64-bit ELF files, called elf32 and elf64. A generic interface to both is also provided, elf, which selects between elf32 and elf64 based on the target machine architecture

Dalla precedente definizione si comprendono i comandi per assemblare:

yasm -f elf32 -o first.o first.asm
ld -o first first.o
./first

Analisi di un semplice programma per iniziare

section .text
	global _start ; Per il linker ld
_start
	mov eax,4 ; chiamata al kernel: write
	mov ebx,1 ; dove scrivere: stdout
	mov ecx,message ; stringa
	mov edx,message_lenght ; numero caratteri
	int 0x80 ; chiamata al kernel !!!
	mov eax,1 ; chiamata al kernel : exit
	int 0x80 ; chiamata al kernel !!!

section .data
	message db "Assembly rules!",10
	message_lenght equ $-message

Le prime due righe indicano dove inizia il programma.
Dopo l’ etichetta “_start” ci sono le istruzioni:
le prime 4 istruzioni inseriscono nei registri della CPU alcuni dati (poi vedremo cosa sono);
dopo c’è l’ istruzione int 0x80 che ha un significato molto forte:
definizione http://www.linfo.org/int_0x80.html e spiegazioni:

int means interrupt, and the number 0x80 is the interrupt number. An interrupt transfers the program flow to whomever is handling that interrupt, which is interrupt 0x80 in this case. In Linux, 0x80 interrupt handler is the kernel, and is used to make system calls to the kernel by other programs.

The kernel is notified about which system call the program wants to make, by examining the value in the register %eax (gas syntax, and EAX in Intel syntax). Each system call have different requirements about the use of the other registers. For example, a value of 1 in %eax means a system call of exit(), and the value in %ebx holds the value of the status code for exit().

Dopo il primo interrupt c’è un altro mov seguito da un int: è proprio la chiamata di sistema per exit(), impostata con il registro %eax che contiene il valore 1.

Tornando al primo blocco di istruzioni mov, vediamo che %eax contiene 4: adesso capiamo che questo registro indica al kernel quale operazione eseguire; in questo caso 4 indica una write().

Il significato del numero di chiamata al kernel presente nel registro %eax risiede nel file /usr/include/asm/unistd.h (presente nel pacchetto linux-libc-dev di debian):

/*
* This file contains the system call numbers.
*/

#define __NR_restart_syscall      0
#define __NR_exit                 1
#define __NR_fork                 2
#define __NR_read                 3
#define __NR_write                4
#define __NR_open                 5
#define __NR_close                6
#define __NR_waitpid              7
#define __NR_creat                8
#define __NR_link                 9
......

cercare syscall o system call per ulteriori approfondimenti.

In coda al listato c’è la sezione .data: questa contiene i dati statici.

  • la variabile “message” viene dichiarata come db (data bytes) e viene inizializzata con una stringa seguita da “,10”, ossia il numero 10 viene concatenato in coda alla stringa. Il numero 10 rappresenta il carattere di “a capo”, così che la stringa visualizzata in output sia ben formattata.
  • la variabile “message_lenght” viene impostata tramite la direttiva equ alla lunghezza della stringa precedente. Ciò si ottiene a partire dalla posizione corrente del programma ($) meno la posizione di “message”: dalla sottrazione si ottiene la lunghezza di “message”.

Disassemblare

Il disassembler di nasm fornisce un output poco leggibile.
Però c’è un altro strumento:

objdump -d first

fornisce un output in un formato diverso da quello usato per scrivere il codice: le istruzioni mov sono invertite, i numeri sono esadecimali, e le etichette sono sostituite dalle locazioni di memoria; è la sintassi AT&T.
Per controllare la sintassi dell’ output si può usare lo switch -M:

objdump -d -M intel first
# oppure
objdump -d -M intel-mnemonic first

first:     file format elf32-i386

Disassembly of section .text:

08048080 <_start>:
 8048080:	b8 04 00 00 00       	mov    eax,0x4
 8048085:	bb 01 00 00 00       	mov    ebx,0x1
 804808a:	b9 a0 90 04 08       	mov    ecx,0x80490a0
 804808f:	ba 10 00 00 00       	mov    edx,0x10
 8048094:	cd 80                	int    0x80
 8048096:	b8 01 00 00 00       	mov    eax,0x1
 804809b:	cd 80                	int    0x80

Riferimenti

Vedere http://www.cin.ufpe.br/~if817/arquivos/asmtut/index.html per ulteriori informazioni.
http://www.giobe2000.it/tutorial/Home.asp
Un testo completo sul linguaggio assembly si trova sul sito http://www.drpaulcarter.com/pcasm/: ecco il PDF Assembly

Facebook UID

Se l’ utente non ha scelto uno username personalizzato, la URL del profilo contiene lo UID:
http://www.facebook.com/profile.php?id=xxxxxxxxxxxxxxx dove le x sono dei numeri.
Se invece l’ utente ha uno username personalizzato del tipo
http://www.facebook.com/nome.scelto
è possibile reperire lo UID dai dati JSON presenti nella risorsa
https://graph.facebook.com/nome.scelto
Infatti, aprendo la precedente URL si trova qualcosa come:

{
   "id": "xxxxxxxxxxxxxxx",
   "name": "Nome Cognome",
   "first_name": "Nome",
   "last_name": "Cognome",
   "link": "https://www.facebook.com/nome.scelto",
   "username": "nome.scelto",
   "gender": "male",
   "locale": "us_US"
}

in cui la prima riga è l’ UID.
In alternativa, l’ UID si trova anche nelle URL delle foto degli album personali:
http://www.facebook.com/photo.php?fbid=938400182301834&set=pu.xxxxxxxxxxxxxxx&type=1
ed è quella al posto delle x.