"Impariamo il C", un corso collaborativo

Qualche settimana fa ho dato via ad un piccolo esperimento sul forum di NGI. Si tratta di un micro-corso di programmazione C di stampo collaborativo: una breve lezione "frontale" discussa con la community.

L'approccio che seguo è bottom-up: son voluto partire dalle minuzie (cioé il ferro, quella che viene chiamata architettura dell'elaboratore) e risalire lentamente, introducendo un piccolo tassello aggiuntivo ad ogni lezione. Naturalmente, tutto scritto in maniera easy, con molte metafore, illustrazioni ed esercizietti.

Perché proprio il C? Beh, perché è la base dei linguaggi imperativi. In fondo, praticamente tutti i linguaggi non funzionali e non logici sono dialetti del C. Una volta imparata la logica, poi ci si può spostare su altri contesti senza paura, dai sistemi embedded alle web-application, passando per il mondo emergente del GPGPU computing.

Queste sono le "lezioni" effettuate finora:

1. installazione dell'IDE, cenni di architettura degli elaboratori
   
2. sintassi del C, programmazione strutturata
3. ancora sulla sintassi, i tipi di dato, le variabili
4. variabili parte seconda: gli array
5. introduzione delle funzioni
6. operatori aritmetici e logici
7. costrutti di selezione
8. costrutti di iterazione
9. ancora sull'iterazione
10. array multipli e struct
11. ricorsione
12. ancora ricorsione, memoria (record attivazione, heap, stack, ecc), introduzione dei puntatori
13. le liste e l'allocazione di memoria (malloc)
14. accenni dei costi asintotici, e ancora liste

Cercherò di tenere aggiornato l'indice. Il corso, per ora, ha un discreto séguito anche se abbiamo subito molti "abbandoni", vuoi per l'incapacità dell'insegnante, vuoi perché la programmazione C può essere rognosa (molti son saltati giù con la ricorsione, chissà perché!).

Come sosteneva Schoenberg, anche il maestro impara nell'insegnare all'allievo. Trasmettendo il C sto scoprendo aspetti che proprio cui non avevo mai prestato attenzione o di cui ignoravo completamente l'esistenza. Per esempio, ho reagito in maniera un po' scomposta alla scoperta che sia sizeof che la virgola sono operatori in C, e in particolare la virgola (grazie ACray!) che in base alle situazioni può avere una semantica che definire balzana è usare un eufemismo. Il C non finisce mai di stupire.

Just for fun: obfuscated hello world, in C

main(int argc,char*argv[]){memset(&argc,0,1);char*s[11]={0,-3,4,4,7,-40,15,7,10,4,-4};while(argc<11)printf("%c",s[argc++]+0x48);}

What could this code do? =)

The reason behind this code is here.

Reinventing the wheel

Matrix multiplication is fundamental in computer graphics, expecially when you're dealing with shadow maps and texture projections.

Unfortunately, there are no standard functions for matrix multiplication, so it was time for DIY. Here comes my snippet:

float* matrixProduct(float* A, float* B) {

// we have to allocate space for a 4x4 floats matrix
float* pointer= (float *) calloc(sizeof(float), 16);

// in order to compute the resulting matrix, we have to use two nested fors
for (int r=0; r<4; r++) {
for (int c=0; c<4; c++) {

    // actual multiplications
    for (int i=0; i<4; i++) {
      pointer[r*4+c] = pointer[r*4+c] + A[r*4+i]*B[c+i*4];
    }
}
}    

return pointer;

}

This simple function returns a pointer to an handful 4x4 array of floats, without memory flaws. Maybe this snippet will be helpful for someone in the future.