none of the above

Questa tastiera che ha un difetto sul tasto “o” mi fa scrivere degli avverbi di negazione da ragazzino, con esiti imbarazzanti.
Ora nn mi resta che spostare la k al posto della c e ringiovanire di 25 anni.

Mi sono reso conto che nel post dove chiedo aiuto per un posto di lavoro manca qualcosa: che tipo di lavoro faccio…

Sono uno sviluppatore di software embedded. O firmware che dir si voglia.

Ora, nessuno chieda cosa significhi, è un argomento scaccia fighe, l’ho già sperimentato sulla mia pelle nella vita reale, ok che i visitatori sono una manciata e non è che si sia avverata quella cosa di cui si diceva che con il blog si scopa di più, ma l’ho dovuto spiegare così tante volte che mi son rotto.

Oggi mi sono trovato a dover risolvere un problema che evidenzia bene come la macchina uomo sia infinitamente superiore ad un computer: ribaltare una stringa arbitraria di bit.

Mi spiego con un esempio, per chi non abbia confidenza con l’informatica di base: il problemae è partire da una fila di di bit tipo 0000000000000001 ed ottenere questa: 1000000000000000.

Già ad occhio si vede come il problema sembri una stupidaggine, anche mia nipotina di 5 anni riuscirebbe a farlo se qualcuno fosse in grado di farla interessare ad una cosa così noiosa.

Ma scrivere un programma in C che lo faccia e non sia troppo stupido non è una cosa così semplice. Almeno per me non lo è stato.

Quando dico non troppo stupido intendo dire che quello che volevo era un pezzo di codice che fosse il più generico possibile o meglio, il meno specifico possibile.

Perché scrivere del codice che ribalti un byte, otto bit, non è molto difficile, anzi. C’è anche fior di letteratura su google al riguardo. E così per una word, sedici bit, o un long, trentadue bit.

Il difficile è fare una stessa funzione che accetti un qualsiasi numero di byte e li ribalti.

Dopo un po’ di pensamenti e ripensamenti, sono giunto ad una soluzione che trovo elegante, la annoto qui per ricordarmela, farla eventualmente trovare e accettare miglioramenti e critiche se qualcuno ne avesse.

L’algoritmo è completamente diverso da quello che userebbe una mente umana, perlomeno una sana; il ribaltamento è fatto in due passi: per prima cosa si prendono i singoli byte del vettore e li si scambia di posto in modo che si leggano dal fondo verso l’inizio. Chiamando tre byte B1, B2 e B3 si passa quindi da una situazione di partenza in cui si ha:

B1B2B3

ad una in cui si ottiene:

B3B2B1

A questo punto si invertono i singoli bit che compongono ogni byte, passando da:

b7b6b5b4b3b2b1b0

a:

b0b1b2b3b4b5b6b7

Semplice, no?

Di seguito il codice per farlo.

(Non l’ho compilato, è da prendere com’è, non usatelo per mandare una navicella nello spazio senza prima testarlo a fondo…)

—SNIP—

// How to mirror an undefined number of bits

void main(void);
void ReverseArray(u8 *, u8);
void SwapBytes(u8 *, u8 *);
u8 ByteReverse(u8);

// A three elements array for testing purpose, but it works with an arbitrary number of bytes

u8 Array[3] =
{
00000000b
00000000b
00000001b
};

void main(void)
 {
 ReverseArray(Array);
 }

void ReverseArray(u8 *variable_ptr, u8 variable_size)
 {
 u8 i;
 u8 j;

 i = 0;
 j = variable_size - 1;
 while (i < j)
  {
  SwapBytes(variable_ptr + i, variable_ptr + j);
  i++;
  j--;
  }

 for (i = 0; i < variable_size; i++)
  {
  *(variable_ptr + i) = ByteReverse(*(variable_ptr + i));
  }
 }

void SwapBytes(u8 *first_byte_ptr, u8 *second_byte_ptr)
 {
 u8 temp_byte;

 temp_byte = *first_byte_ptr;
 *first_byte_ptr = *second_byte_ptr;
 *second_byte_ptr = temp_byte;
 }

u8 ByteReverse(u8 byte_variable)
 {
 u8 i;
 u8 reversed_variable;

 reversed_variable = 0;

 for (i = 0; i < SIZE_BYTE; i++)
  {
  if (byte_variable & (1 << i))
   {
   reversed_variable |= 1 << ((SIZE_BYTE - 1) - i);
   }
  }
 return reversed_variable;
 }

—PINS—

Mi piacerebbe sapere come mai, a sentire le statistiche di FeedBurner, di giorno in giorno i lettori del mio feed aumentano o diminuscono di qualche unità.

Perché fossero centinaia lo capirei, ma siamo dell’ordine della trentina e tre su trenta è un bel diecipercento.
E capisco che quello che scrivo può smettere di interessare qualcuno, ma se ci si pensa bene è strano. Perché il modello per cui i lettori del feed crescono o diminuiscono di uno è qualcosa del tipo:

“Toh, vediamo sto fmf come scrive, sottoscriviamo il feed.”
Passano due giorni: “Bah, sto fmf dice solo cazzate, dimentichiamolo.”

Ma se invece da un giorno all’altro più di una persona fa questo vuol dire che c’è molta gente che legge il blog o lo trova in qualche modo nella rete e decide di provarlo e si stufa il giorno dopo.

Fossero migliaia i lettori totali, di cui una percentuale via feed, di cui una percentuale fissa e una variabile capirei molto meglio queste fluttuazioni, mentre così ho l’impressione che o ci sono un paio di pazzi che un giorno si iscrive e quello dopo si cancella sistematicamente oppure c’è qualcosa che non capisco delle statistiche di feedburner.