Forum libero

> > > > > > > > il flash player mi si è bloccato anche dentro il sito della adobe...A questo punto non ci sono dubbi che boicottino mozilla per far scaricare chrome
> > > > > > >
> > > > > > > Firefox fa cagare.
> > > > > > > Sia da un punto di vista di performance che da un punto di vista di stabilità e sicurezza, inoltre boicottano di proposito tecnologie utili solo perché proposte o implementate da Chrome. Sono anche indietro per quanto riguarda le tecnologie di sicurezza come le chiavette USB per la 2 factor authentication.
> > > > > >
> > > > > > Proprio 20 minuti fa ho dovuto riavviare il browser (qui uso Firefox perché non posso installare su questo PC Chrome, praticamente non ci sono estensioni installate a parte adblock).
> > > > > >
> > > > > > La scusa è stata "uno script non risponde".
> > > > > >
> > > > > > Supponiamo anche fosse vero... come fa uno script del cazzo a bloccare non solo la sua pagina WEB ma anche l'intera interfaccia di Firefox costringendomi a riavviare il browser? E a che cazzo serve il pulsante "Ferma script" se non fa un cazzo di niente?
> > > > >
> > > > > Ok mi avete convinto, installerò chrome così mi faccio googlare tutto!!!
> > > >
> > > > Installa Opera.
> > > > E` Chromium meno Google.
> > >
> > > Opera è una merdaccia al quadrato. Sono riusciti anche ad eliminare la barra dei segnalibri.
> >
> > Boh, io i segnalibri non li uso dal '98, mi pare. Autocompleto o googlo, e quelli frequenti li tengo sulla speed dial, che ultimamente hanno ridisegnato in stile metro, coi quadrettini colorati che non prendono molto posto. Ce n'entrano un bel po'.
>
> Io li tengo in una cartella con sottocartelle per argomenti. Ad esempio se voglio ricordare un thread del FDT in cui si parla di armi, trascino l'icona dell'url nella cartella "armi". Poi quando lo cerco non lo trovo più.

Per forza non lo trovi piu`, ogni tanto fai shift+delete e butti via tutto.

> > > > > > il flash player mi si è bloccato anche dentro il sito della adobe...A questo punto non ci sono dubbi che boicottino mozilla per far scaricare chrome
> > > > >
> > > > > Firefox fa cagare.
> > > > > Sia da un punto di vista di performance che da un punto di vista di stabilità e sicurezza, inoltre boicottano di proposito tecnologie utili solo perché proposte o implementate da Chrome. Sono anche indietro per quanto riguarda le tecnologie di sicurezza come le chiavette USB per la 2 factor authentication.
> > > >
> > > > Proprio 20 minuti fa ho dovuto riavviare il browser (qui uso Firefox perché non posso installare su questo PC Chrome, praticamente non ci sono estensioni installate a parte adblock).
> > > >
> > > > La scusa è stata "uno script non risponde".
> > > >
> > > > Supponiamo anche fosse vero... come fa uno script del cazzo a bloccare non solo la sua pagina WEB ma anche l'intera interfaccia di Firefox costringendomi a riavviare il browser? E a che cazzo serve il pulsante "Ferma script" se non fa un cazzo di niente?
> > >
> > > Ok mi avete convinto, installerò chrome così mi faccio googlare tutto!!!
> >
> > Installa Opera.
> > E` Chromium meno Google.
>
> Opera è una merdaccia al quadrato. Sono riusciti anche ad eliminare la barra dei segnalibri.

Boh, io i segnalibri non li uso dal '98, mi pare. Autocompleto o googlo, e quelli frequenti li tengo sulla speed dial, che ultimamente hanno ridisegnato in stile metro, coi quadrettini colorati che non prendono molto posto. Ce n'entrano un bel po'.

> > Sissi` scherza scherza, che` poi viene fuori che era vero...
>
> In effetti ho subito scritto alla Walton Foundation,
>
> Dear Walton Family Foundation,
>
> Today I received the following email:
>
> "${messaggio_ricevuto}"
>
> It would be nice to see that there's someone who knows so closely my most intimate needs, but I don't think I am that lucky. This message is to inform you that someone is sending scam emails in your name.
>
> Thanks for your attention, and regards.
>
> ma sono breoggubado: compilato il form sul loro sito e premuto invio, non è venuta la pagina di riepilogo che normalmente viene in questi casi, "grazie per averci contattato" eccetera, ma è stato ripresentato di brutto il form.

Ah si dice grazie? Mi pare che anynowhere dicesse "ok, non ci riprovare prima di 24 ore o si viene li` e ti si spacca dalle botte". Mi pareva piu` utile cosi`...

> Che ne pensano quelli di ANOwhere?

Niente, a loro lo presento quando ho qualcosa di vagamente piu` completo e con un tutorial che abbraccia argomenti piu` interessanti della conversione di stringhe da 8 a 32 bit. A proposito, l'output del compilatore per quella routine:



dovrebbe evidenziare come il rapporto fra le istruzioni nel sorgente e quelle nell'output sia vicino a 1:1, insomma il fatto che fin qui non tradisce la sua natura di "assembly sotto un'altra forma". Poi c'e` a chi piacera` e a chi dira` che era meglio un CIL a stack machine invece di fare register naming a mano, ma a me mi piace cosi`.

Ci si capisce un casino!
E` tutto molto espressivo e ovvio.

        include rc
        include text
        nameset text


        to From ByteString r    "binaural fn
        to From ByteString      "monaural fn
        
            creates a text object from a byte-aligned null-terminated string,
            such as those built by the compiler e.g. when you type @8:{ Hello! },
            or generally read from ASCII files (does not support UTF-8; another
            function will probably be developed for that, once someone provides
            means to render the characters outside the historical ASCII range...)

                --> m = firstByte       (byte select mask)
                --> n = R               (first unit in source buffer)
                --> p = r               (start address in source buffer)
                --> q                   (future start address in target buffer)
                --> r = 0               (source bytes counter, starts at zero)
                
                repeat if n has m       (as long as no null terminator found)

                        r + 1           (increment bytes counter)
                        m ] 8           (rotate mask, e.g. FF000000 -> 00FF0000)
                        
                        if m eq firstByte
                        
                                p + 1   (access next unit in source buffer)
                                n = P   (load new source buffer unit)

                <-- p                   (p = entry r, i.e. initial source address)

                q <- rc::Pick r Units   (q = target buffer)
                r <- rc::Size Of q      (r = back to abovely determined byte-size)
                
                --> q                   (will be returned to caller)
                --> v = firstByte       (free register v, use as byte select mask)
                
                m = 0                   (rotation magnitude, starts at zero)
                
                r times                 (each byte in source)

                        m + 8           (increase rotation: make that 8 for first byte)
                        n = P           (read current source unit)
                        n & v           (mask off all bytes except the relevant one)
                        n [ m           (rotate the relevant byte to its place, i.e...)
                        Q = n           (left-most of the target unit, hereby written)
                        
                        if m eq bitsPerUnit
                        
                                p + 1   (full circle? ok, access next unit in source)
                                m = 0   (and reset rotation magnitude)

                        q + 1           (access next unit in target buffer)
                        v ] 8           (rotate mask, e.g. FF000000 -> 00FF0000)
                
                <-- v                   (restore v - it's callers' vicinity pointer)
                <-- r                   (we had stacked target buffer before v)
                <-- q                   (callee-saved)
                <-- p                   (callee-saved)
                <-- n                   (callee-saved)
                <-- m                   (callee-saved)
                
                return r                (we return the target buffer address)

Oh ma comunque una cosa del genere (conversione di una stringa ASCII da un allineamento a 8 bit a uno a 32 bit per carattere), penso sarebbe piuttosto oscura anche se la scrivessi in javascript. Comunque ho commentato tutto, il che spiega molte cose e non sto affatto prendendo per il culo, no, cosa andate mai a pensare?

Vabbe' ragazzi, ovviamente poi uno 'ste cose se le trova pronte e le chiama e basta. Cioe` in un esempio da tutorial, 'sta roba e` solo usata, non scritta, il che viene fuori piu` comprensibilmente cosi`:

	startup displayStatus engage
	include text fromByteString
	include text say
	include util pause


	to Begin

		text::From ByteString @8:{ Hello } -> Say

		each P inside \

		[

			@8:{ _Mercury		},
			@8:{ _Venus		},
			@8:{ _Earth		},
			@8:{ _Mars		},
			@8:{ _Jupiter		},
			@8:{ _Saturn		},
			@8:{ _Uranus		},
			@8:{ _Neptune		},
			@8:{ _and_maybe_Pluto	}

		]

			text::From ByteString P -> Say

		util::Pause
		leave

E qui dai si capisce.
Testo::daStringaDiBytes @8:{ questa } -> Dillo
Dove @8 imposta la wordsize, cioe` gli dice fai 8 bit per carattere.
Per default la fa lunga un'unita`, cioe` una parola della CPU, cioe` 32 bit qui.
E poi "per ogni P in un array di stringhe di bytes", fai la stessa cosa con P.
Pausa e poi chiudi il programma.
L'output e` ovviamente "Hello Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune and maybe Pluto".
Ah, gli underscore nelle stringhe marcano gli spazi.
Dai che si capisce, dai, non mi puoi dire... no? come no?

> > > > > Capiva
> > > > >
> > > > > test dh,0x3
> > > > >
> > > > > perche' e` quello che hai assemblato.
> > > >
> > > > Ah badaganzo, allora sugli opcode reg8 usano il reg ID di ESI per rappresentare DH.
> > >
> > > ah/sp
> > > bh/di
> > > ch/bp
> > > dh/si
> >
> > Sicche` t'interessi anche di assembly?
>
> no.

Ah, capisco, era solo per precisare che non c'era nessun mystero nell'istruzione che avevo assemblato per sbaglio, e rovinare tutta la poesia. Peccato.

> > Ci ho messo tutta la mattina a capirlo. Avevo scorciato, a suo tempo, delle istruzioni che l'assembler interno poteva rappresentare con operandi di 8 bit quando implicavano un registro a cui veniva applicato un operando immediato sufficientemente piccolo. Sicche` avevo tradotto, ad esempio:
> >
> > TEST EAX, 0xFF
> >
> > con una piu` breve
> >
> > TEST AL, 0xFF
> >
> > che tanto e` uguale, ai fini dei flag che imposta: nella fattispecie, se tra gli 8 bit meno significativi di EAX ce n'e` almeno uno impostato a 1, il risultato e` non-zero. Fin qui tutto bene, il problema e` che m'ero scordato di verificare che il registro in questione fosse uno dei quattro che hanno una parte bassa a 8 bit (EAX ha AL, EBX ha BL, ECX ha CL, EDX ha DL), e avevo allegramente esteso l'ottimizzazione anche a ESI, EDI, ESP, EBP, che non hanno sottoregistri a 8 bit. Sicche` stamani l'assembler interno stava traducendo:
> >
> > if r has oddBites
> >
> > (che significa "se r ha impostati i bit che compongono il valore immediato 3", cioe` se r/4 da` un resto, cioe` se r non e` multiplo di 4) con la sequenza in linguaggio macchina:
> >
> > F6C603
> >
> > con quella stava chiedendo, provocando un crash che non mi spiegavo, al microprocessore "testa i bit del valore 3 nel sottoregistro a 8 bit di ESI". E siccome il sottoregistro a 8 bit di ESI non esiste, chissa` cosa capiva; secondo me si chiedeva "EH?! BOH!" e pero` non crashava in quel punto, provocava un crash per via del risultato sbagliato di un arrotondamento per eccesso che allocava un blocco di heap un po' piu` piccolo del necessario. La sequenza corretta usa per forza la forma a 32 bit, cioe`:
> >
> > F7C603000000
> >
> > e ora va bene, ma boja, c'e` voluta tutta la mattina a scoprire perche` cazzo non funzionava. L'istruzione sembrava corretta, infatti, nel sorgente L.in.oleum. Ma veniva assemblata male.
> >
> > No, lo raccontavo perche` trovato divertente l'aver scoperto di aver usato un opcode a 8 bit su un registro di 32, come se facessi riferimento all'inesistente sottoregistro SI-L. Um... ma vedo che non diverte.
>
> Ma sarà più veloce del C anche stavolta?

Dipende da cosa fa il C-qualcosa. Ricordo che nel 2008 in una prova buttata li` in questo thread sembrava sverniciare C++, C# e Java.

http://anynowhere.com/bb/posts.php?t=3874&p=8

Magari il C semplice no, quello magari non si fa le seghe.

> > > il flash player mi si è bloccato anche dentro il sito della adobe...A questo punto non ci sono dubbi che boicottino mozilla per far scaricare chrome
> >
> > Firefox fa cagare.
> > Sia da un punto di vista di performance che da un punto di vista di stabilità e sicurezza,
>
> La qualita` di Firefox e` discontinua, certo e` che l'engine javascript e` veloce, ma altrettanto certo e` che il rendering e` lento come un geco dopo che ci ha giocato Ares.
>
> > inoltre boicottano di proposito tecnologie utili solo perché proposte o implementate da Chrome. Sono anche indietro per quanto riguarda le tecnologie di sicurezza come le chiavette USB per la 2 factor authentication.
>
> E rilancio con le vecchie questioni sulle scrollbar stylate. Sono testardamente convinti che debbano restare come sono, com'erano nei tardi anni 90. Intanto, il resto del mondo e` andato avanti e sui dispositivi mobile sono SPARITE del tutto (Se Dio Vuole Finalmente), mentre webkit (e con esso Opera e Chome), da ormai un paio di strani eoni, permette di stylarle come cazzo pare e piace al web designer. Loro NO. Loro NO. Le scrollbar restano cosi`: sono peggio dei fondamentalisti islamici.

Ah, e non hanno ancora risolto bachi che ricordano l'epoca delle browser wars, per esempio di recente sono incappato nel fatto che se zoomi una pagina (cosa che non devono testare spesso), e poi uno script richiede getComputedStyle di una div, la lineHeight della div e` scalata con lo zoom, invece di restare com'e` (cosa che succede sugli altri browsers). Il baco e` anche segnalato, ora non sto a riportare il link ma una ricerca dovrebbe trovarlo facile, ed e` ancora li` che attende da mesi.

Ci ho messo tutta la mattina a capirlo. Avevo scorciato, a suo tempo, delle istruzioni che l'assembler interno poteva rappresentare con operandi di 8 bit quando implicavano un registro a cui veniva applicato un operando immediato sufficientemente piccolo. Sicche` avevo tradotto, ad esempio:

TEST EAX, 0xFF

con una piu` breve

TEST AL, 0xFF

che tanto e` uguale, ai fini dei flag che imposta: nella fattispecie, se tra gli 8 bit meno significativi di EAX ce n'e` almeno uno impostato a 1, il risultato e` non-zero. Fin qui tutto bene, il problema e` che m'ero scordato di verificare che il registro in questione fosse uno dei quattro che hanno una parte bassa a 8 bit (EAX ha AL, EBX ha BL, ECX ha CL, EDX ha DL), e avevo allegramente esteso l'ottimizzazione anche a ESI, EDI, ESP, EBP, che non hanno sottoregistri a 8 bit. Sicche` stamani l'assembler interno stava traducendo:

if r has oddBites

(che significa "se r ha impostati i bit che compongono il valore immediato 3", cioe` se r/4 da` un resto, cioe` se r non e` multiplo di 4) con la sequenza in linguaggio macchina:

F6C603

con quella stava chiedendo, provocando un crash che non mi spiegavo, al microprocessore "testa i bit del valore 3 nel sottoregistro a 8 bit di ESI". E siccome il sottoregistro a 8 bit di ESI non esiste, chissa` cosa capiva; secondo me si chiedeva "EH?! BOH!" e pero` non crashava in quel punto, provocava un crash per via del risultato sbagliato di un arrotondamento per eccesso che allocava un blocco di heap un po' piu` piccolo del necessario. La sequenza corretta usa per forza la forma a 32 bit, cioe`:

F7C603000000

e ora va bene, ma boja, c'e` voluta tutta la mattina a scoprire perche` cazzo non funzionava. L'istruzione sembrava corretta, infatti, nel sorgente L.in.oleum. Ma veniva assemblata male.

No, lo raccontavo perche` trovato divertente l'aver scoperto di aver usato un opcode a 8 bit su un registro di 32, come se facessi riferimento all'inesistente sottoregistro SI-L. Um... ma vedo che non diverte.

> > > > Ho cercato di classificare formalmente le "inlet" in L.in.oleum 4. La premessa e` che il termine "inlet" e` un catch-all, significa essenzialmente subroutine: una label di codice che puo` essere chiamata. Poi le inlets possono essere, a seconda di come vengono dichiarate e di come si comportano, ricondotte ai casi di subroutine semplici, funzioni, o metodi. I termini che ho definito per dichiararle (e su cui il compilatore effettua dei controlli per produrre avvisi quando qualcosa non e` chiamato in un modo compatibile con la sua dichiarazione) sono questi:
> > > >
> > > >

> > > > [monaural | binaural] [fn | id]
> > > > 

> > > >
> > > > Il che significa che la inlet puo` essere dichiarata opzionalmente o monaural o binaural, e come ulteriore opzione, o funzione generica (fn) o funzione identita` (id). "monaural" e "binaural" si occupano della questione di come vengono legate all'istanza su cui operano: la sintassi monaural ("che sente da un solo orecchio") e` quella tipica in cui si lega l'istanza alla chiamata, tipo "antani.stampa(perTerra)"; la sintassi binaural (che sente da due orecchie) e` compatibile con la monaural ma in piu` permette di specificare l'istanza come argomento, cioe` di scrivere ANCHE in forma imperativa "stampa(antani,perTerra)". Ci sono delle differenze tra efficienza e comodita` tra le due, a seconda delle circostanze, sicche` non e` affatto privo di senso dichiarare, generalmente come sinonimo, la forma binaural (perche` se l'istanza viene passata come argomento e il metodo non e` una funzione, il registro di riserva diventa caller-saved). Per quanto riguarda le identita`, si dichiarano per usare le fluent interfaces, quelle dove un metodo e` una funzione che ritorna sempre l'istanza su cui opera (dove poi metti le chiamate "a trenino").
> > > >
> > > > Per tornare torna, e permette di delineare piuttosto bene il comportamento di una inlet. Temo solo che non ci si capisca un cazzo. Avro` mica ragione?
> > >
> > > Ma chi deve passare a questa da una versione precedente diventa pazzo, stai cambiando tutto!
> >
> > Temo che un po' traumatico sara`, si`.
> > Pero` che ti devo dire?
> > Ho girato e rigirato la frittata finche` non e` venuta meglio.
> > Ah comunque e` facile ricondurre, nelle spiegazioni, il discorso sopra al modo di classificare le funzioni nel "resto del mondo". In pratica:
> >
> > una dichiarazione senza "firme" significa subroutine: stampa (antani)
> > una inlet "monaural" significa metodo: antani.stampa ()
> > una inlet "fn" significa funzione: risultato = somma (x, y)
> > una "monaural fn" e` un metodo che e` una funzione: l = blah.length()
> > una "monaural id" e` un metodo in fluent interface: p = blah.length().alloc()
> >
> > basta rimandare a wikipedia per invitare a capire cos'e` un metodo, cos'e` una fluent interface, eccetera, e MAGARI diventa comprensibile, no?
> >
> > No eh?
> >
> > p.s. e non ho neanche accennato ai decoratori:
> >
> > frequent, framed, internal, rc
> >
> > frequent = chiamata frequente, allineata a una boundary di codice ottimale,
> > framed = che ha uno stack frame,
> > internal = privata (il compilatore avvisa se si chiama dall'esterno),
> > rc = resource-collected (incorniciata da specifici prequel e sequel).
> >
> > I prequel e i sequel sono macro, infatti il compilatore v4 supporta le macro, e il decoratore "rc", per attivare la garbage collection a partire dal ramo dell'inlet dichiarata, non ha nulla di "hard-wired" nel compilatore: viene definito dalla libreria rc, il che permette di riscrivere come si comporta il collector.
>
> Non sarebbe il caso di dargli una semplificata e far uscire direttamente Linoleum 4.4?

Non so quanto si possa semplificare: non nego che non sia facile raccapezzarcisi, o almeno che la learning curve sia un pochettino ripida, pero` e` anche vero che le complicazioni emergono dal voler dare un certo grado di controllo al programmatore, a partire dal register naming, cioe` dalla scelta dei registri della CPU da usare. In altre parole, ok, sto gia` facendo il possibile per renderlo piu` espressivo, ma insomma non arrivera` mai al livello di un Quick Basic o di un Javascript. E` assembly: cross-platform, strutturato e oggettizzato ma fondamentalmente sempre assembly. Come minchia faccio a semplificare piu` di tanto l'assembly?