Newsgroup: it.comp.giochi.avventure.testuali
Titolo: [OT] Congratulazioni a Niccolai

Congratulazioni a Giancarlo Niccolai per il coraggio ed il valore
dimostrato nell' affrontare la fossa dei matti inferociti chiamata ICOG
(it.cultura.orientale.giappone)
Gia' e' assalito da tutti i lati, ma si difende con Valore.
Saluti,
Dott. Piergiorgio.
P.s. Per Niccolai: se ti piace il Giappone, perche' non scrivi una bella
AT "Giapponese" ? apparte Katana.gam praticamente non c' è niente, a
parte IF che prendono in giro i luoghi comuni del Giappone....

Dott. Piergiorgio wrote:

Ciao, Piergiorgio. 
Ti ringrazio per il tuo sostegno [anche se una tua lettera di supporto su
ICOG sarebbe ancora più gradita;-)] .
Per l'AT giapponese, penso che potrei prendere l'idea in seria
considerazione; putroppo, ho una conoscenza non certo enciclopedica del
giapponese (conosco abbastanza a fondo la grammatica, che è la cosa che mi
intrippa in tutte le lingue, ma posso al più sostenere una conversazione
amichevole e leggere qualche semplice sito internet) né del giappone; ho
letto qualcosa, ma non ci sono mai stato.
Però, a ben pensarci, una AT su Miamoto Musashi non mi dispiacerebbe.
Sto finendo un linguaggio di programmazione che dovrebbe unire le
caratteristiche di Inform per la gestione delle AT con la potenza del
python. Mi mancano solo un paio di costrutti, e una minima libreria RTL per
avere un sistema davvero interessante, quindi potrei iniziare a scrivere
qualcosa questa settimana stessa. 
Se hai qualche spunto...
Giancarlo.

 Giancarlo.
Bravo! Complimenti.
Hai imparato il giapponese da autodidatta?
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 ICOG sarebbe ancora più gradita;-)] .
Vedro' di farla, anche se e' noto che pochi la leggono....
Cmq, per quanto riguarda il tuo engine python, sembra un progetto
interessantissimo, quando rilascerai la beta saro' lietissimo di
sperimentarlo.
E ovviamente, mi auguro che insieme al world model in Italiano ne rilasci
anche uno in Inglese e vediamo che reazioni suscita in raif.....
Saluti,
Dott. Piergiorgio.

 
Parzialmente: all'università ho fatto due anni di business japanese; lì ho
imparato la parola wappuro... (word processor), e altri termini usati nel
mondo degli affari; i nostri docenti, tuttavia, erano più concentrati
nell'insegnarci come fare affari con in giapponesi, come non offenderli,
come condurre le trattative, una infarinatura di cultura generale... tutto
sommato fu un bel corso. Ma giapponese colloquiale 0; penso che avremmo
avuto dei problemi anche a chiedere le informazioni per strada: le forme
onorifiche e "colloquiali" erano totalmente tralasciate, (veniva insegnato
solo il "piano" la forma di cortesia "media", e qualcosa delle due
onorifiche) mentre guardando i film in giapponese mi sono reso conto che le
forme colloquiali, l'equivalente del nostro "dare del tu", sono spesso
usate anche fra "sconosciuti", se l'occasione è informale. Inoltre, senza
conoscere le forme base è difficile coniugare alcune forme verbali. Quindi
la scrittura e il giapponese più spicciolo li ho studiati da solo, su una
grammatica di "non mi ricordi chi", i 250 "essential kanji for everyday
living" e il corso in 99 lezioni dell'ASSIMIL. Ora come ora sono un poco
arrugginito... soprattutto sui kanji, ma quando hai le basi è facile
ripassare. Come per tutte le lingue, la cosa più difficile è entrare in una
mentalità diversa dalla tua, ma questo è un esercizio che il mio lavoro
(programmatore) mi ha portato a conoscere molto bene.
Gian.

 
Ovviamente.
Cordiali saluti,
Giancarlo.

Dott. Piergiorgio wrote:

Anche io adoro il Giappone... e manco sapevo di quel newsgroup.

saintpumpkin wrote:

Per curiosità, perché non hai fatto tutto in python? Dopotutto lo stesso 
Inform non ha nulla in sé che faciliti l'applicazione alle AT, il 
supporto sta tutto nelle librerie... e pensa come sarebbe facilmente 
estendibile ( e portabile!) se fosse python puro...
ciao
S
PS peraltro qualcuno aveva già fatto qualcosa, sotto il nome PAWS, però 
non so che fine ha fatto... temo sia stato tutto abbandonato

 a Inform. Per quello mi potrebbe necessitare un'altra settimana.
Complimenti, Giancarlo...
Sono estremamente curioso. Si puo' vedere qualcosa? Un po' di 
documentazione? Qualche specifica? Qualche esempio di codice?
(arf..arf..)
bye
-- 
Paolo Lucchesi
email: plucchesi(at)tin(dot)it
home page: 
http://www.paololucchesi.it

 Anche io adoro il Giappone... e manco sapevo di quel newsgroup.
Non so quello, ma ricordo it.cultura.linguistica.giapponese in cui si
parlava non solo di lingua e QUALUNQUE COSA POSTAVI il 25% degli
utenti non era d'accordo, il 50% ti aggrediva, il 40% ti insultava.
-_-
Il restante 10% non aveva capito il post :P

 
Uhm; per ora ho solo qualche esempio di codice + un po' di assembly:
/*
   Haste test suite
   Class tests
   $Id: class.hst,v 1.6 2004/09/06 01:28:51 gian Exp $
*/
class TestClass(param) from BaseClass
   printl( "TestClass Initialization" )
   self.prop1 = "hi"
   self.prop2 = param +  self.prop1
   printl( "Test class initialization:", param )
   function reset( param )
      self.prop0 = param
      self.prop1 = param
      self.prop2 = param
   end
   function inspect()
      printl( "TestClass values:", self.prop1, self.prop2 )
      print( "Self object: " ); inspect( self )
      print( "Sender object: " ); inspect( sender )
      // Go with the base class instance
      self.BaseClass.inspect()
   end
end
function cool()
   // Uhm, let's hope our object has a prop0
   printl("FROM COOL: ", self.prop1 )
end
instance = TestClass( "initial" )
instance.inspect()
instance.reset( "reset" )
instance.inspect()
instance.BaseClass.inspect()
instance.prop0 = cool
testvar = instance.prop0
testvar()
E ANCORA:
/*
   Haste test suite
   Mimimal stateful function tests
   $Id: state.hst,v 1.2 2004/08/27 02:07:58 gian Exp $
*/
function stateless( param )
   printl( "A stateless function", param )
end
function stateful( param )
   printl( "A stateful function:", param )
   state st1 = "first"
      printl( "A state with value:", param  )
      /*
         The first time, when called with begin, the value is the one of the
         target state (st2); but as it is not given, the value is defaulted
         to this state value that is "first". This is the Moore mode
      */
      if param = "Begin": leave st2
      // From that point on, we set the value in the transition (Mealy
mode).
      leave st2 = param
   state st2
      printl( "A state without a value:", param )
      // the function need to know its name.
      printl( "Value is", stateful.value )
      enter st1
end
enter st1 stateful( "Begin" )
printl( "Stateful returned - value:", stateful.value )
stateful( "one" )
printl( "Stateful returned - value:", stateful.value )
stateful( "two" )
printl( "Stateful returned - value:", stateful.value )
stateful( "three" )
printl( "Stateful returned - value:", stateful.value )
stateful( "four" )
printl( "Stateful returned - value:", stateful.value )
----
Oltre a questo, il linguaggio supprota la gestione delle eccezioni, il
caricamento di moduli binari o in haste, i cicli while, for e foreach gli
array associativi e molto altro.
Credo che stasera stessa potrei avere un primo compilatore stand-alone.
Gian.

 Per curiosità, perché non hai fatto tutto in python? Dopotutto lo stesso
La mia prima necessità era creare un linguaggio embeddabile in una
applicazione; tale applicazione doveva essere "configurabile" con script
che ne gestivano i diversi "agenti", ma il python è troppo "potente": ad
esempio, non è possibile escludere la funzionalità di accesso ai file senza
modificarlo pesantemente.
Inoltre il python mancava di molte feature di cui avevo bisogno.
Infine il python era troppo lento e avevo bisogno di uno scripting language
molto più performante per sostituire i miei lavori che non necessitano di C
puro con qualche script. Questo include anche alcune applicazioni server di
basso profilo.
Insomma, non è che ho scritto un linguaggio per fare le AT. INCIDENTALMENTE,
siccome ci TENGO a scrivere AT, e non voglio continuare a scriverle in un
linguaggio limitato come Inform, ho scritto un linguaggio per ALTRI scopi
ma tenendo ben presente le necessità delle AT; che fra l'altro sono anche
un modello per altri tipi di problemi "più seri", come ad esempio la
modellazione di agenti a stati.
Appena ho un compilatore multipiattaforma stand-alone (questione di ore,
oramai) e un minimo set di librerie I/O posto qualcosa.
Gian.
Infine 

 
Scusa, mancava l'assembly.
; ------------------------------------------------
; Haste ASM source
; for module unnamed
; ------------------------------------------------
.module unnamed
; ============
; Entry point
; ============
.entry
.func stateless
.func stateful
.extern printl
        .set_state      $stateful, "st1"
        PUSH    "Begin"
        CALL    1, $stateful
        PUSH    "Stateful returned - value:"
        LDP     $stateful, "value"
        PUSH    A
        CALL    2, $printl
        PUSH    "one"
        CALL    1, $stateful
        PUSH    "Stateful returned - value:"
        LDP     $stateful, "value"
        PUSH    A
        CALL    2, $printl
        PUSH    "two"
        CALL    1, $stateful
        PUSH    "Stateful returned - value:"
        LDP     $stateful, "value"
        PUSH    A
        CALL    2, $printl
        PUSH    "three"
        CALL    1, $stateful
        PUSH    "Stateful returned - value:"
        LDP     $stateful, "value"
        PUSH    A
        CALL    2, $printl
        PUSH    "four"
        CALL    1, $stateful
        PUSH    "Stateful returned - value:"
        LDP     $stateful, "value"
        PUSH    A
        CALL    2, $printl
        END
; ------------------------------------------------
; Function stateless
; ---------------------------------------------
.funcdef stateless
.param  param
        PUSH    "A stateless function"
        PUSH    $param
        CALL    2, $printl
        RET
; Function end
.endfunc
; ------------------------------------------------
; Function stateful
; ---------------------------------------------
.funcdef stateful
.param  param
        PUSH    "A stateful function:"
        PUSH    $param
        CALL    2, $printl
        LDPB    $stateful, 1
        .switch B
                .case   "st1", _stateful_state_st1
                .case   "st2", _stateful_state_st2
        .end_switch
        RET
_stateful_state_st1:
        PUSH    "first"
        STP     $stateful, 2
        PUSH    "A state with value:"
        PUSH    $param
        CALL    2, $printl
        EQ      $param, "Begin"
        IFF     A, _branch_0
_branch_ok_0:
        .set_state      $stateful, "st2"
        RET
_branch_0:
        .set_state      $stateful, "st2"
        LD      A, $param
        PUSH    A
        STP     $stateful, 2
        RETVAL
_stateful_state_st2:
        PUSH    "A state without a value:"
        PUSH    $param
        CALL    2, $printl
        PUSH    "Value is"
        LDP     $stateful, "value"
        PUSH    A
        CALL    2, $printl
        .set_state      $stateful, "st1"
        JMP     _stateful_state_st1
        RET
; Function end
.endfunc
; ------------------------------------------------
; End of listing
; ------------------------------------------------
Per il momento, il compilatore compila in assembly; quindi l'assemblatore
genera il bytecode. In fine, un runner (interprete) esegue il bytecode.
Appena ho finito l'ultimo pezzo del sistema base che mi manca (il sistema
riflessivo di gestione degli errori) integro questo processo in un unico
programma, di modo che si possa scrivere come col python
haste programma.hst
e vedere il programma girare.
Gian.

Kyoba wrote:

Argh

 documentazione? Qualche specifica? Qualche esempio di codice?
Confermo che il linguaggio ideato da Giancarlo è veramente interessante.
Giancarlo, appena ho un po' di tempo libero mi leggo bene quello che mi 
hai mandato e ti faccio un po' di domande e commenti.
Giovanni
-- 
Giovanni Riccardi
personal: 
http://www.composizioni.net
   weblog: 
http://www.composizioni.net/addv
     work: 
http://www.anxur.it

 esempio, non è possibile escludere la funzionalità di accesso ai file 
 > senza modificarlo pesantemente.
Perche' non Lua? (lo so, e' un po' tardi)
   .Erix.

 Argh
Dovevo essere molto rincoglionito quando ho scritto 'sto post... Non
tornano i conti -_- :D

Enrico Colombini wrote:

Era proprio a LUA che ci eravamo rivolti inizialmente. Ma purtroppo, lo
abbiamo trovato limitante per le seguenti caratteristiche.
1) Nonostante "sostengano" che il sistema funziona in multithreading,
abbiamo scoperto che sarebbe stato assai difficile far funzionare la loro
VM in un multithreading vero, o lanciare thread fisici dall'interno della
VM. Questo l'ho verificato io stesso.
2) Il supporto delle "coroutine", ossia dei thread logici "leggeri"
interamente gestiti dalla macchina virtuale, era una delle feature che ci
interessavano di più; ma un nostro collaboratore, estremamente esperto
nella scrittura di sistemi a coroutine (ha anche scritto una libreria e ha
collaborato ad un paio di queste cosette nei luoghi in cui lavora) ci ha
segnalato che c'erano alcuni problemi concettuali di base; un uso spinto
avrebbe potuto essere problematico.,
3) L'embedabilità, seppur migliore che nel python e nel perl, non era ancora
abbastanza spinta: per "ridurre" alcune funzionalità di base sarebbe stato
necessario modificare parte del motore interno.
4) Lua è scritto in C (come del resto tutti i linguaggi VM). Niente di male,
ma tutti noi preferivamo il C++; fra l'altro, il C++ permette una più
semplice gestione della memoria e ottimizzazioni di compilazione più
spinte. 
5) La licenza di LUA non è free. Non può essere usato per applicazioni
commerciali senza un accordo con la società che detiene il copyright.
Lua in se' poteva andare, tutti questi problemi, unito al fatto che la
grammatica di LUA non ci piaceva e che, a parte le coroutine, LUA non
offriva alcuna feature "speciale", nessun plus rispetto agli altri
linguaggi, abbiamo pensato di scrivere un linguaggio nostro. O meglio, ho
pensato.
Inoltre, c'è un problema di base ad usare un progetto open source se sei
costretto ad "adattarlo". Se puoi collaborare con gli autori, bene; ma se
hai bisogno di aggiungere feature che possono "appesantire" il sistema in
cambio di un beneficio che solo pochi noteranno; quindi sei
"automaticamente" costretto a farti in casa le tue modifiche. Ma un
prodotto open source si evolve costantemente, e hai sempre necessità di
restare aggiornato. Questo si traduce in un lavoro aggiuntivo, piuttiosto
tedioso e ... uhm... scoglionante ;-) di riedizione manuale delle modifiche
che mano a mano si accumulano da una parte (gli sviluppatori originali) e
dall'altra (la tua versione). Quindi, quando hai bisogno di qualcosa di
pesantemente personalizzato, nel modo OS, fai prima a creare qualcosa di
tuo e a vedere se c'è interesse per la tua idea. Questo è comunque un
problema secondario, ma unito alle cinque considerazioni di cui sopra, e
unito al fatto che la grammatica del lua non ci piaceva (ma badate, questo
non è determinate), ho pensato di fare qualcosa di meglio, e le persone che
collaborano con me sul progetto per cui questo linguaggio è stato pensato
sono state entusiaste, e mi stanno dando una mano.
Per quanto riguarda le AT, devo ammettere che il LINGUAGGIO inform mi è
sempre piaciuto. Implementa alcune caratteristiche del modello OOP che sono
state snobbate dagli altri (maliziosamente, io credo per incapacità o
semplicemente per "rilassatezza"). Ha anche alcuni operatori fighi
(provides) e uno degli switch() più potenti che ci siano in giro. Pensate
che nella guida al python, l'autore ( Il BDL Guido Van Rossum) commenta che
siccome il python ha il costrutto if .. elif ... endif non ha bisogno dello
switch. Ridicolo. Come dire che siccome il C ha il while, non ha bisogno
del for. Poi vado matto per gli attributi (anche se sto cercando di
inventarmi un modo meno "limitante" per implementarli, e ancora non mi è
venuto niente in mente). Il supporto al parser, ossia "Verb" e famiglia,
non è "eccezionale", solo molto comodo nel suo contesto. Anche gli
operatori di disgiunzione del valore (and/or) sono graziosi: in tutti i
linguaggi devi scrivere
        if (a == b /OR/ a == c )
mentre in inform puoi scegliere se usare questa forma (con l'operatore ||) o
usare la disgiunzione di valore:
        if (a == b or c)
Trovo che sia una bella pensata, anche se per il momento (e solo per il
momento) ho deciso di non implementarla.
Il suo problema non è tanto la grammatica, quanto il target. Ossia, il fatto
che troppi aspetti della sua grammatica sono legati alla compilazione su
Z-Machine; quindi ad una macchina virtuale dotata anche di I/O virtuali.
Non scendo nei dettagli, ma purtroppo, quando programmo in inform mi sento
in una "gabbia". Non posso davvero fare tutto quello che voglio, posso SOLO
scrivere una AT, e questo è seccante. E poi mi mancano alcune cose
"moderne" alle quali non voglio rinuciare: gli array associativi e la
gestione delle eccezioni, ad esempio.
Infine, ho fatto una scelta molto europea. E' da quando ho quattordici anni,
ossia dalla prima volta che ho messo mano al C, che ho per sogno nel
cassetto un linguaggio che non richiede parentesi graffe. Sì, lo sò è una
cretinata... ma che ci volete fare! Avete notato che il python non usa
quasi mai le parentesi graffe? Sono utilizzate solo per i dizionari, e i
dizionari sono EVIDENTEMENTE un add on pensato da qualcuno che non era
certo l'autore originale. Perché? Semplice, perché la parentesi graffa
manca anche dalle tastiere olandesi.
Beh, tagliando corto, ho pensato di unire l'utile al dilettevole: se devo
creare un linguaggio, che sia un linguaggio che ha anche costrutti che mi
consentano di 1) scrivere facilmente AT, 2) usano i concetti "estesi" di
OOP che sono molto utili nelle AT.
Sono alle prese con le fasi finali del compilatore... more in my next ;-)
Giancarlo.

Kyoba wrote:

Non è detto: se parte degli utenti che ti aggredivano ti insultavano
pure... ;-)
Gian.

 oramai) e un minimo set di librerie I/O posto qualcosa.
Vabeh, se hai già quasi finito...
Pedonzolo

 imparare (io ho imparato leggendo il python tutorial)
Anche haste. Ho scritto haste perché chiunque, anche chi non ha la minima
esperienza in campo di programmazione, possa apprenderlo in meno di un ora.
In realtà, penso di essere riuscito nell'impresa di rendere haste più
semplice del python.
Gian.

 unito al fatto che la grammatica di LUA non ci piaceva
OK, vedo che abbiamo opinioni piuttosto diverse in merito :-)
 > Ma un prodotto open source si evolve costantemente, e hai sempre
 > necessità di restare aggiornato.
Tragicamente vero. Quanto sopra non era per contestare la tua valida 
scelta, ma a puro titolo informativo.
Ti leggo nel pensiero se suppongo che, come me, tu sia uno di quelli a 
cui piace costruire e controllare l'intero universo, a partire dalle 
fondamenta, in modo che funzioni sempre come dovrebbe? :-)
   .Erix.

 Il restante 10% non aveva capito il post :P
E difatti ICOG e' dove si sono spostati adesso questi tipi, ma cmq e' un
NG ben più vivibile di, diciamo, IPI.
Saluti,
Dott. Piergiorgio.

 
Eh sì. In particolare quando dalle fondamenta dipende il successo di un
sistema...
Gian.

 Per usi commerciali è richiesto un "contatto diretto" con gli autori. 
Forse era una vecchia versione. Attualmente la licenza e' pure listata 
tra quelle open source.
   .Erix.

 Dott. Piergiorgio.
Piergiorgio, scusa se rompo nel newsgroup, ma ti è arrivato il mio 
messaggio? Ultimamente ho problemi di invio/ricezione posta.
-- 
Paolo Vece - 
pv...@mclink.it
 - 
http://www.vece.net

 messaggio?
Si ricevuto, ti inviero' il "materiale" appena mi e' possibile.
Dettagli in prv, ma non adesso.....
Saluti,
Dott. Piergiorgio.

 instance = TestClass( "initial" )
Quindi l'istanza di un oggetto si crea senza un new? 


 
Sì. La classe è uno degli oggetti "callable". Le altre sono le funzioni
interne, quelle esterne e i metodi. Chiamando un oggetto di tipo classe, la
macchina virtuale istanzia un oggetto di default e quindi lo passa al
costruttore della classe per l'inizializzazione. Nella definizione della
classe possono essere listate altre classi da qui questa eredita, e la
macchina virtuale chiama i loro costruttori formando l'oggetto poco alla
volta.
Gian.

 costruttore della classe per l'inizializzazione. 
Quindi posso usare una classe anche senza assegnarla ad una variabile di 
istanza? 


 
Ovviamente; puoi ad esempio passare l'oggetto classe ad una funzione (anche
esterna /scritta in C++) per farne quello che vuoi. Ad esempio:
class MyClass
...
end
function realize( a_class )
        return a_class( "some", "params" )
end
o = realize( MyClass )
istanzierà la classe come se avessi chiamato MyClass( "some", "params" )
Come in Inform, sarà possibile anche il contrario: creare oggetti senza
instanziarli da classi. Sto ancora studiando una grammatica coerente con il
resto del linguaggio ma molto semplice (tale da rendere preferibile usare
"oggetti puri" al posto di classi).
(P.s. la funzione di print diretta, come le stringhe in mezzo al codice di
Inform, è già pronta. Non solo, un qualunque embedder può sostituirla con
la funzione che preferisce).
Gian.

 istanzierà la classe come se avessi chiamato MyClass( "some", "params" )
 
E se a realize passo un'altra classe userà quella? 
Posso fare una cosa tipo:
o = realize( MyClass )
p = realize( YourClass )
A patto che il costruttore accetti gli stessi parametri; è come se a_class 
fosse implicitamente l'oggetto base?


Paolo Vece wrote:

Esattamente. La classe è uno "STAMPINO", che in più può avere (non
necessariamente ha) un costruttore. L'oggetto classe non ha niente a che
vedere con il suo "simbolo". Ad esempio, se non trovo una variabile nello
"scope" globale, presumo che sia importata. Quando il modulo viene passato
alla VM per l'esecuzione, il RunTime cerca in tutti gli altri moduli già
compilati e caricati gli oggetti non definiti (e se non li trova, segnala
errore). Quindi mi sono messo nella condizione di non fare NESSUNA
ASSUNZIONE sul tipo dei simboli; sono solo dei "contenitori di item", e gli
item possono contenere un intero, una stringa, (tante altre cose), una
classe o un oggetto. O persino una funzione o un metodo (che collega una
funzione all'oggetto che la funzione riceverà nel registro "self).
(PS questo GIA' funziona, anzi ho già creato classi "sintetiche" che pososno
essere iniettate dal C++ negli script come se fossero state create
internamente dalla VM).
Giancarlo.

Paolo Vece wrote:

Anzi, per essere precisi, non è nemmeno necessario che accettino gli stessi
parametri. Il passaggio di parametri, in haste, è opzionale, e il chiamante
può inviare più o meno parametri di quelli dichiarati. Se non tutti i
parametri sono valorizzati, quelli "vuoti" ricevono NIL. Se sono
valorizzati più di quelli richiesti, non succede nulla, ma la funzione può
comunque accedere ai parametri extra con delle funzioni di libreria. Se si
tenta di usare un parametro non inizializzato, l'applicazione riceve un
errore che può essre intercettato in un blocco try-catch, o può essere
prevenuto semplicemente verificado se i parametri ricevuti sono del tipo
desiderato.
Questa tecnica di passaggio flessibile dei parametri può sembrare
pericolosa, ma lascia il massimo grado di libertà agli sviluppatori e agli
implementatori di librerie; ad esempio è usata da più di venti anni nel
linguaggio CLIPPER e XBASE (applicazioni business oriented), ed è
dannatamente "usable" e "programmer friendly".
Gian.