Forum libero

> > >
> > >
> > > Avevo cominciato il modellino, idealmente molto approssimato, per vedere come stavano le pareti ridipinte con decorazioni di vari colori. Poi mi sono lasciato prendere la mano e ho cominciato (ma non finito) a riprodurre tutto. Se vi venisse in mente di glorificare la vostra stanzetta in modo analogo, postate pure 'che` la gente e` curiosa. Quando ho finito carico il modello cosi` ci si puo` girare dentro in Sketchup.
> >
> > un belink al file sarebbe oro
>
> Volevo aggiungere almeno i dettagli e le suppellettili principali prima di caricare il file col modello. Però vabbé, a grande richiesta domani lo metto online.

Ok, questo e` il link al modello, cosi` com'e` ora:
http://anynowhere.com/personal/room/room5.skp

Questo e` un primo piano della replica del pannello sinistro della scrivania:


Ma c'e` ancora un bel po' di roba da disegnare: il pannello sinistro, il mouse, la tastiera coperta (cosi` non sto a modellare la tastiera vera e propria, fare tutti i tasti sarebbe una palla), il mouse, i quadri alle pareti, i soprammobili sulle mensole... ah gia`, anche le ante della porta-finestra...

> >
> >
> > Avevo cominciato il modellino, idealmente molto approssimato, per vedere come stavano le pareti ridipinte con decorazioni di vari colori. Poi mi sono lasciato prendere la mano e ho cominciato (ma non finito) a riprodurre tutto. Se vi venisse in mente di glorificare la vostra stanzetta in modo analogo, postate pure 'che` la gente e` curiosa. Quando ho finito carico il modello cosi` ci si puo` girare dentro in Sketchup.
>
> S'è evoluto parecchio sto ketchup: il pavimento è realistico.

Era una stock texture (di serie col programma). Io ho solo ritoccato colori, posizione e dimensioni, allineandola con cura in modo che le piastrelle ricalcassero quelle del vero pavimento, anche perche` la griglia risultante, a occhio, mi aiuta a stimare dove vanno i mobili. Volendo potrei fare una foto alle piastrelle e mettere quella, ma e` abbastanza simile. Le texture da foto le serbo per quando riprodurro` i quadri alle pareti.

> Comunque vedo che lo sai usare molto bene.

Ci avro` messo forse tre ore in tutto. Sketchup e` molto semplice da usare per forme rettilinee, e la mia stanza e` piena di forme rettilinee.

**Modificato dall'autore il 05.06.2014 00:19**

> > Se per "stare in quella fascia" vanno bene anche perdite di performances spesso tra il 200 e il 300 percento, allora basta.
>
> Palle.
>
> > > > Ma se in Lino 3 scrivi:
> > > >
> > > >

> > > > % = b;
> > > > % + c;
> > > > leave;
> > > > 

> > > >
> > > > ottieni:
> > > >
> > > >

> > > > mov ebp, ebx
> > > > add ebp, ecx
> > > > ret
> > > > 

>
> In C
>
>

> int f(int a, int b) {
> return a + b;
> }
> 

>
> produce quel codice li` e fa constant folding.

Immagino usi EAX per il ritorno, ma che il codice sia equivalente. E` un esempio semplice. Dovresti provare a tradurre per un po' listatini C in assembly, a mano, e fare benchmarking, poi lo vedi.

> > > > Vedi cosa intendo per "acerbo"?
> > > > Questo sta facendo il percorso a scossoni di Linoleum.
> > > >
> > > > Classes were also removed, replaced by a combination of implementations and structured types.
> > > >
> > > > Cioe`, ha cambiato interamente object model tra una versione e l'altra.
> > > > Che cavolo ci vorresti fare finche` la sua impostazione e` cosi` volatile?
> > >
> > > Stai usando nodejs che è anche lui alla versione 0.10.x
> >
> > Colpa tua!
> > Comunque la tentazione era troppo forte.
> >
> > > Rust nasce come sostituto del c++, aggiungendo strati di verifiche statiche che intercettano a compile time un sacco di errori con messaggi significativi (hai mai visto un errore di compilazione c++ con i templates? io si ) e alcuni vantaggi come multithreading efficiente (threading m:n), type system forte (se non sbaglio è il modello di scala a sua volta ispirato a haskell),
> >
> > La wiki dice che e` anche "inferred"?
> > Mi sono chiesto en passand come faccia ad essere forte ed inferred insieme...
>
> Nel senso che il tipo delle variabili è sempre chiaro, esplicitamente o dedotto che sia; anche haskell ha un type system considerato tra i più forti (non puoi castare niente con niente, anche le conversioni di primitivi sono esplicite), ma ha la type inference. Quando una espressione è dubbia viene dedotto all'ultimo momento il suo tipo.

Ah, interessante.
Boh. Personalmente prediligo l'untyped o lo strong in tutti i casi.
Sono un tipo che pensa in bianco e nero.

> > > l'ownership dei puntatori (che ne determina il lifetime, e di conseguenza intercetta i memory leak a compile time), costrutti sintattici utili (pattern matching, return implicito dell'ultima espressione, oltre agli ormai immancabili closures, for-each, ...).
> >
> > In pratica un C antisdrucciolo. Mah, la roba troppo managed mi rende perplesso: piu` cose si lasciano fare al compilatore, piu` cose vengono fatte in maniera non ponderata perche` il compilatore non capisce qual'e` il ruolo, in pratica, di quel che sta compilando. Per come l'ho sempre vista io, piu` aspetti del run-time allontani dal controllo del programmatore, piu` colpisci la performance. Molti, oggi, forse non si rendono conto del problema perche` evitano il basso livello come la peste, confrontano performances di linguaggi diversi ma tutti piu` o meno molto al di sopra dell'assembly, e non vedono, in pratica, quel che perdono.
>
> Il C è un compromesso già di suo, per buone performances intendo vicine a C/C++, in generale è quasi sempre sufficiente che produca codice nativo e non giri in una virtual machine per stare in quella fascia (ci sono eccezioni, ma generalmente è così).

Se per "stare in quella fascia" vanno bene anche perdite di performances spesso tra il 200 e il 300 percento, allora basta.

> Rust ha come target di compilazione llvm. Pensa che se lino fosse stato maturo avrebbe potuto essere là.

Non so, non e` stato pensato per quello.
E` stato pensato per essere un intermediate language leggibile e gestibile.
ehm... vabbe', da me almeno.

> > > Lo sto osservando da almeno un annetto, (leggo spesso i This week in Rust che trovi qui ) ho seguito il tutorial sul sito per la versione 0.8 e mi sono promesso di riaffrontarlo di nuovo per vedere come sta cambiando; quello che stanno affrontando ora è l'ultimo set di modifiche alla sintassi prima di andare verso la stabilizzazione e il rilascio della versione 1.0 di linguaggio e runtime library prevista per l'inizio del prossimo anno.
> >
> > Hmmmmrrr... dicono tutti cosi`. Aspetterei che ci arrivino e poi lascerei comunque passare un po' di tempo affinche` dia prova di essersi davvero stabilizzato.
> >
> > > I suoi principali concorrenti sono D della digital mars e Go di google, entrambi garbage collected; mi interessa capire se può diventare il linguaggio general purpouse che copre più use-case senza troppa fatica da aggiungere al mio bagaglio di conoscenze; mi sembra un linguaggio con buone performances, sintassi e compilatore amichevoli, un buon seguito di persone, nessuna pressione o interessi concorrenti alla realizzazione del linguaggio.
> >
> > Per le buone performances, nella mia idea, bisogna quanto meno avere accesso diretto ai registri, tanto per dirne una.
> >
> > e di certo costrutti come il ritorno implicito, che impacchettano l'operazione di ritorno di un valore e ne passano la gestione al compilatore, non aiutano. Fai conto che tra Lino 2 e Lino 3 l'istruzione di ritorno e` stata PERSA in favore della performance. Ti faccio un esempio:
> >
> >

> > a = b;
> > a + c;
> > return [register] a;
> > 

> >
> > Somma B e C e poi ritorna il registro A.
> > Il compilatore pero` la tradurrebbe in:
> >
> >

> > mov eax, ebx
> > add eax, ecx
> > mov ebp, eax
> > ret
> > 

> >
> > Ma se in Lino 3 scrivi:
> >
> >

> > % = b;
> > % + c;
> > leave;
> > 

> >
> > ottieni:
> >
> >

> > mov ebp, ebx
> > add ebp, ecx
> > ret
> > 

> >
> > che sono tre istruzioni, non quattro. Questo perche` come programmatore SAI che ritornerai B + C e usi direttamente il registro dedicato al valore di ritorno come accumulatore. Ovviamente un caso del genere puo` essere considerato da un compilatore sofisticato, ma quando cominci a prendere in considerazione fattori un po' piu` complessi, il compilatore dovrebbe capire cosa sta facendo in relazione a tutto il resto del codice di una funzione da ottimizzare. Piu` roba implicita hai, piu` perdi occasioni (o le complichi a dismisura) per ottimizzare. Per questo penso che linguaggi come Rust possano diventare piu` comodi del C++, ma non significativamente piu` performanti. Pero` se valuti la comodita` e una velocita` decente senza cercare il massimo, fai bene a seguirlo, io non ti seguo e non lo seguo perche` sono un vecchio che vive nel passato e che e` fissato con gli estremi: o vado in javascript e me ne frego della performance ma favorisco qualcosa che esegue out of the box vista l'onnipresenza dei browser, oppure il mio ideale rimane qualcosa come Linoleum. Qualcosa che si mette in mezzo il meno possibile tra te e il bare metal.
>
> Non scrivere 3 istruzioni per fare 1 + 1 è il tipo di compromesso che sembra ragionevole prendere per molti.

Quello si fa anche con un'istruzione sola, se in due registri e` gia` caricato 1. Ma capisco quel che vuoi dire e ti dico che quel passaggio, la serializzazione delle espressioni, introduce nel compilatore vari problemi NP-completi, per cominciare il register naming. Fin qui, CPU e listato C-like sono state due forme diverse e incompatibili. Cosa ci riservi il futuro non saprei, ma per ora e` un po' come l'annosa questione di stendere una sfera su un piano. Il mio approccio con Linoleum e` quello di evitare i passaggi indistricabili proprio come quello tra l'avere l'espressione 1+1 e l'avere le istruzioni corrispondenti: in Lino, scrivi direttamente le corrispondenti, in una forma non specifica della CPU bersaglio ma comunque adatta a un'architettura che e`, molto genericamente, una load-store.

>

Vai alla pagina
Visualizza embed

Lo shepard tone e` curioso. A forza di riavvolgere prima o poi sembra ricominciare su frequenze piu` basse, come se un po' a casaccio il cervello correggesse l'illusione.

> > Vedi cosa intendo per "acerbo"?
> > Questo sta facendo il percorso a scossoni di Linoleum.
> >
> > Classes were also removed, replaced by a combination of implementations and structured types.
> >
> > Cioe`, ha cambiato interamente object model tra una versione e l'altra.
> > Che cavolo ci vorresti fare finche` la sua impostazione e` cosi` volatile?
>
> Stai usando nodejs che è anche lui alla versione 0.10.x

Colpa tua!
Comunque la tentazione era troppo forte.

> Rust nasce come sostituto del c++, aggiungendo strati di verifiche statiche che intercettano a compile time un sacco di errori con messaggi significativi (hai mai visto un errore di compilazione c++ con i templates? io si ) e alcuni vantaggi come multithreading efficiente (threading m:n), type system forte (se non sbaglio è il modello di scala a sua volta ispirato a haskell),

La wiki dice che e` anche "inferred"?
Mi sono chiesto en passand come faccia ad essere forte ed inferred insieme...

> l'ownership dei puntatori (che ne determina il lifetime, e di conseguenza intercetta i memory leak a compile time), costrutti sintattici utili (pattern matching, return implicito dell'ultima espressione, oltre agli ormai immancabili closures, for-each, ...).

In pratica un C antisdrucciolo. Mah, la roba troppo managed mi rende perplesso: piu` cose si lasciano fare al compilatore, piu` cose vengono fatte in maniera non ponderata perche` il compilatore non capisce qual'e` il ruolo, in pratica, di quel che sta compilando. Per come l'ho sempre vista io, piu` aspetti del run-time allontani dal controllo del programmatore, piu` colpisci la performance. Molti, oggi, forse non si rendono conto del problema perche` evitano il basso livello come la peste, confrontano performances di linguaggi diversi ma tutti piu` o meno molto al di sopra dell'assembly, e non vedono, in pratica, quel che perdono.

> Lo sto osservando da almeno un annetto, (leggo spesso i This week in Rust che trovi qui ) ho seguito il tutorial sul sito per la versione 0.8 e mi sono promesso di riaffrontarlo di nuovo per vedere come sta cambiando; quello che stanno affrontando ora è l'ultimo set di modifiche alla sintassi prima di andare verso la stabilizzazione e il rilascio della versione 1.0 di linguaggio e runtime library prevista per l'inizio del prossimo anno.

Hmmmmrrr... dicono tutti cosi`. Aspetterei che ci arrivino e poi lascerei comunque passare un po' di tempo affinche` dia prova di essersi davvero stabilizzato.

> I suoi principali concorrenti sono D della digital mars e Go di google, entrambi garbage collected; mi interessa capire se può diventare il linguaggio general purpouse che copre più use-case senza troppa fatica da aggiungere al mio bagaglio di conoscenze; mi sembra un linguaggio con buone performances, sintassi e compilatore amichevoli, un buon seguito di persone, nessuna pressione o interessi concorrenti alla realizzazione del linguaggio.

Per le buone performances, nella mia idea, bisogna quanto meno avere accesso diretto ai registri, tanto per dirne una.

e di certo costrutti come il ritorno implicito, che impacchettano l'operazione di ritorno di un valore e ne passano la gestione al compilatore, non aiutano. Fai conto che tra Lino 2 e Lino 3 l'istruzione di ritorno e` stata PERSA in favore della performance. Ti faccio un esempio:

a = b;
a + c;
return [register] a;

Somma B e C e poi ritorna il registro A.
Il compilatore pero` la tradurrebbe in:

mov eax, ebx
add eax, ecx
mov ebp, eax
ret

Ma se in Lino 3 scrivi:

% = b;
% + c;
leave;

ottieni:

mov ebp, ebx
add ebp, ecx
ret

che sono tre istruzioni, non quattro. Questo perche` come programmatore SAI che ritornerai B + C e usi direttamente il registro dedicato al valore di ritorno come accumulatore. Ovviamente un caso del genere puo` essere considerato da un compilatore sofisticato, ma quando cominci a prendere in considerazione fattori un po' piu` complessi, il compilatore dovrebbe capire cosa sta facendo in relazione a tutto il resto del codice di una funzione da ottimizzare. Piu` roba implicita hai, piu` perdi occasioni (o le complichi a dismisura) per ottimizzare. Per questo penso che linguaggi come Rust possano diventare piu` comodi del C++, ma non significativamente piu` performanti. Pero` se valuti la comodita` e una velocita` decente senza cercare il massimo, fai bene a seguirlo, io non ti seguo e non lo seguo perche` sono un vecchio che vive nel passato e che e` fissato con gli estremi: o vado in javascript e me ne frego della performance ma favorisco qualcosa che esegue out of the box vista l'onnipresenza dei browser, oppure il mio ideale rimane qualcosa come Linoleum. Qualcosa che si mette in mezzo il meno possibile tra te e il bare metal.

> > > > http://www.playfuljs.com/a-first-person-engine-in-...
> > >
> > > Altg&Calzedonya talmente al tappeto che potrebbero rifornire tutto il Marocco
> >
> > Vedo, vedo, d'altronde per arrivare a Cydonia gli mancano solo:
> >
> > - Migliaia di righe di codice in piu'-
> > - Staticita'
> > - ~1fps
>
> Fix'd

Il primo esperimento chiamato cydonia faceva rendering in tempo reale.
Ricordi, vero?

http://anynowhere.com/personal/wirez/wirez.html

Poi ho provato three.js per vedere cosa sapeva fare WebGL e infine ho deciso che niente di tutto quello mi sembrava conveniente. Dietro alla scelta c'e` una fraccata di considerazioni, ma evidentemente vanno al di la` delle tue capacita` di comprensione.

> > > Visto che si poteva fare anche senza tutto l'accrocchio di quack? Il JS su un processore moderno e` infatti piu` veloce dell'assembly di un 486 DX dei primi anni '90, il che apre le possibilita` a una serie di giochini retro` a sviluppo indy. Bei tempi, bei bei tempi. (semi-cit)
> > >
> > > Io ultimamente faccio il tifo per questo sviluppo interamente HTML5 (lo so, all'inizio ero scettico, ma solo gl'imbecilli non cambiano opinione) anche perche` potrebbe col tempo fagocitare i vari developer kit incompatibili tra loro degli attuali dispositivi a base Apple, Android, Microsoft, quel-che-sara`. Non ho mica voglia d'impararli tutti, e in fondo non ho piu` voglia neanche di dedicarmi a Linoleum.
> >
> > Quando ti ho chiesto cosa ne pensavi di mozilla rust non mi hai più risposto. Lo fai ora?
>
> Neanche mi ricordavo che me l'avessi chiesto.
> Comunque...
>
>

> Appeared in	2012
> Preview release	0.10[1] / 3 April 2014; 61 days ago
> 

>
> non ti sembra troppo acerbo?
> E se poi te ne innamori ma non si afferma?
> Io aspetterei a vedere che ne viene fuori, ecco.
> A dirla tutta, io ormai aspetto che mezzo mondo usi qualcosa, poi lo uso anch'io.

Vedi cosa intendo per "acerbo"?
Questo sta facendo il percorso a scossoni di Linoleum.

Classes were also removed, replaced by a combination of implementations and structured types.

Cioe`, ha cambiato interamente object model tra una versione e l'altra.
Che cavolo ci vorresti fare finche` la sua impostazione e` cosi` volatile?

> > http://www.playfuljs.com/a-first-person-engine-in-...
>
> Altg&Calzedonya talmente al tappeto che potrebbero rifornire tutto il Marocco

Vedo, vedo, d'altronde per arrivare a Cydonia gli mancano solo:

- arbitrary-angled polygons,
- six degrees of freedom,
- pixel-perfect meshing,
- supersampling,
- per-pixel phong shading model,
- depth buffering,
- stencil buffering,
- shadow volumes,
- penumbra modulation,

e l'importazione di modelli direttamente da Blender e indirettamente da Sketchup, se non mi sono scordato qualche altra inezia.