Archivi Categorie: Basic

Il linguaggio di Programmazione Basic, e i suoi dialetti

SmallBASIC

Quelli che hanno avuto la fortuna di trovarsi con l’età giusta al momento dello sboccio dei personal computer hanno un grande rimpianto: non c’è più il BASIC di una volta!
Anche per quelli che non lo dicono, o a domanda negano, in realtà la pensano così.

Io, purtroppo, a quella stagione non ho partecipato: ero troppo vecchio e avevo un ‘puter (allora si chiamava calcolatore, termine che ogni tanto mi scappa ancora) ben più grosso, diciamo che pesava diversi quintali e aveva ben 1/2 MegaByte di RAM. E si usava solo il FORTRAN, anche se c’erano ben due interpreti BASIC (ma se vi racconto storie su di loro rischio di far arrabbiare qualcuno, anzi diversi che sanno dove trovarmi).


Il BASIC allora. Intanto ce n’erano diversi, molto diversi tra di loro, alcuni raffinati altri molto meno. Mi ricordo un giovane che scriveva codice a una velocità incredibile senza lasciare spazi fra le parole e mettendo le istruzioni sulla stessa riga, separate da due-punti, GOTO e GOSUB come se piovesse, poi ha lavorato anche in Microsoft. A proposito, fare un interprete BASIC dev’essere relativamente semplice, ne ha fatto uno anche Bill Gates (si dice).

Quando poi il PC IBM si è imposto il BASIC era doppio: Basica sull’IBM e GW-BASIC (quello di Bill) sui compatibili. Ma forse qualcuno si ricorda anche il Turbo Basic, poi PowerBASIC.

Poi da Microsoft sono usciti QuickBasic (e QBasic) e VisualBasic prima per DOS e poi per Windows, non male quest’ultimo, la sua interfaccia grafica ha fatto scuola.

Poi a Redmond si sono poi convertiti al C/C++ e varianti, anche se gli adepti del Basic hanno resistito a lungo e se ne trovano ancora.

Tutta questa premessa per introdurre un post faticoso: l’ho riscritto più volte e è nato per via di un incontro tra vecchi, di quelli che si fanno attorno tra Natale e Capodanno.


Allora il mio amico, chiamiamolo Alberto, che ormai non scrive più codice ma dirige e raccomanda Java mi ha parlato di SmallBASIC, per lamentarsi che non sia portato avanti come si dovrebbe.

SmallBASIC is a fast and easy to learn BASIC language interpreter ideal for everyday calculations, scripts and prototypes. SmallBASIC includes trigonometric, matrices and algebra functions, a built in IDE, a powerful string library, system, sound, and graphic commands along with structured programming syntax.

Sì ha ragione, SmallBASIC è come il BASIC di una volta, fatto bene, c’è una comunità e un forum attivo, si possono trovare cose sorprendenti, come quest’implementazione di life di JH Conway, scritto con la sintassi antica, probabilmente si tratta di un porting da chissà dove.

SmallBASIC è stato creato da Nicholas Christopoulos di cui si hanno scarse notizie: ha un suo sito, in greco.

Il progetto è adesso gestito da Chris Warren-Smith di Brisbane nel cui profilo Twitter si presenta come “Parent, Programmer, Musician, Cyclist…“.

OK, adesso dovrei fare la conclusione: SmallBASIC è carino, buono ma il mondo è andato avanti. Oggi l’equivalente del BASIC è Python (secondo me) o Java (per Alberto).

Avvertenza: Microsoft ha un basic che si chiama, indovinate come, sì, SmallBasic, non c’entra niente con SmallBASIC — vedete che tra maiuscolo e minuscolo c’è differenza anche al di fuori di Unix/Linux? :-D

Ancora su BaCon (e newLISP)


Questo post è un po’ più atipico del solito 8) Potrebbe essere considerato come una continuazione a quello su BaCon o un semplice esercizio per il trattamento delle stringhe in newLISP. In quest’ultimo caso sarebbe classificabile come un sottoprodotto di cose fatte nel torrido agosto: i side effects sono molto comuni, anzi l’essenza del Lisp 8)

In ogni caso in conclusione del post citato mi lamentavo del fatto che le keyword di BaCon dovessero essere scritte tutte in maiuscolo. E allora, presto, lanciare newLISP che per queste cose è ottimo. A dire il vero andrebbe bene anche Python, o il C++, o, perché no, BaCon 8)

OK! finita la premessa senza troppo senso, ecco lo script che cerca le parole chiave (keyword) elencate nel file kwlist e le sostituisce con l’equivalente maiuscolo. Attenzione che non basta cercare la stringa costituente la keyword: potrebbe far parte di una parola più lunga. Per questo motivo viene valutata la parola composta dalla keyword con i due caratteri immediatamente precedente e seguente. Questi delimitatori devono essere compresi nella stringa sep –riga 7.

#!/usr/bin/newlisp

(define (in? inst , t sep)
		(if (= inst (upper-case inst))
			(set 't nil)
			(begin
				(set 'sep " \n\r\t(),.+-*/=;:'$")
				(not (not (and (find (first inst) sep)
							   (find (last inst) sep))))
			)
		)
)

(set 'argv (main-args))
(set 'narg (length argv))

; nome dell'eseguibile o dello script
; il primo indice dei parametri è pex + 1
(if (= "newlisp" (argv 0))
	(set 'pex 1)
	(set 'pex 0)
)
(set 'xname (real-path (argv pex)))

; directory dell'eseguibile o dello script
(set 'lp (parse xname "/"))
(pop lp -1)
(set 'xpath (join lp "/"))

; file delle keywords
(if (> (- narg pex) 2)
	(set 'kwfile (join xpath (argv (+ pex 2)) "/"))
	(set 'kwfile (join (list xpath "kwlist") "/"))
)

(set 'kwlist (string (read-file kwfile)))
(set 'kt (parse kwlist))
(set 'kwl (explode kt))
(set 'nkwl (length kwl))

; file di BaCon
(if (> narg pex)
	(set 'sorgente (argv (++ pex)))
	(set 'sorgente "bacon.bac")
)

(set 'text (read-file sorgente))
(push "*" text)
(push "*" text -1)

(set 'updated nil)
(for (c 0 (-- nkwl))
	(begin
		(set 'word-a (kwl c))
		(set 'katt (string (word-a 0)))
		(set 'lkatt (length  katt))
		(set 'rkw (upper-case katt))
		(set 'ppos 0)
		(set 'pos (find katt text 1 ppos))
		(while pos
			(begin
				(set 'st (pop (copy text) (-- pos) (+ lkatt 2)))
				(if (in? st)
					(begin
						(set 'updated true)
						(pop text (++ pos) lkatt)
						(push rkw text pos)
					)
				)
				(set 'ppos (+ pos lkatt 1))
				(set 'pos (find katt text 0 ppos))
			)
		)
	)
)

(if (not updated)
	(exit)
)

(pop text 0)
(pop text -1)
(set 'bak (join (list sorgente "bak") "."))
(if (file? bak)
	(delete-file bak))
(rename-file sorgente bak)
(write-file sorgente text)

(exit)

Per testarlo sono ricorso all’esempio trovato in questa pagina, copiandolo scrivendo tutto minuscolo, così

N.B.: rispetto al listato nella pagina indicata c’è la dichiarazione che la variabile e è int; senza l’istruzione FORMAT da errore e la compilazione abortisce.

Lo script uk.nl è stato compilato, come raccontato in questo post per cui possiamo eseguirlo, in questo modo

Vediamo che le keyword adesso sono come BaCon comanda e possiamo andare avanti

OK. Ma adesso esageriamo (con giudizio nèh!): prendiamo un esempio a caso di quelli indicati, che ne dite del demo calculator? Dopo averlo salvato lo converto tutto in minuscolo con tolower.nl, raccontato qui, lo processo con uk, lo compilo e lo lancio: funziona! (Non riporto le immagini, non direbbero niente di nuovo).

Quindi tutto a posto?
Quasi: il package HUG per gestire la grafica non rispetta la convenzione del maiuscolo. Anche perché include direttamente chiamate a funzioni C. E allora per tutto quanto riguarda HUG niente da fare: dovete fare attenzione al caso.

E questo per il Basic dovrebbe essere sufficiente. O no? 8)

BaCon – un altro linguaggio

Preparando il post su Genie  mi sono imbattuto nella pagina The Genie Language   in cui l’autore, Barry Kauler, annunciava di aver cambiato linguaggio, scegliendo BaCon.


È il caso di farsi scappare una notizia del genere? Almeno una sbirciatina bisogna dargliela –chissà cos’è, com’è, cosa fa– dai presto :-D

E questo è il risultato. BaCon sta per Basic Converter. Ma con tutti i linguaggi nuovi chi può essere interessato a BaCon? Davvero una buona domanda (sì sto traducendo).

Sviluppato da Peter van Eerten è estremamente facile da imparare e usare. Ed è una celebrità su Puppy Linux, guardate qua.

Nel sito di Peter su BaCon si trova tutto: il package per l’installazione su Ubuntu, guide e manuali, tantissimi esempi, tutto quello che può servire insomma.

E allora?
Allora solo un esempio di cosa si può ottenere, un orologio digitale, il cui sorgente è lungo 232 linee 118 delle quali per definire le dieci cifre 0-9.
E questo è il risultato.

Lo userò?
Forse; dipende da cosa devo fare. A me il Basic (GW, Quick, Visual) non è mai stato particolarmente simpatico. Anticamente c’era il Turbo Basic della Borland che era molto più snello e performante dell’equivalente Microsoft, ma nessuno lo apprezzava. Recentemente per la scuola ho avuto a che fare con la versione gratuita di Visual Basic ed è decisamente scioccante: grosso e esoso di RAM oltre ogni limite e, naturalmente solo per Windows (che era peraltro il SO richiesto).

BaCon è tutt’altra cosa: intanto è per i sistemi operativi seri

ma la genialata è che prende il codice Basic e lo converte in C. Poi compila questo. Ha quindi a disposizione tutte –va be’ tante– librerie scritte per il C.

Per contro a scrivere codice per BaCon mi viene l’orticaria: tutte le keywords devono essere in maiuscolo; mi verrebbe voglia di fare uno scriptino che le scovi e converta –forse prossimamente…

Poi comunque di bacon c’è chi preferisce questo

ma non adesso: fa troppo caldo 8)

Gambas, Gambas Almost Means BASIC

It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration.” (Edsger W. Dijkstra, EWD498, 1975).
Non so se sia giusto e/o condivisibile. La rivoluzione dei PC, personal computer come si diceva allora, esplosa alla fine degli anni 70 è intimamente e inestricabilmente connessa con il Basic.
Oggi i fortunati ragazzini che hanno avuto la fortuna di avere un Atari, un Sinclair, un Commodore o simili (io no: ero troppo vecchio e lavoravo su dei macchinoni dove c’era solo il Fortran, macchinoni che la rivoluzione ha spazzato via) sono cresciuti e alcuni ogni tanto si ricorda ancora di allora, vero prof. Lipari?
Anche a livello più professionale (cioè più costoso) i PC non erano molto dissimili a quelli citati. Prima che IBM introducesse il suo, affidandosi a Microsoft per il software, era normale che ogni macchina avesse un suo sistema operativo. Questo era molto elementare, doveva stare su un dischetto (allora si chiamava floppy) che poteva memorizzare da 100 a 360 KB. Sì kilobytes che in italiano diventava kappabait e fuori nessuno capiva (per i francesi erano kilo-octets, ma questo è un altro discorso).
Io mi ricordo di due PC in particolare: l’Apple ][ e l’HP9816

Poi con l’avvento di IBM il mondo è cambiato, sono nati i cloni (da noi noti con il nome di compatibili, il primo è stato il Compaq), il DOS è diventato il sistema operativo comune a tutti (o quasi, Apple non ha mai fatto comunella con nessuno, ma anche altri come Commodore Amiga e Archimedes) e Microsoft è diventata Microsoft.

Purtroppo allora non c’era Linux! E Microsoft credeva nel Basic. Questo veniva dato con il sistema operativo, come GWBASIC, e davvero è difficile non dar ragione a Dijkstra: tutte le variabili erano globali, il GOTO era comune più del sale in cucina, le procedure (GOSUB) creavano più che altro problemi (era possibile uscire con un GOTO invece del RETURN o saltare nel mezzo di un’altra procedura). Inoltre era normale scrivere codice disordinato, niente indentazione, più istruzioni sulla stessa riga, separate da due-punti. Ah ogni riga iniziava obbligatoriamente con il numero di linea. Una skifetsa, davvero, ha ragione EWD.

Col tempo il Basic si è evoluto, in modo straordinario: sono convinto che nessun linguaggio di programmazione è cambiato così tanto.Per quel che ne so oggi anche Microsoft l’ha un po’ abbandonato, forse era diventato troppo standard per i loro gusti ;-)

E quelli che comunque lavoravano con il Basic (Visual Basic) con Windows e hanno deciso di passare a Linux e si sentono orfani del Basic? Ecco giunto il momento di introdurre il nostro eroe: (rullo di tamburi per favore)

Benoît Minisini

francese di Parigi nato nel 1972 che si ricorda di Amstrad e Atari e poi è passato a altri ‘puter e linguaggi (visto EWD che si può?)… (è tutto qui).

La creatura di Benoît si chiama Gambas, nome che è tutto un programma: Gambas Almost Means BASIC.

Ed è davvero bello, impressionante: avete presente Visual Basic o Delphi? Ecco vi trovate in una GUI molto simile, creare finestre, pulsanti, menu, etichette e quant’altro consiste semplicemente nel selezionare l’oggetto dalla tavolozza, posizionarlo, modificare le sua proprietà nella tabella delle proprietà e dirgli cosa fare con un doppio click.

Per Ubuntu l’installazione è semplicissima, basta selezionare gambas2 in Sistema/Amministrazione/Gestore pacchetti. Scaricherà millemila files sul vostro ‘puter (fino a 160MB) e il gioco è fatto: non resta che provare. E quando avete finito, sempre all’interno dell’IDE, potete creare il pacchetto per l’installazione. Bravo Benoît!

Q&A
Immagino tutta una serie di cose che si potevano dire e non lo sono state, quante domande sono possibili! Eccone alcune di quelle più probabili.

Q: Hai fatto un’introduzione lunghissima e poi te la sei cavata con un paio di paragrafi
A: Sì, Gambas è talmente ben fatto che potete andare avanti da soli. In effetti io mi sono arenato su una cosa: volevo trascinare un oggetto dal desktop e dropparlo su un’area sensibile di una finestra Gambas, non ci sono riuscito, ma per il resto è OK.

Q: Viene utilizzato da qualcuno?
A: Sì. Tra i linuxiani italiani più conosciuti posso citare Gusions e Guiodic.
Un blogger che ammiro moltissimo, anche se ha quasi smesso di postare, Blake Stacey, uno di quelli che è nato con i PC della rivoluzione di cui sopra invece usa un altro linguaggio, ma conviene leggersi questo suo post.

Q: come si pronuncia “Dijkstra”?
A: bella domanda! Gli olandesi non si sono nemmeno messi d’accordo se “IJ” si possa scrivere “Y“. E non avete idea di come pronunciano “G“; invece “V” la leggono come “F“. Ma non è un caso isolato, pensare ai Bernoulli, che oltretutto sono una tribù. E a Delphi: c’è qualcuno in Italia che lo chiama “delfai“, a parte me, quando mi ricordo?

Q: hai citato un sacco di prodotti, non bisognerebbe mettere ™ dopo il loro nome così™?
A: sì bisognerebbe ma mi fa senso, se proprio ci tenete fate come se l’avessi fatto.

 

Iscriviti

Ricevi al tuo indirizzo email tutti i nuovi post del sito.

Unisciti agli altri 63 follower