Mostra notizie nelle discussioni
  • Avatar
    Scritto da
    Non Autenticato
    il 2010-11-16 00:43:00.0 alle 2010-11-16 00:43:00.0
    Avve ti spiego come si studia
    1) DEVI ESSERE ONESTO CON TE STESSO

    Se una cosa non l'hai capita devi stare lì finché non ti è chiara. Anche se poi scoprirai che non era importante come argomento, ti toglie sicurezza andare avanti senza capire, perché rimarrai sempre col dubbio di non avere il background adatto per capire l'argomento successivo.

    2) NON DEVI FARE UNA PASSEGGIATA NEL TESTO CI DEVI PASSARE ATTRAVERSO

    Studiare un libro tecnico non è come leggere un romanzo che vai avanti come se stessi camminando. Quando studi il libro lo devi attraversare in ogni suo punto. Non è un percorso lineare lo studio è un andare avanti e indietro continuamente.

    3) NON FARTI PRENDERE DALLA FRETTA

    Studiare richiede lentezza, più vai di fretta e più sarà facile distrarsi. Quante volte ti è capitato di leggere una cosa, andare avanti e renderti conto che stavi pensando ad altro e però avevi già passato la pagina. Non saltare le cose e non cercare di apprendere il più in fretta possibile. L'apprendimento è un processo naturale e richiede tempo, come una torta che lievita


    4) ASTRAI SEMPRE

    Se una cosa non la sai astrarre vuol dire che non l'hai capita. Crea e associa nuove metafore a quello che stai studiando. Sarà più facile capire e quindi anche ricordare.
    Devi fare tutti gli esercizi e ricreare anche esempi tuoi.

    AVVE CE LA PUOI FARE! Sorride

    Non fare sua fine dello spocchioso postino di Cin Cin con la sua cultura da wikipedianoIn lacrime
    Immagine postata dall'utente
    • Avatar
      ☺
      Scritto da
      alex.tg
      il 2010-11-16 02:26:00.0 alle 2010-11-16 02:26:00.0
      Trollate totali: 3444
      Re: Avve ti spiego come si studia
      > Devi fare tutti gli esercizi e ricreare anche
      > esempi
      > tuoi.

      Bisogna subito ottimizzare quell'esercizio che fa il blur di un'immagine.

      [La divisione e` un'operazione lenta. Perche` non farsi un vettore di 65536 elementi con i risultati delle divisioni per 25, e la somma dei quozienti al posto del quoziente della somma? Tanto una cosa del genere e` a scopi estetici, c'importa una sega se perde un pochino di precisione.]
      • Avatar
        ☺
        Scritto da
        Caccola
        il 2010-11-16 09:00:00.0 alle 2010-11-16 09:00:00.0
        Trollate totali: 4459
        Re: Avve ti spiego come si studia

        - Scritto da: alex.tg
        > > Devi fare tutti gli esercizi e ricreare anche
        > > esempi
        > > tuoi.
        >
        > Bisogna subito ottimizzare quell'esercizio che fa
        > il blur di
        > un'immagine.
        >
        > [La divisione e` un'operazione lenta. Perche` non
        > farsi un vettore di 65536 elementi con i
        > risultati delle divisioni per 25, e la somma dei
        > quozienti al posto del quoziente della somma?
        > Tanto una cosa del genere e` a scopi estetici,
        > c'importa una sega se perde un pochino di
        > precisione.]

        Alex sei troppo un grande Occhiolino
      • Avatar
        ☺
        Scritto da
        avvelentani
        Cubicolario
        il 2010-11-16 15:15:00.0 alle 2010-11-16 15:15:00.0
        Trollate totali: 18184
        Re: Avve ti spiego come si studia 
        #include<stdio.h>
#include<time.h>
#include<limits.h>

#define M 10000000
#define REP 50

int source[M];
int dest[M];
int divtab[65536];

int main(void) {
  int i, m;
  time_t start;

  for (i = 0; i < M; ++i) source[i] = ((double)rand() / INT_MAX) * 65535;
  for (i = 0; i < 65536; ++i) divtab[i] = i / 25;

  start = time(NULL);

  printf("Inizio divisioni: %ld\n", start);

  for (m = 0; m < REP; ++m) 
    for (i = 0; i < M; ++i) dest[i] = source[i] / 25;

  printf("Divisioni: %ld\n", time(NULL) - start);

  start = time(NULL);

  printf("Inizio lookups: %ld\n", start);

  for (m = 0; m < REP; ++m) 
    for (i = 0; i < M; ++i) dest[i] = divtab[source[i]];
    
  printf("Lookups: %ld\n", time(NULL) - start);

  return 0;
}


        Sul mio computer il secondo loop e` il 50% piu` lento del primo loop.
        I think happiness is love
        - Vladimir Putin
        • Avatar
          ☺
          Scritto da
          Caccola
          il 2010-11-16 18:32:00.0 alle 2010-11-16 18:32:00.0
          Trollate totali: 4459
          Re: Avve ti spiego come si studia

          - Scritto da: avvelentani
          > 
          > #include<stdio.h>
> #include<time.h>
> #include<limits.h>
> 
> #define M 10000000
> #define REP 50
> 
> int source[M];
> int dest[M];
> int divtab[65536];
> 
> int main(void) {
>   int i, m;
>   time_t start;
> 
>   for (i = 0; i < M; ++i) source[i] =
> ((double)rand() / INT_MAX) *
> 65535;
>   for (i = 0; i < 65536; ++i) divtab[i] = i / 25;
> 
>   start = time(NULL);
> 
>   printf("Inizio divisioni: %ld\n", start);
> 
>   for (m = 0; m < REP; ++m) 
>     for (i = 0; i < M; ++i) dest[i] = source[i] /
> 25;
> 
>   printf("Divisioni: %ld\n", time(NULL) - start);
> 
>   start = time(NULL);
> 
>   printf("Inizio lookups: %ld\n", start);
> 
>   for (m = 0; m < REP; ++m) 
>     for (i = 0; i < M; ++i) dest[i] =
> divtab[source[i]];
>     
>   printf("Lookups: %ld\n", time(NULL) - start);
> 
>   return 0;
> }
>

          >
          > Sul mio computer il secondo loop e` il 50% piu`
          > lento del primo
          > loop.

          Questo perché il tuo computer utilizza un coprocessore matematico.${vecchio_che_vive_nel_passato.jpg}
        • Avatar
          ☺
          Scritto da
          alex.tg
          il 2010-11-16 18:47:00.0 alle 2010-11-16 18:47:00.0
          Trollate totali: 3444
          Re: Avve ti spiego come si studia
          Proca miseria, perche` ti sei preso la briga di controllare? I computer moderni hanno la tendenza ad essere piu` veloci a fare che a ricordare. In lacrime

          Comunque, non saprei. Bisognerebbe che riprovassi in Linoleum, usando 16 bit per elemento della tabella di lookup e disponendo le istruzioni atomiche appropriatamente. Devo andare a fare la spesa, poi vedo un po' che salta fuori. Intuitivamente, la lookup table potrebbe ancora guadagnare qualcosa. Ma si`, se non ci perde nei ritardi di accesso alla memoria, guadagna probabilmente molto poco. Se pero` non controllavi ci facevo bella figura. Imbarazzato
          • Avatar
            Scritto da
            Non Autenticato
            il 2010-11-16 20:21:00.0 alle 2010-11-16 20:21:00.0
            Re: Avve ti spiego come si studia

            - Scritto da: alex.tg
            > Proca miseria, perche` ti sei preso la briga di
            > controllare? I computer moderni hanno la tendenza
            > ad essere piu` veloci a fare che a ricordare.
            > In lacrime
            >
            > Comunque, non saprei. Bisognerebbe che riprovassi
            > in Linoleum, usando 16 bit per elemento della
            > tabella di lookup e disponendo le istruzioni
            > atomiche appropriatamente. Devo andare a fare la
            > spesa, poi vedo un po' che salta fuori.
            > Intuitivamente, la lookup table potrebbe ancora
            > guadagnare qualcosa. Ma si`, se non ci perde nei
            > ritardi di accesso alla memoria, guadagna
            > probabilmente molto poco. Se pero` non
            > controllavi ci facevo bella figura.
            > Imbarazzato

            Non state tenendo conto dell'architettura.
            La lookup table rischia di non essere in cache e di dover essere sempre letta dalla RAM, che è di diversi ordini di grandezza più lenta della cache istruzioni del procio, che invece eseguirà molto più velocemente le operazioni del loop che effettua la divisione.

            Comunque dei cinque punti, a me mi fotte alla grande il 3° punto (la fretta).
            Il 1° l'ho acquisito nel tempo (ma abbastanza in fretta).
            Sugli altri due punti (soprattutto sul 4°) sono un mostro di mio Ficoso
            • Avatar
              Scritto da
              Non Autenticato
              il 2010-11-16 20:22:00.0 alle 2010-11-16 20:22:00.0
              Re: Avve ti spiego come si studia

              - Scritto da:
              >
              > - Scritto da: alex.tg
              > > Proca miseria, perche` ti sei preso la briga di
              > > controllare? I computer moderni hanno la
              > tendenza
              > > ad essere piu` veloci a fare che a ricordare.
              > > In lacrime
              > >
              > > Comunque, non saprei. Bisognerebbe che
              > riprovassi
              > > in Linoleum, usando 16 bit per elemento della
              > > tabella di lookup e disponendo le istruzioni
              > > atomiche appropriatamente. Devo andare a fare la
              > > spesa, poi vedo un po' che salta fuori.
              > > Intuitivamente, la lookup table potrebbe ancora
              > > guadagnare qualcosa. Ma si`, se non ci perde nei
              > > ritardi di accesso alla memoria, guadagna
              > > probabilmente molto poco. Se pero` non
              > > controllavi ci facevo bella figura.
              > > Imbarazzato
              >
              > Non state tenendo conto dell'architettura.
              > La lookup table rischia di non essere in cache e
              > di dover essere sempre letta dalla RAM, che è di
              > diversi ordini di grandezza più lenta della cache
              > istruzioni del procio, che invece eseguirà molto
              > più velocemente le operazioni del loop che
              > effettua la
              > divisione.
              >
              > Comunque dei cinque punti, a me mi fotte alla
              > grande il 3° punto (la
              > fretta).
              > Il 1° l'ho acquisito nel tempo (ma abbastanza in
              > fretta).
              > Sugli altri due punti (soprattutto sul 4°) sono
              > un mostro di mio
              > Ficoso

              "5 punti"... appunto, dicevo... la fretta.
            • Avatar
              ☺
              Scritto da
              alex.tg
              il 2010-11-16 20:33:00.0 alle 2010-11-16 20:33:00.0
              Trollate totali: 3444
              Re: Avve ti spiego come si studia
              > Non state tenendo conto dell'architettura.
              > La lookup table rischia di non essere in cache e
              > di dover essere sempre letta dalla RAM, che è di
              > diversi ordini di grandezza più lenta della cache
              > istruzioni del procio, che invece eseguirà molto
              > più velocemente le operazioni del loop che
              > effettua la
              > divisione.

              Si`, e` un grosso rischio con un'operazione cosi` semplice.
              Sul mio iMac Core2 Duo 2800 pero` questo programmino Linoleum:

              "libraries"

    hmi/conout;
    math/random;
    utils/msecs24;

"directors"

    unit = 32;
    display status = engage;

"constants"

    k = 20 000 000;    (di elementi)

"variables"

    t filling source range = { filling_source_range...\lf } : 8;
    t filling lookup table = { filling_lookup_table...\lf } : 8;
    t testing integer maths = { testing_integer_maths...\lf } : 8;
    t testing lookups = { testing_lookups...\lf } : 8;
    t elapsed maths time = { elapsed_maths_time:_ } : 8;
    t elapsed lookups time = { elapsed_lookups_time:_ } : 8;
    t lf = { \lf } : 8;

"workspace"

    r source * k;
    r target * k;
    r lookup * [65536 multiplied 16] as bit size;    (65536 valori di 16 bit)

    n start time;
    n stop time;

"programme"

    mt . sgenrand: 12345;

    conout . t say: t filling source range;

        a # a;
        b = k;
        
        "filling source range"

            [r source [a]] <- mt . i rnd;
            [r source [a]] & ffffh;

            + a;

        ? b ^ filling source range;

    conout . t say: t filling lookup table;

        a # a;
        b # b;
        c = 65536 div 2;

        "filling lookup table"

            as,

                d = a;
                d / 25;

            [r lookup [b]] = d;

            + a;

            as,

                d = a;
                d / 25;
            @    d < 16;
            
            [r lookup [b]] | d;

            + a;
            + b;

        ? c ^ filling lookup table;

    conout . t say: t testing integer maths;

    [n start time] <- msecs 24;

        a # a;
        b = k;

        "testing integer maths"

            as,

                c = [r source [a]];
                c / 25;

            [r target [a]] = c;

            + a;

        ? b ^ testing integer maths;

    [n stop time] <- msecs 24;
    [n stop time] - [n start time];

    conout . t say: t elapsed maths time;
    conout . n say: [n stop time];
    conout . t say: t lf;

    conout . t say: t testing lookups;

    [n start time] <- msecs 24;

        a # a;
        b = k;

        "testing lookups"

            as,

                c = [r source [a]];
                d = c;

            '    d > 1;
                c & 1;

            @    c < 4;
                e = [r lookup [d]];
                
            @    e > c;
                + a;

                e & ffffh;
                - b;

            [r target [a minus 1]] = e;

        ? b ! zero > testing lookups;

    [n stop time] <- msecs 24;
    [n stop time] - [n start time];

    conout . t say: t elapsed lookups time;
    conout . n say: [n stop time];
    conout . t say: t lf;

    as,

        [thread command] = suspend thread;
        [thread suspend timeout] = 10 000 (milliseconds);

    isocall;

    end;


              Si direbbe mostrare che la lookup table e` piu` veloce:

              filling source range...
filling lookup table...
testing integer maths...
elapsed maths time: 109
testing lookups...
elapsed lookups time: 47


              Probabilmente l'ottimizzazione migliore in questo caso e` procedere a moltiplicare e shiftare come fa il gcc: breve in esecuzione, e non rischia ritardi di accesso alla memoria. Ma la lookup table sembra comunque ancora un po' piu` veloce della divisione intera nvda e crvda, quando viene organizzata a basso livello, quindi anche la mia ottimizzazione era relativamente valida.

              Se volete provare vi uploado l'eseguibile, oppure scaricate Linoleum e ve lo compilate.
              • Avatar
                Scritto da
                Non Autenticato
                il 2010-11-16 20:38:00.0 alle 2010-11-16 20:38:00.0
                Re: Avve ti spiego come si studia

                - Scritto da: alex.tg
                > > Non state tenendo conto dell'architettura.
                > > La lookup table rischia di non essere in cache e
                > > di dover essere sempre letta dalla RAM, che è di
                > > diversi ordini di grandezza più lenta della
                > cache
                > > istruzioni del procio, che invece eseguirà molto
                > > più velocemente le operazioni del loop che
                > > effettua la
                > > divisione.
                >
                > Si`, e` un grosso rischio con un'operazione cosi`
                > semplice.
                > Sul mio iMac Core2 Duo 2800 pero` questo
                > programmino
                > Linoleum:
                >
                > 
                "libraries"
> 
>     hmi/conout;
>     math/random;
>     utils/msecs24;
> 
> "directors"
> 
>     unit = 32;
>     display status = engage;
> 
> "constants"
> 
>     k = 20 000 000;    (di elementi)
> 
> "variables"
> 
>     t filling source range = {
> filling_source_range...\lf } :
> 8;
>     t filling lookup table = {
> filling_lookup_table...\lf } :
> 8;
>     t testing integer maths = {
> testing_integer_maths...\lf } :
> 8;
>     t testing lookups = { testing_lookups...\lf } :
> 8;
>     t elapsed maths time = { elapsed_maths_time:_ }
> :
> 8;
>     t elapsed lookups time = {
> elapsed_lookups_time:_ } :
> 8;
>     t lf = { \lf } : 8;
> 
> "workspace"
> 
>     r source * k;
>     r target * k;
>     r lookup * [65536 multiplied 16] as bit
> size;    (65536 valori di 16
> bit)
> 
>     n start time;
>     n stop time;
> 
> "programme"
> 
>     mt . sgenrand: 12345;
> 
>     conout . t say: t filling source range;
> 
>         a # a;
>         b = k;
>         
>         "filling source range"
> 
>             [r source [a]] <- mt . i rnd;
>             [r source [a]] & ffffh;
> 
>             + a;
> 
>         ? b ^ filling source range;
> 
>     conout . t say: t filling lookup table;
> 
>         a # a;
>         b # b;
>         c = 65536 div 2;
> 
>         "filling lookup table"
> 
>             as,
> 
>                 d = a;
>                 d / 25;
> 
>             [r lookup [b]] = d;
> 
>             + a;
> 
>             as,
> 
>                 d = a;
>                 d / 25;
>             @    d < 16;
>             
>             [r lookup [b]] | d;
> 
>             + a;
>             + b;
> 
>         ? c ^ filling lookup table;
> 
>     conout . t say: t testing integer maths;
> 
>     [n start time] <- msecs 24;
> 
>         a # a;
>         b = k;
> 
>         "testing integer maths"
> 
>             as,
> 
>                 c = [r source [a]];
>                 c / 25;
> 
>             [r target [a]] = c;
> 
>             + a;
> 
>         ? b ^ testing integer maths;
> 
>     [n stop time] <- msecs 24;
>     [n stop time] - [n start time];
> 
>     conout . t say: t elapsed maths time;
>     conout . n say: [n stop time];
>     conout . t say: t lf;
> 
>     conout . t say: t testing lookups;
> 
>     [n start time] <- msecs 24;
> 
>         a # a;
>         b = k;
> 
>         "testing lookups"
> 
>             as,
> 
>                 c = [r source [a]];
>                 d = c;
> 
>             '    d > 1;
>                 c & 1;
> 
>             @    c < 4;
>                 e = [r lookup [d]];
>                 
>             @    e > c;
>                 + a;
> 
>                 e & ffffh;
>                 - b;
> 
>             [r target [a minus 1]] = e;
> 
>         ? b ! zero > testing lookups;
> 
>     [n stop time] <- msecs 24;
>     [n stop time] - [n start time];
> 
>     conout . t say: t elapsed lookups time;
>     conout . n say: [n stop time];
>     conout . t say: t lf;
> 
>     as,
> 
>         [thread command] = suspend thread;
>         [thread suspend timeout] = 10 000
> (milliseconds);
> 
>     isocall;
> 
>     end;

                >
                > Si direbbe mostrare che la lookup table e` piu`
                > veloce:
                >
                > 
                filling source range...
> filling lookup table...
> testing integer maths...
> elapsed maths time: 109
> testing lookups...
> elapsed lookups time: 47

                >
                > Probabilmente l'ottimizzazione migliore in questo
                > caso e` procedere a moltiplicare e shiftare come
                > fa il gcc: breve in esecuzione, e non rischia
                > ritardi di accesso alla memoria. Ma la lookup
                > table sembra comunque ancora un po' piu` veloce
                > della divisione intera nvda e crvda,
                > quando viene organizzata a basso livello, quindi
                > anche la mia ottimizzazione era relativamente
                > valida.
                >
                > Se volete provare vi uploado l'eseguibile, oppure
                > scaricate Linoleum e ve lo
                > compilate.

                In lacrime Non capirò mai nulla di algoritmi, per me o un problema dò una formula o è irrisolvibile In lacrime
                • Avatar
                  ☺
                  Scritto da
                  alex.tg
                  il 2010-11-16 20:45:00.0 alle 2010-11-16 20:45:00.0
                  Trollate totali: 3444
                  Re: Avve ti spiego come si studia
                  > In lacrime Non capirò mai nulla di algoritmi, per me o
                  > un problema dò una formula o è irrisolvibile
                  > In lacrime

                  E` un listato Linoleum che utilizza rotazioni e shift binari per accedere a una tabella di elementi di 32 bit suddivisi in words alte e basse per tenere in memoria due risultati per elemento, onde dimezzare la dimensione della tabella in memoria per aumentare le prestazioni. Inoltre nel ciclo di lookup fa uso di ottimizzazioni a basso livello sulla disposizione e l'accoppiabilita` delle istruzioni che operano tramite registri su (almeno) due pipelines di esecuzione (per esempio incrementa l'indice dei vettori sorgente e destinazione prima di depositare il risultato nel vettore destinazione, quindi aggiunge uno spiazzamento immediato di meno 1, in [r target [a minus 1]] = e.

                  Insomma, non e` che uno debba prendersela troppo se non risulta ehm... di immediata comprensibilita. Imbarazzato
                  • Avatar
                    Scritto da
                    Non Autenticato
                    il 2010-11-16 20:59:00.0 alle 2010-11-16 20:59:00.0
                    Re: Avve ti spiego come si studia

                    - Scritto da: alex.tg
                    > > In lacrime Non capirò mai nulla di algoritmi, per me o
                    > > un problema dò una formula o è irrisolvibile
                    > > In lacrime
                    >
                    > E` un listato Linoleum che utilizza rotazioni e
                    > shift binari per accedere a una tabella di
                    > elementi di 32 bit suddivisi in words alte e
                    > basse per tenere in memoria due risultati per
                    > elemento, onde dimezzare la dimensione della
                    > tabella in memoria per aumentare le prestazioni.
                    > Inoltre nel ciclo di lookup fa uso di
                    > ottimizzazioni a basso livello sulla disposizione
                    > e l'accoppiabilita` delle istruzioni che operano
                    > tramite registri su (almeno) due pipelines di
                    > esecuzione (per esempio incrementa l'indice dei
                    > vettori sorgente e destinazione prima di
                    > depositare il risultato nel vettore destinazione,
                    > quindi aggiunge uno spiazzamento immediato di
                    > meno 1, in [r target [a minus 1]] =
                    > e.
                    >
                    > Insomma, non e` che uno debba prendersela troppo
                    > se non risulta ehm... di immediata
                    > comprensibilita.
                    > Imbarazzato

                    Se lo scrivessi in assembler...
    • Avatar
      Scritto da
      Non Autenticato
      il 2010-11-16 08:44:00.0 alle 2010-11-16 08:44:00.0
      Re: Avve ti spiego come si studia

      - Scritto da:
      > 1) DEVI ESSERE ONESTO CON TE STESSO
      >
      > Se una cosa non l'hai capita devi stare lì finché
      > non ti è chiara. Anche se poi scoprirai che non
      > era importante come argomento, ti toglie
      > sicurezza andare avanti senza capire, perché
      > rimarrai sempre col dubbio di non avere il
      > background adatto per capire l'argomento
      > successivo.
      >
      > 2) NON DEVI FARE UNA PASSEGGIATA NEL TESTO CI
      > DEVI PASSARE
      > ATTRAVERSO
      >
      > Studiare un libro tecnico non è come leggere un
      > romanzo che vai avanti come se stessi camminando.
      > Quando studi il libro lo devi attraversare in
      > ogni suo punto. Non è un percorso lineare lo
      > studio è un andare avanti e indietro
      > continuamente.
      >
      > 3) NON FARTI PRENDERE DALLA FRETTA
      >
      > Studiare richiede lentezza, più vai di fretta e
      > più sarà facile distrarsi. Quante volte ti è
      > capitato di leggere una cosa, andare avanti e
      > renderti conto che stavi pensando ad altro e però
      > avevi già passato la pagina. Non saltare le cose
      > e non cercare di apprendere il più in fretta
      > possibile. L'apprendimento è un processo naturale
      > e richiede tempo, come una torta che
      > lievita
      >
      >
      > 4) ASTRAI SEMPRE
      >
      > Se una cosa non la sai astrarre vuol dire che non
      > l'hai capita. Crea e associa nuove metafore a
      > quello che stai studiando. Sarà più facile capire
      > e quindi anche
      > ricordare.
      > Devi fare tutti gli esercizi e ricreare anche
      > esempi
      > tuoi.
      >
      > AVVE CE LA PUOI FARE! Sorride
      >
      > Non fare sua fine dello spocchioso postino di Cin
      > Cin con la sua cultura da
      > wikipedianoIn lacrime
      > [img]http://img339.imageshack.us/img339/5374/posti

      Complimenti all'anonimo di questo post,uno dei pochi post utilissimi ed intelligenti di questo forum Sorride
    • Avatar
      Scritto da
      Non Autenticato
      il 2010-11-16 22:00:00.0 alle 2010-11-16 22:00:00.0
      Re: Avve ti spiego come si studia

      - Scritto da:
      > 1) DEVI ESSERE ONESTO CON TE STESSO
      >
      > Se una cosa non l'hai capita devi stare lì finché
      > non ti è chiara. Anche se poi scoprirai che non
      > era importante come argomento, ti toglie
      > sicurezza andare avanti senza capire, perché
      > rimarrai sempre col dubbio di non avere il
      > background adatto per capire l'argomento
      > successivo.
      >
      > 2) NON DEVI FARE UNA PASSEGGIATA NEL TESTO CI
      > DEVI PASSARE
      > ATTRAVERSO
      >
      > Studiare un libro tecnico non è come leggere un
      > romanzo che vai avanti come se stessi camminando.
      > Quando studi il libro lo devi attraversare in
      > ogni suo punto. Non è un percorso lineare lo
      > studio è un andare avanti e indietro
      > continuamente.
      >
      > 3) NON FARTI PRENDERE DALLA FRETTA
      >
      > Studiare richiede lentezza, più vai di fretta e
      > più sarà facile distrarsi. Quante volte ti è
      > capitato di leggere una cosa, andare avanti e
      > renderti conto che stavi pensando ad altro e però
      > avevi già passato la pagina. Non saltare le cose
      > e non cercare di apprendere il più in fretta
      > possibile. L'apprendimento è un processo naturale
      > e richiede tempo, come una torta che
      > lievita
      >
      >
      > 4) ASTRAI SEMPRE
      >
      > Se una cosa non la sai astrarre vuol dire che non
      > l'hai capita. Crea e associa nuove metafore a
      > quello che stai studiando. Sarà più facile capire
      > e quindi anche
      > ricordare.
      > Devi fare tutti gli esercizi e ricreare anche
      > esempi
      > tuoi.
      >
      > AVVE CE LA PUOI FARE! Sorride
      >
      > Non fare sua fine dello spocchioso postino di Cin
      > Cin con la sua cultura da
      > wikipedianoIn lacrime

      quante cazzate

      prendi il libro
      leggilo e comprendi quello che dice
      poi studiane un pezzo e ripeti

      looppa la riga precedente fino a che non hai finito

      se ci sono definizioni, regole, leggi, teoremi, dimostrazioni scrivi e riscrivi tutto fino controllando che tutto quello che hai scritto sia corretto

      poi fatti un giro di una mezzora

      ritorna due punti sopra e ripeti finchè non riesci a scrivere correttamente le regole, le leggi, le definizioni, le dimostrazioni in tutti i loro punti
<softv>

Pagina generata in 130 millisecondi

Utenti attivi: 14 nell'ultimo minuto, 26 negli ultimi cinque minuti, 41 negli ultimi 15 minuti