biwas di BiwaScheme un interprete Scheme in JavaScript

Sono sempre intrigato dagli interpreti, ne ho parlato qui.

Bello provarli online, ma non solo, prendi BiwaScheme. Mysteryouso e intrigousassay 😯

Intanto c’è un gruppo su G+, da perlustrare — messo tra le cose da fare.

Ma prima di subito si può scaricare l’interprete e installarlo in locale. Serve Node.js, è scritto in JavaScript.
E volendo si può anche modificare, personalizzare. Io ho cominciato con togliere metà del banner:

è stato sufficiente commentare la riga 103 del file /usr/local/lib/node_modules/biwascheme/bin/biwas così:

  var prompt = prompts.base;
  rl.setPrompt(prompt);

  console.log('BiwaScheme version ' + BiwaScheme.VERSION);
  //console.log('try (+ 1 2), etc. (Ctrl-D to exit)');

  BiwaScheme.Port.current_input = new BiwaScheme.Port.CustomInput(

Facile vero? volendo si può cambiare anche il prompt, mettere qualcosa come bs > per esempio. Basta ricordarsi che occorre sudo, siamo in /usr.

E nella directory cosa non si trova! non sempre facile, ma ci sono i commenti. Ma sono in giapponese 😜

Yutaka Hara è presente qui e qui –e altri posti ancora ma meno accessibili, ho carenze linguistiche, parlo principalmente piemonteis (pron. piemuntèis) dei contadini della zona di Carmagnola 😙

Maggiori info si BiwaScheme si possono trovare in un post di Jakub Jankiewicz, qui: How to use and extend BiwaScheme.
In questo post ci sarebbero altre cose da approfondire, per esempio Dialog –manca solo il tempo.
Inoltre, da viebel | klipse (prossimamente…) un rapido approccio a Scheme, Interactive overview of Scheme’s semantics, complementare alle specifiche di Scheme, disponibili anche sulla home di Biwascheme, queste.

Perché i nomi delle variabili devono essere significativi

Non so se a voi capita mai di svegliarvi nel cuore della notte (le tre meno un quarto), senza un motivo particolare, niente brutti sogni, solo così. E non riuscire più a riaddormentarvi. E per giunta cominciare a lambiccare su un post di sessanta ore prima.
A me è successo questa notte e voglio devo raccontarlo a qualcuno. Tanto il blog lo leggono in pochi e dopo questo incipit diminuiranno ancora. Assay.

La storia è semplicissima, più semplice di come la ricordavo questa notte, questa:

Sì, viene 12. Basta guardare le parentesi.
Anzi no, bisogna vederlo nella GUI, DrRacket:

Uh! vediamo se ho capito per davvero: rinomino la x globale xg e quella locale xl, ottengo:

(define xg 2)
(let ((xl 3)
      (y (+ xg 2)))
  (* xl y))

OK, così è chiaro (spero).
Ma mi resta un dubbio: è solo per rimarcare bene-bene la distinzione tra le variabili locali introdotte da let e quelle esterne o è una delle domande da fare all’esame allo studente rompipalle, dicendogli “l’abbiamo fatto anche a lezione, anzi c’è nel sillabario” (loro lo chiamano così).

Quando ero piccolo agli esami di idraulica (tre se ricordo bene) andava di moda quello in figura (spoiler: Bernoulli, sempre lui).

Dubbio: chissà quanti punti ho perso con questo post? Ma posso ssmettere quando voglio. Probabilmente. Forse… 😳

L’Interprete Universale Lisp 1.5 in Racket

Una cosa che si può trovare ontehtoobz da 10 giorni ormai ma metti che ancora non l’avete ancora incontrata…
Non ho alcun merito, indico solo l’URL a un post di Eugene Wallingford. Riguarda il Lisp, quello delle origini e quello di adesso (uno dei _).
Siccome wallingf sa spiegare molto meglio di me (ehi! è un prof | hey! it’s a Dr.), vi conviene andar qui: The Lisp 1.5 Universal Interpreter, in Racket.
Visto? L’ho provato anch’io; anzi ho tentato di eseguirlo nella REPL, senza successo (sono troppo niubbo) ma con DrRacket è OK:

Quale altro linguaggio è così versatile, autoridefinibile?
Eh… sapete come dicono loro a programmable programming language 😀

SICP – perché hanno smesso

Una rassegna di cinguettii: uno, due e tre.

Io adesso sono alle prese con SICP, un po’ per volta, per quel che ne sono capace, roba da über-nerd ma piace anche a me che sono niubbassay 😳 😀
Adesso non è che mi monto la testa e pretendo di dire qualcosa di nuovo e importante, quello che segue è solo una considerazione mia personale, non esportabile, anzi vale solo per me.

In this talk at the NYC Lisp meetup, Gerry Sussman was asked why MIT stopped teaching the legendary 6.001 course, which was based on Sussman and Abelson’s classic text The Structure and Interpretation of Computer Programs (SICP). Sussman’s answer was that: (1) he and Hal Abelson got tired of teaching it (having done it since the 1980s). So in 1997, they walked into the department head’s office and said: “We quit. Figure out what to do.”
(da qui).

OK, allora: quindici anni (circa, ho finito i diti) a ripetere le stesse cose, anche se fondamentali diventa un po’ –come dire– avete presente il rosario?
E poi è vero: con il Web e conoscendo i posti adatti (Stack Overflow, p.es.) la prima cosa una delle prime cose quando si parte è googlare e vedere quello che già c’è. Perché c’è parecchia roba là in fondo (quasi-cit.).

E Python (o linguaggi affini), vero anche questo. Funziona anche se lento (ma volendo…) e ci sono un sacco –OOPS già detto 😳
Oppure Java al posto del C++ (nessuno usa più il C liscio, io poi avevo il K&R con la versione antica quella in cui dichiaravi i tipi fuori dalle parentesi degli argomenti). E non parlo di altri linguaggi perché non sono ripetitivo (non tanto comunque).
Poi c’è l’HTML e tools ad esso collegati (CSS, anche JavaScript che è un linguaggio solo sotto certi aspetti). E si fa tutto non per il desktop (lo uso solo più io) ma per il telefono che ha lo schermo piccolo ma una risoluzione da sogno. E tanta RAM, ci deve girare sopra cose che chi s’immaginava quando ero giovane (avevano ragione i miei genitori a farmi desistere dal ‘puter 😳 l’ho capito tardi ma adesso so che è così).

Sussman pointed out that engineers now routinely write code for complicated hardware that they don’t fully understand (and often can’t understand because of trade secrecy.) The same is true at the software level, since programming environments consist of gigantic libraries with enormous functionality.

Vero, tranne pochissimissimi che quelle librerie le scrivono, dai qualcuno ci dev’essere che le ha scritte!
E poi capita (è capitato a me recentemente) che il giorno prima della pubblicazione salta fuori un bug (in un caso molto particolare, improbabile ma possibile) che fa partire subito una revisione. Anche perché tutto resta in una versione beta perenne; e manca la documentazione.

OK, basta lamentarsi, d’altronde

Sussman admitted that the SICP curriculum was “more coherent” than what they have now and that they still don’t know what the right curriculum should be.

Io che ormai sono fuori continuerò con SICP, mi piace, tanto 😀
E sul post indicato una meraviglia:

The SICP video lectures by Sussman and Abelson from 1986 (given to HP) are also available.

Ne ho visto solo qualche pezzettino (ci vuole tempo) ma sono OK, proprio come le lezioni normali; e per quelli come me ci sono itranscipts, solo che è difficile seguire la lezione e il testo sotto contemporaneamente, il tempo come minimo raddoppia.

Infine: Sure. There are valid reasons to move beyond SICP. Discussione da seguire; io intanto continuo a trovare nuovi tweeps da followare

Linguaggi di programmazione, una segnalazione

Cosa non si trova nel Web! Io poi che non ho fatto la scuola giusta; cioè no, nel senso di sì, ho fatto la scuola giusta ma non quella che avrei voluto, quella per programmatori. Anche perché illo tempore i ‘puters erano molto diversi da quelli di adesso. E anche misteriosi: il primo che ha girato un mio programma non l’ho mai visto; scrivevi il programma (controllando bene), perforavi le schede nell’orario prefissato, avevi diritto a un tempo massimo che era –secondo il me di allora– troppo sotto il minimo ma –secondo il me di adesso– troppo grande; consegnavi il tutto al responsabile e tornavi dopo un paio di giorni; se era tutto OK ti ridava le schede e un paio di fogli di tabulato con il listato e l’output; se andava male l’output era una serie di scritte misteriose. Solo Fortran IV (1966).

Oggi invece –beh lo sapete tutti.
Vero che non devo dirvi nemmeno di Twitter che è come un party dove ci vai perché ti porta un amico che poi ti presenta gente che a loro volta, se vuoi, puoi conoscere, stai a sentire cos’hanno da dire, conosci altri –tutti più hyper-über-smart di te. Ovvio che c’è anche ci fa gossip, parla di calcio, dei marò, … Ma puoi scegliere.
Io per esempio seguo diversi hyper-über-smart molto più bravi di me. E recentemente ho trovato il prof Eugene Wallingford dell Università dell’Iowa (chissà dov’è quella roba lì?).

E pensa te –meravigliosa meraviglia qui– il prof mette online il corso CS3540 Programming Languages and Paradigms.

Chissà se posso sbirciare un pochino; se non se ne accorgono e mi cacciano a calci in cu quel posto là urlandomi che mi denunciano (chissà se capirei l’iowese?).

La prima lezione è OK, non mi hanno cacciato, insisto.
La seconda è ancora meglio: Learning a New Language: Racket.
Uh! la combinazione: Racket 😀 il mio nuovo linguaggio preferito (pari merito con altri Nmila, anzi un po’ di più di tutti gli altri). OK, c’era da aspettarselo, con Twitter ti autoselezioni i follower esaminando i followabili retwittati da chi già segui.

La faccio breve: conto di fare tutta la classe tutto il corso.
Inoltre nella seconda lezione ho trovato tante cose ma una in particolare mi ha incuriosito tanto da proporre su Facebook e Google Plus una domanda, questa:

Domanda per tutti ma in particolare per i mate:
da noi si fa così
  3 +
  5
 --
  8

mentre altri fanno così:
  3
+ 5
 --
  8

perché?
Perché io sarei con gli altri?
Sono solo io?
OK, è una domanda multipla, forse senza senso. Ma forse...
Chissà cosa ne pensano [segue elenco]

Si vede che la domanda era troppo vaga, sempre che avesse un senso; c’è stato chi si è avvicinato (MfM, Marco) ma non so se quello che dice Eugene (posso chiamare così il prof, non è che mi fa cacciare?) è condivisibile:

The prefix notation that Scheme uses has several advantages over other notations, such as infix:

Using prefix notation, we can have an arbitrary number of arguments without repeating the operator. For example, it is easy to write (+ 3 4 8 6 5 4 7 6 5 8 9) using prefix notation. In other notations, this expression would be longer and involve 11 – 1 = 10 operator symbols. (And, even worse, perhaps ten separate evaluations!) This, despite the fact that children as young as second grade learn how to operate on multiple values as a single operation:

               3
               4
               8
               6
               5
               4
               7
               6
               5
               8
             + 9
             ---
              65

Ecco, è vero? Fuori dal Lisp intendo. Cioè se scrivo la mia espressione così diventa più chiara l’operazione? Chiedo anche se questa può sembrare tutta una manfrina per propagandarvi Racket.
Ah! Racket viene aggiornato costantemente, per esempio l’operazione complicata portata come esempio restituisce il valore indicato dal prof nella REPL

ma nell’IDE ottengo

e sì, proprio così:

SICP – pronto? via!

Allora, da tanto che volevo farlo, forse oggi, …
Qui: Structure and Interpretation of Computer Programs – second edition di Harold Abelson and Gerald Jay Sussman with Julie Sussman.
Userò Racket, grazie a SICP Support for DrRacket di Neil Van Dyke.

La pagina iniziale da le istruzioni –semplicissime– per l’installazione del package richiesto, l’unica avvertenza è di lanciare DrRacket con sudo, deve installare 😀

OK, pronto? via!

Per prima cosa memorizzare:

• l’indicazione del linguaggio: #lang planet neil/sicp;
• la home di SICP: https://mitpress.mit.edu/sicp/;
• il PDF del SICP: http://web.mit.edu/alexmv/6.037/sicp.pdf.

OK, mi sa che non ho più scuse, respiro profondo e via!

I think that it’s extraordinarily important that we in computer science keep fun in computing. When it started out, it was an awful lot of fun.

Dall’intro di Alan J. Perlis.

Poi si passa all’idice, Contents, URL da memorizzare: https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html, OK, fatto.

Bella anche la premessa, letta, davvero, giurin-giuretta 😀
Letta anche quella della seconda edizione, tiene conto dell’avvento del Web (sembra ieri):

The World-Wide-Web site www-mitpress.mit.edu/sicp provides support for users of this book. This includes programs from the book, sample programming assignments, supplementary materials, and downloadable implementations of the Scheme dialect of Lisp.

Poi ci sono i ringraziamenti, li leggerò offline, dal PDF, promesso e sono pronto per il primo capitolo. Prossimamente, qui 😀

LOL – Let Over Lambda

Quando uno ridefinisce così un acronimo universalmente riconosciuto al volo dev’essere un nerd davvero über. Ma ‘spetta’n’attimino: è un lisper, quelli che usano il programmable programming language, quello delle macro, quelle vere, mica la robetta di C/C++.
OK, adesso mi spiego 🙄
Sto parlando di Doug Hoyte, ecco come si presenta, qui.
Sì ha un blog da seguire, cioè no, non è aggiornato, abbandonato. Anche la foto di allora è di quando era un über-nerd giovane. Adesso scrive su Hoytech che Feedly si rifiuta di RSSare. Da seguire autonomamente.

Anche perché la novità è non nuovissima ma di quelle ***BREAKING NEWS***: Let Over Lambda—50 Years of Lisp.

Un libro di quelli intimidatori per la mole, 384 pagine 15×23 cm, pieno di Common Lisp.
Poco per volta, per chi ha pazienza e pochi €, Doug lo sta mettendolo online; anche se è uno di quelli che qualificano la propria biblioteca 😉 ma attenti che se lo vedo lo prendo, vedo se ci sono segnalibri, lo apro e controllo sottolineature e note, nèh.

Io l’ho subito messo tra le cose da fare, non subitissimo ma abbastanza urgenti (non urgentissime). Altamente consigliato ai lispers tutti. E un ringraziamento particolare al prof Lipari 😀 che me l’ha segnalato.

Lisp – ecco Babbo Natale

Cioè non lui, o forse sì ma per interposte persone, stroia complicata adesso vi spiego, anzi riparto.

Vi interessa il Lisp? Anche per l’aspetto storico, altrimenti oggi potete scegliere tra CL (common Lisp) e Racket (o più genericamente Scheme). Io di Racket mi sono preso una cotta con i controfiocchi 😀 über-bellissimissimo, e vedo spesso che si usa come intro alla programmazione in diversi posti sexy –ma sto andando OT.

Allora c’è Rainer Joswig che in questi giorni sta twittando link a millemila libri sul Lisp (tutti Springer finora ma chissà…).

Troppi per elencarli tutti, si può seguire herr Rainer (consigliato) o l’hashtag #lisp. Anzi no, da vedere tutti e due, sull’#hash si trovano altri lispers.

Purtroppo il tempo è quello che è (come quantità e nel senso di fenomeno di derivazione termodinamica, non nel senso atmosferico) ma proposito per l’anno che viene: devo leggerli, attentamente, al rogo abbandono la narrativa tutta 😀

Un test running joke per Common Lisp e Racket

Continuo a spulciare The Evolution of Lisp di Guy L. Steele Jr. e Richard P. Gabriel.

Perché se uno (io, me) vuole ci trova tanti spunti che si possono sviluppare un modalità semi-LOLlosa, anche senza troppe competenze. Per esempio questo:

A running joke was an acceptance test for nascent Common Lisp implementations developed by Guy Steele. It was in three parts. First you type T; if it responds T, it passes part 1. Second, you define the factorial function and then calculate (/ (factorial 1000) (factorial 999)).
If it responds 1000, it passes part 2. Third, you try (atanh -2). If it returns a complex number, it passes; extra credit if it returns the correct complex number. It was a long time before any Common Lisp implementation passed the third part.

Uh! Una piccola avvertenza: so un paio di aliases perso, questi:

rl='rlwrap sbcl --noinform'
rre='racket -il xrepl'

Part 1

È immediata:

Common Lisp (d’ora in poi CL) è insensitivo al caso, secondo la vecchia scuola, seguendo il Fortran; Con Scheme (e quindi Racket) c’è stata una revisione e uniformizzazione dei nomi, quindi #t. E, ovviamente, si distingue tra maiu- e minuscole.
Però proprio #t e #f fanno eccezione 😉
E i lispers non hanno –ovviamente– F

Per entrambi i linguaggi esame superato brillantemente, passiamo a…

Part 2

Qui diventa più interessante. Comincio con Racket:

OOPS! 😳 troppo grande, in effetti

2567 cifre nella sua rappresentazione decimale 🙄

Però tornando al test ecco:

OK, adesso CL dove c’è che non c’è predefinita la funzione fattoriale ma –hey! when the going gets tough, the tough no, dai è semplice– si può fare:

OK, funziona quindi

😀 esame superato brillantemente, bravi davvero.

Ma…

Part 3

Qui diventa più arduo, c’è qualche duro in sala? perché per CL

quindi

ma Racket risponde male

Lo so che non è un numero di quelli semplici, è complesso, ma di solito li tratta ottimamente. Chissà, rimandato, per adesso.

Ovvio che, come per CL in part 2, si potrebbe scrivere una funzione, non è difficile, ecco la Wiki (come farei…).

Uhmmmm 🙄 non semplicissimo, chissà…

Il risultato di CL merita la lode? Si può verificare con WolframAlpha:

click

WA la sa davvero lunga, da vedere; peccato non sia FOSS 😦

Esiste poi un tool che io adoro da sempre calc

OK, CL, WA e calc rockzs, con Racket ne riparliamo, nèh!

Il Lisp è diverso

Il Lisp è diverso; e i lispers lo sanno, per esempio qui 😉
Io il Lisp l’avevo incontrato leggendo GEB di Hofstader, ne ho già parlato più volte per cui non mi ripeto. Poi recentemente ho riletto GEB e –indovina?– sì 😀
Adesso sono alle prese con una sua evoluzione recente, Racket, prossimamente comincio con esercizi pratici –forse. I racketeers sono über-nerds senza pari, mi trovo spesso in (quasi) difficoltà (quasi) panicose ma fa parte del gioco.

Inoltre, essendo vecchio, m’interessano aspetti storici e sono capitato su un capitolo liberamente disponibile di HOPL2, History of Programming Languages, Volume 2 by Thomas J. Bergin, Richard G. Gibson, Richard G., Jr Gibson, Addison-Wesley, 1995.

Si tratta di The Evolution of Lisp di Guy L. Steele Jr. e Richard P. Gabriel.

Quant’è complicata la storia del Lisp! E tutte quelle varianti che all’inizio inducono perlessità che poi in seguito possono confermarsi come vere perplessità hanno qui una spiegazione: stavano inventando, il mondo era nuovo allora. Peccato che si fermi a una vantina d’anni fa, ma è il guaio della storia. Tanto per il presente (e il futuro?) c’è Racket 😀

Oggi vorrei raccontarne, senza pretese, qualcosa che mi sembra interessante o divertente o –beh ecco 😀
Poi magari ne faccio qualche altra puntata, ho preso appunti 😀

If FORTRAN is the language that pushes numbers around, and C is the language that pushes characters and pointers around, then Lisp is the language that pushes programs around. Its data structures are useful for representing and manipulating program text. The macro is the most immediate example of a program written in a metalanguage. Because Lisp is its own metalanguage, the power of the entire programming language can be brought to bear on the task of transforming program text.

Sussman also spent a fair amount of time at MIT teaching Lisp to undergraduates. Sussman thought it was absolutely crazy to have to tell students that the quotient of 10.0 and 4.0 was 2.5 but the quotient of 10 and 4 was 2. Of course, nearly all other programming languages have the same problem (Pascal [] and its derivatives being notable exceptions), but that is no excuse; Lisp aspires to better things, and centuries of mathematical precedent should outweigh the few decades of temporary aberration in the field of computers. At Sussman’s urging, the / function was defined to return rationals when necessary, so (/ 10 4) in Common Lisp produces 5/2. (This was not considered a radical change to the language. Rational numbers were already in use in symbolic algebra systems. The developers of Common Lisp were simply integrating into the language functionality frequently required by their clients, anyway.)

Più avanti nella stessa pagina di parla di / (slash) che anticamente per il Lisp (in una sua implementazione almeno) aveva la funzione oggi pressoché universale di \ (backslash): The committee eventually decided to swap the roles of slash and backslash, so that slash became alphabetic and backslash became the character quoter, thus allowing the division operation to be written “/” instead of “//” and allowing rational numbers to be written in conventional notation. This also solved some problems caused by a then little-known and little-loved (in the Lisp community) operating system called Unix, which used backslash as a character-quoter and slash in file names. However, it was a major incompatible change from MacLisp and Zetalisp, which left Common Lisp open to quite some criticism.

LOL, che Unix avesse molti detrattori non è una novità, ma oggi è raro sentirlo ricordare in questi termini.

Ci sono tantissime altre cose notevoli, anche divertenti come quelle di Yu Hsiang 😀 e DWIM :grin:; prevedo altre puntate, prossimamente… 😉