Mostra notizie nelle discussioni
  • Avatar
    ☺
    Scritto da
    altg
    utente che non utiene
    il 2014-10-07 13:15:00.0 alle 2014-10-07 13:15:00.0
    Trollate totali: 11540
    Come si presenta ora nell'insieme...
    Il programmino del punto che rimbalza:
    Immagine postata dall'utente

    Usa l'implementazione "canvas" della classe astratta "raster". La keyword "as" fa il typecast sul registro "p", dicendogli che punta a un'istanza di canvas. In java, l'equivalente sarebbe una variabile di riferimento dichiarata come "tipo nome" ma non assegnata a un "new" qualcosa.

    Un "raster" e` definito cosi`:

    Immagine postata dall'utente

    E gli unici metodi che implementa sono degli accessors per le dimensioni in pixels, che appunto sono le uniche cose che al momento hanno in comune canvas e bitmap, i due tipi concreti di raster. Gli altri sono signatures per metodi non implementati, che finiscono tutti in un'unica istruzione "leave" che ritorna al chiamante senza fare nulla. I campi dell'istanza sono descritti dai "count". Count e` un enumeratore progressivo: se non gli si dice diversamente, parte da zero e assegna la prima named constant a 0, la seconda a 1 e cosi` via. L'ultimo count da` la dimensione dell'istanza in unita` (cioe` in words del microprocessore).

    L'implementazione "canvas", per esempio, poi implementa il costruttore "Create" cosi`:

    Immagine postata dall'utente

    facendo l'override della inlet "Create" nel nameset "raster", che e` esteso dal nameset "canvas" (per via della dichiarazione "nameset canvas extends raster"). Se dovesse dichiarare altri campi membri, dichiarerebbe altri count dopo "count from nSizeOfInstance" (risolta automaticamente nel nameset "raster", e la ridichiarerebbe (nel suo nameset) alla fine delle dichiarazioni "count".

    Per curiosita`, canvas::Create alloca un canvassino di 1x1 pixels di default, se non viene ridimensionato, sicche` il bordo destro e inferiore sono tutti e due zero e width e height sono 1. Per ridimensionarlo c'e` canvas::SizeToByPixels (chiamato come "Size To larghezza;altezza Pixels"), oppure c'e` il costruttore alternativo canvas::CreateByPixels ("Create larghezza By altezza Pixels") che istanzia canvas e poi chiama subito (o meglio, si lascia "cadere" nel codice di) SizeToByPixels. E quello crea un canvas che inizialmente ha le dimensioni volute.

    A me non sembra venuto male.
    A me sembra esteticamente bello. Imbarazzato
    • Avatar
      Scritto da
      Non Autenticato
      il 2014-10-07 14:25:26.0 alle 2014-10-07 14:25:26.0
      Re: Come si presenta ora nell'insieme...
      Scritto da: altg
      > Il programmino del punto che rimbalza:
      > Immagine postata dall'utente
      >
      > Usa l'implementazione "canvas" della classe astratta "raster". La keyword "as" fa il typecast sul registro "p", dicendogli che punta a un'istanza di canvas. In java, l'equivalente sarebbe una variabile di riferimento dichiarata come "tipo nome" ma non assegnata a un "new" qualcosa.
      >
      > Un "raster" e` definito cosi`:
      >
      > Immagine postata dall'utente
      >
      > E gli unici metodi che implementa sono degli accessors per le dimensioni in pixels, che appunto sono le uniche cose che al momento hanno in comune canvas e bitmap, i due tipi concreti di raster. Gli altri sono signatures per metodi non implementati, che finiscono tutti in un'unica istruzione "leave" che ritorna al chiamante senza fare nulla. I campi dell'istanza sono descritti dai "count". Count e` un enumeratore progressivo: se non gli si dice diversamente, parte da zero e assegna la prima named constant a 0, la seconda a 1 e cosi` via. L'ultimo count da` la dimensione dell'istanza in unita` (cioe` in words del microprocessore).
      >
      > L'implementazione "canvas", per esempio, poi implementa il costruttore "Create" cosi`:
      >
      > Immagine postata dall'utente
      >
      > facendo l'override della inlet "Create" nel nameset "raster", che e` esteso dal nameset "canvas" (per via della dichiarazione "nameset canvas extends raster"). Se dovesse dichiarare altri campi membri, dichiarerebbe altri count dopo "count from nSizeOfInstance" (risolta automaticamente nel nameset "raster", e la ridichiarerebbe (nel suo nameset) alla fine delle dichiarazioni "count".
      >
      > Per curiosita`, canvas::Create alloca un canvassino di 1x1 pixels di default, se non viene ridimensionato, sicche` il bordo destro e inferiore sono tutti e due zero e width e height sono 1. Per ridimensionarlo c'e` canvas::SizeToByPixels (chiamato come "Size To larghezza;altezza Pixels"), oppure c'e` il costruttore alternativo canvas::CreateByPixels ("Create larghezza By altezza Pixels") che istanzia canvas e poi chiama subito (o meglio, si lascia "cadere" nel codice di) SizeToByPixels. E quello crea un canvas che inizialmente ha le dimensioni volute.
      >
      > A me non sembra venuto male.
      > A me sembra esteticamente bello. Imbarazzato

      Aspettiamo che sassofono finisca di mangiare.
    • Avatar
      ☺
      Scritto da
      altg
      utente che non utiene
      il 2014-10-07 14:26:01.0 alle 2014-10-07 14:26:01.0
      Trollate totali: 11540
      Re: Come si presenta ora nell'insieme...
      Ah, dimenticavo: sapete che per caso m'e` venuto anche un modo abbastanza naturale, anche se non previsto espressamente dal compilatore, per l'overloading dei metodi? Deriva dal fatto che una inlet (e` il termine che indica una routine in generale: puo` essere subroutine, funzione, metodo... a seconda di come si comporta e di come la si tratta) e` dichiarata con una signature semantica, che indica insieme alle keywords che compongono il nome della inlet anche dove stanno gli argomenti.

      Ora, queste signatures possono contenere un solo segno di "punteggiatura": il punto e virgola. Come nel caso di "Plot at m;n In Color q". Va da se` che se scrivo "Antani x" oppure "Antani x;y" ottengo due metodi diversi che hanno visualmente lo stesso nome, eccetto che per il compilatore non sono la stessa cosa, e quindi nella symbols map li risolve a due simboli diversi. Ergo, se uso dei punti e virgola per marcare il numero di argomenti, ottengo l'equivalente dell'overloading. Ma sara` carino? Imbarazzato
      • Avatar
        ☺
        Scritto da
        ::1
        il 2014-10-07 14:28:09.0 alle 2014-10-07 14:28:09.0
        Trollate totali: 12321
        Re: Come si presenta ora nell'insieme...
        Scritto da: altg
        > Ah, dimenticavo: sapete che per caso m'e` venuto anche un modo abbastanza naturale, anche se non previsto espressamente dal compilatore, per l'overloading dei metodi? Deriva dal fatto che una inlet (e` il termine che indica una routine in generale: puo` essere subroutine, funzione, metodo... a seconda di come si comporta e di come la si tratta) e` dichiarata con una signature semantica, che indica insieme alle keywords che compongono il nome della inlet anche dove stanno gli argomenti.
        >
        > Ora, queste signatures possono contenere un solo segno di "punteggiatura": il punto e virgola. Come nel caso di "Plot at m;n In Color q". Va da se` che se scrivo "Antani x" oppure "Antani x;y" ottengo due metodi diversi che hanno visualmente lo stesso nome, eccetto che per il compilatore non sono la stessa cosa, e quindi nella symbols map li risolve a due simboli diversi. Ergo, se uso dei punti e virgola per marcare il numero di argomenti, ottengo l'equivalente dell'overloading. Ma sara` carino? Imbarazzato

        stai pericolosamente scivolando verso il befunge e il malbolge
        Young professional woman and busy mom.
        • Avatar
          Scritto da
          Non Autenticato
          il 2014-10-07 14:37:18.0 alle 2014-10-07 14:37:18.0
          Re: Come si presenta ora nell'insieme...
          Scritto da: ::1
          > Scritto da: altg
          > > Ah, dimenticavo: sapete che per caso m'e` venuto anche un modo abbastanza naturale, anche se non previsto espressamente dal compilatore, per l'overloading dei metodi? Deriva dal fatto che una inlet (e` il termine che indica una routine in generale: puo` essere subroutine, funzione, metodo... a seconda di come si comporta e di come la si tratta) e` dichiarata con una signature semantica, che indica insieme alle keywords che compongono il nome della inlet anche dove stanno gli argomenti.
          > >
          > > Ora, queste signatures possono contenere un solo segno di "punteggiatura": il punto e virgola. Come nel caso di "Plot at m;n In Color q". Va da se` che se scrivo "Antani x" oppure "Antani x;y" ottengo due metodi diversi che hanno visualmente lo stesso nome, eccetto che per il compilatore non sono la stessa cosa, e quindi nella symbols map li risolve a due simboli diversi. Ergo, se uso dei punti e virgola per marcare il numero di argomenti, ottengo l'equivalente dell'overloading. Ma sara` carino? Imbarazzato
          >
          > stai pericolosamente scivolando verso il befunge e il malbolge

          è la fallacia del piano inclinato
        • Avatar
          ☺
          Scritto da
          altg
          utente che non utiene
          il 2014-10-07 14:41:24.0 alle 2014-10-07 14:41:24.0
          Trollate totali: 11540
          Re: Come si presenta ora nell'insieme...
          > > Ah, dimenticavo: sapete che per caso m'e` venuto anche un modo abbastanza naturale, anche se non previsto espressamente dal compilatore, per l'overloading dei metodi? Deriva dal fatto che una inlet (e` il termine che indica una routine in generale: puo` essere subroutine, funzione, metodo... a seconda di come si comporta e di come la si tratta) e` dichiarata con una signature semantica, che indica insieme alle keywords che compongono il nome della inlet anche dove stanno gli argomenti.
          > >
          > > Ora, queste signatures possono contenere un solo segno di "punteggiatura": il punto e virgola. Come nel caso di "Plot at m;n In Color q". Va da se` che se scrivo "Antani x" oppure "Antani x;y" ottengo due metodi diversi che hanno visualmente lo stesso nome, eccetto che per il compilatore non sono la stessa cosa, e quindi nella symbols map li risolve a due simboli diversi. Ergo, se uso dei punti e virgola per marcare il numero di argomenti, ottengo l'equivalente dell'overloading. Ma sara` carino? Imbarazzato
          >
          > stai pericolosamente scivolando verso il befunge e il malbolge

          Seee.... e` chiarissimo. Certo e` pur sempre assembly, cross-platform e decorato, ma checcazzo, sempre assembly, e di certo non apparira` mai come se fosse Visual Basic. Fantasma
      • Avatar
        Scritto da
        Non Autenticato
        il 2014-10-07 14:39:41.0 alle 2014-10-07 14:39:41.0
        Re: Come si presenta ora nell'insieme...
        > inlet (e` il termine che indica una routine in generale: puo` essere subroutine, funzione, metodo...

        e qui l'associazione come salta fuori?
        • Avatar
          ☺
          Scritto da
          altg
          utente che non utiene
          il 2014-10-07 14:47:31.0 alle 2014-10-07 14:47:31.0
          Trollate totali: 11540
          Re: Come si presenta ora nell'insieme...
          > > inlet (e` il termine che indica una routine in generale: puo` essere subroutine, funzione, metodo...
          >
          > e qui l'associazione come salta fuori?

          Inlet - ingresso.
          Ingresso principale in una sezione di codice eseguibile di natura, a priori, ignota.

          Quindi ne` subroutine (che implica che non ritorni un valore prevedibile), ne` funzione (che implica che ritorni un valore prevedibile), ne` metodo (che implica l'istanza di un oggetto), ne` procedura (che nella tradizione degli assemblers, implica uno stack frame), ne` qualunque altra cosa che chi si riferisce a qualcosa come a una "inlet" potrebbe aspettarsi. Serve a rimarcare, con un termine non sporcato da significati storici precedenti, il fatto che una inlet e` un termine che indica niente di piu` che un simbolo che puoi invocare in qualche modo.

          E` lo stesso principio per cui le word della CPU si chiamano unita`.
          Perche` word e` storicamente (malamente) associato con un valore di esattamente 16 bit.
      • Avatar
        Scritto da
        Non Autenticato
        il 2014-10-07 14:41:15.0 alle 2014-10-07 14:41:15.0
        Re: Come si presenta ora nell'insieme...
        Scritto da: altg
        > Ah, dimenticavo: sapete che per caso m'e` venuto anche un modo abbastanza naturale, anche se non previsto espressamente dal compilatore, per l'overloading dei metodi? Deriva dal fatto che una inlet (e` il termine che indica una routine in generale: puo` essere subroutine, funzione, metodo... a seconda di come si comporta e di come la si tratta) e` dichiarata con una signature semantica, che indica insieme alle keywords che compongono il nome della inlet anche dove stanno gli argomenti.
        >
        > Ora, queste signatures possono contenere un solo segno di "punteggiatura": il punto e virgola. Come nel caso di "Plot at m;n In Color q". Va da se` che se scrivo "Antani x" oppure "Antani x;y" ottengo due metodi diversi che hanno visualmente lo stesso nome, eccetto che per il compilatore non sono la stessa cosa, e quindi nella symbols map li risolve a due simboli diversi. Ergo, se uso dei punti e virgola per marcare il numero di argomenti, ottengo l'equivalente dell'overloading. Ma sara` carino? Imbarazzato

        Ma c'è qualcosa che sia vagamente simile alla versione precedente?
        • Avatar
          ☺
          Scritto da
          altg
          utente che non utiene
          il 2014-10-07 14:56:36.0 alle 2014-10-07 14:56:36.0
          Trollate totali: 11540
          Re: Come si presenta ora nell'insieme...
          > > Ah, dimenticavo: sapete che per caso m'e` venuto anche un modo abbastanza naturale, anche se non previsto espressamente dal compilatore, per l'overloading dei metodi? Deriva dal fatto che una inlet (e` il termine che indica una routine in generale: puo` essere subroutine, funzione, metodo... a seconda di come si comporta e di come la si tratta) e` dichiarata con una signature semantica, che indica insieme alle keywords che compongono il nome della inlet anche dove stanno gli argomenti.
          > >
          > > Ora, queste signatures possono contenere un solo segno di "punteggiatura": il punto e virgola. Come nel caso di "Plot at m;n In Color q". Va da se` che se scrivo "Antani x" oppure "Antani x;y" ottengo due metodi diversi che hanno visualmente lo stesso nome, eccetto che per il compilatore non sono la stessa cosa, e quindi nella symbols map li risolve a due simboli diversi. Ergo, se uso dei punti e virgola per marcare il numero di argomenti, ottengo l'equivalente dell'overloading. Ma sara` carino? Imbarazzato
          >
          > Ma c'è qualcosa che sia vagamente simile alla versione precedente?

          Vediamo...

          Le istruzioni seguono ancora la convenzione che l'operando di sinistra e` la destinazione, oltre che una delle sorgenti, di un'operazione, cioe` x = x + 1 diventa x + 1.

          L'indirizzamento e` ancora n-flat, cioe` basato su locazioni numerate progressivamente ciascuna della dimensione di un unita` (e non di un byte: n-flat significa modello d'indirizzamento flat con granularita` n, in contrasto con il normale modello flat che ha granularita` di 8 bit).

          Il modulo di run-time e` essenzialmente lo stesso: l'IsoKernel parser funziona come prima (eccetto l'acquisizione di un mutex per rendere possibile condividerlo in multithreading, anche se la cosa migliore in termini prestazionali resterebbe delegare il maggior numero possibile di chiamate di sistema a un singolo thread, cioe` non creare race conditions sull'IsoKernel in primo luogo).

          La mappatura dei registri non e` molto diversa, i modi d'indirizzamento (diretto, indiretto a registro singolo con spiazzamento costante, immediato, e registro) sono gli stessi.

          Insomma ce ne sono parecchi di punti in comune, secondo me in essenza e` ancora se` stesso, ma con una superficie esposta decisamene migliore.
<softv>

Pagina generata in 108 millisecondi

Utenti attivi: 8 nell'ultimo minuto, 21 negli ultimi cinque minuti, 42 negli ultimi 15 minuti