gobasic

I wrote a golang BASIC interpreter a few years ago, which was inspired by my ZX Spectrum: https://github.com/skx/gobasic And later still I wrote an adventure game in Z80: https://github.com/skx/lighthouse-of-doom The Spectrum was how I got into programming, and despite the limitations I have fond memories.

At that kinda age I opened up google-docs, set the browser to full-screen, increased the font-size and let the child "type" He loved writing "adsdfdsfjkldf", and sometimes he'd painstakingly type his own name. Later I implemented the classic guessing-game "I'm thinking of a number", "that was too high", "that was too low", and we talked about choosing the number in the middle: https://github.com/skx/gobasic/blob/master/examples/55-game.... Later still things got more interesting when he could both type but also read, and I implemented a simple text-based adventure game for him to play with: https://github.com/skx/lighthouse-of-doom/ As for him using the computer? Nowdays he watches videos of minecraft stuff on youtube, but has zero interest in coding, experimenting, or learning how it works. That's fine, he's not me and he can have his o

I wrote a simple BASIC interpreter based on happy memories of the speccy, but to be honest I have more fun these days writing toy projects in z80 assembly. I guess it's all about nostalgia either way though. The early experience in hacking games for infinite lives lead me to assembly, and z80 became x86. There was a lot in common removing anti-copying protection to getting infinite lives! Though modern games don't really appeal to me as much as Dizzy did, or the old-school fighting games. https://github.com/skx/gobasic https://github.com/skx/lighthouse-of-doom/

I wrote a BASIC interpreter in golang a few years back, and somehow the child really fell in love with the classic "guess the number" game: https://github.com/skx/gobasic/blob/master/examples/55-game.... I taught him how to divide the range in half to cut down on the number of guesses, and once he got the hang of that he was hooked. We played a couple of simple text-based games together after that, but most of the classics were too hard, too long, and required too much typing for him. So the game I made was deliberately simple. Even so the first time he played he had no idea that a rug could cover a trapdoor. That level of hiding things was too much for him to leap to himself, I had to direct him. These kinda shared activities don't replace his love of Minecraft, or Super Mario Bros (original NES version!), but I'm still glad we can do

There are a bunch of BASIC interpreters out there, my own isn't so complex or thorough, but I definitely had fun writing it: https://github.com/skx/gobasic/ My own vision was to reproduce something akin to the ZX Spectrum, rather than the more advanced Microsoft BASIC.

Unusable might be a bit harsh, but I have to say that when I wrote my own BASIC interpreter last year I deliberately concentrated on the line-numbers and facilities of the ZX Spectrum I remembered: https://github.com/skx/gobasic Being standalone it doesn't have the graphic support or the interactivity, but it was still a fun project to work upon.

Note that there is a bug: 10 PRINT "OK" 20 GOTO 1 That reports an error "Cannot go to a nonexistant line". I think "real" BASIC interpreters would fall-through to the 10-line. I know my own toy BASIC does: https://github.com/skx/gobasic Edit: Have reported issue, so it doesn't get lost in this thread.

I wrote a trivial BASIC interpreter too, in golang: https://github.com/skx/gobasic

I wrote a simple BASIC too, for nothing more than a sense of nostalgia: https://github.com/skx/gobasic

I made a simple BASIC interpreter in golang, and one of the sample programs allows you to enter BASIC into a browser and see a PNG of the output. I called that "visual basic" even though it is nowhere near the same thing! https://github.com/skx/gobasic I had way more fun than I expected tinkering with it though, made me very nostalgic for the ZX Spectrum which was my first computer.

I had fun writing my own BASIC - less advanced, as I had no graphics, but also designed to be embedded in golang applications. I accept that 99% of the software I publish will have zero users, so even if it's no good for others it is still rewarding for its own sake. As for why? Nostalgia. The first computer I owned was a ZX Spectrum that booted to BASIC. I loved it. I still love writing in BASIC, and I still play spectrum games under emulation at least once every few months. My BASIC is like this one, fun to write, fun to tinker with, and at the end of the day it doesn't matter if others don't care/like it too https://github.com/skx/gobasic

Yeah a lot of the early computers wouldn't have the grunt to parse into an AST. Instead they'd write bytecode, or interpret the code at runtime pretty efficiently. Storing programs as bytes instead of ASCII wasn't uncommon either. (e.g. "PRINT" -> 0x02, etc). I wrote a simple BASIC interpreter for golang, and did something a little more high-level, but not by much: https://github.com/skx/gobasic

I've been following a few different BASIC projects over the past few months, it seems that there is a sudden rise of them. Whether nostalgia, or just fun/learning/experimentation is to blame I can't say. My own BASIC is very simple, but easy to embed/extend: https://github.com/skx/gobasic I sometimes consider extending it with WHILE/WEND, named functions, and similar. But then I remember the constraints are part of what makes it interesting to me. I still remember the Christmas when I received 48k Spectrum, with my sisters. The tape-deck didn't work, so my sisters lost interest. I worked my way through the (spiral-bound orange) manual, typing BASIC and having a blast. Later we got a cassette recorder which worked, and I started playing games, and hacking them for infinite lives. I think my initial love/enthusiasm for typing in BASIC

I wrote a simple BASIC interpreter inspired by the Sinclair, over here https://github.com/skx/gobasic

Looks good, you might compare to this implementation of Monkey with a bunch of extensions (such as "objects", regular expressions, and a standard-library written in the language itself): https://github.com/skx/monkey/ A similar idea allows embedded usage of a scripting language, as a filter: https://github.com/skx/evalfilter/ Of course it gets addictive writing little languages, so you'll probably want to have fun and try making more! I went with BASIC: https://github.com/skx/gobasic But then you start thinking about assembly language: https://github.com/skx/math-compiler