QuickBASIC Lives On with QB64

When I got my first computer, a second hand 386 running MS-DOS 6.22, I didn’t have an Internet connection. But I did have QuickBASIC installed and a stack of programming magazines the local library was throwing out, so I had plenty to keep myself busy. At the time, I thought QuickBASIC was more or less indistinguishable from magic. I could write simple code and compile it into an .exe, put it on a floppy, and give it to somebody else to run on their own machine. It seemed too good to be true, how could this technology possibly be improved upon?

Of course, that was many years ago, and things are very different now. The programming languages du jour are worlds more capable than the plodding BASIC variants of the 80’s and 90’s. But still, when I found a floppy full of programs I wrote decades ago, I couldn’t help but wonder about getting them running again. With something like DOSBox I reasoned I should be able to install the QuickBASIC IDE and run them like I was back on my trusty 386.

Unfortunately, that was not to be. Maybe I’m just not well versed enough in DOSBox, but I couldn’t get the IDE to actually run any of the source code I pulled off the floppy. This was disappointing, but then it occured to me that modern BASIC interpreters are probably being developed in some corner of the Internet, and perhaps I could find a way to run my nearly 30 year old code without having to rely on 30 year old software to do it. Continue reading “QuickBASIC Lives On with QB64”

A Modern, Upgraded BASIC Stamp

Back in the Before Times, when microcontroller development required ultraviolet light, building anything was a pain. You probably had to burn a ROM onto a chip with a parallel programmer, there was no in-circuit programming, and who knows what would happen if you needed a serial port.

This changed in the early 90s with the introduction of the BASIC Stamp from Parallax. This was a simple microcontroller development board using Microchip PIC. With a little bit of clever firmware developed by Parallax, you could write code in BASIC, upload your code over a serial or parallel port (which every computer had), and blink a LED with just a few lines of code. All microcontroller development boards — including the Arduino — owe a debt to the BASIC Stamp. It is the grandfather to the Arduino, and it is very, very old.

Microchip didn’t update the BASIC Stamp, but that doesn’t mean someone else can’t handle that. [Bruce Eisenhard] is crowdfunding an improved, updated version of the famous 24-pin BASIC Stamp. It’s got modern parts, runs seven hundred times faster than the original, and is still chock full of BASIC interpretation.

This upgraded Stamp is built around NXP’s LPC11U3 micrcontroller, an ARM Cortex-M0 part with about a hundred times more Flash than the chip in the original Stamp. Programming is done through modern IDEs, and yes, there’s a USB port. This project is pin-compatible with the original BASIC Stamp, so if your microcontroller project from twenty years ago is dying, this is the replacement for you.

The BASIC Stamp was an awesome device for its time, even though it cost more than two hundred dollars in today’s money. [Bruce]’s campaign is offering one of these for $25, which is pretty reasonable for what it is.

 

Fixing Bugs In Ancient BASIC Games

Before everyone learned programming on Stack Exchange, things were much different. Computer magazines had BASIC programs in them, which readers would type out, line by line, and hit RUN. In theory, this is a terrible way to learn programming; it’s simply rote recitation without any insight into what the code is actually doing. Of course, copying and pasting from Stack Exchange is exactly the same thing, so maybe these magazines were ahead of the curve.

[0xA000] recently came across one of his old computer magazines containing the type-in listing for Blindganger, a game where you wander a maze blindly. When [0xA000] typed this game into his C64 back in 1988, the game didn’t work. Thirty years later, he decided to give it another go and ended up fixing bugs in an old computer game.

When [0xA000] typed this game into his computer back in 1988, the map just didn’t work, and the final screen revealed a maze where the walls were where they shouldn’t be. A quick Google turned up a disk image of the same game that had the same problem. This bug was obviously in the section of code that draws the map at the end of the game, so [0xA000] started looking there. The offending typo in the code was an $F4 instead of an $F5, or 244 instead of 255. This shifted the colors of the map by 11 positions, meaning the locations marked as visited in the final screen were wrong. Whether this bug cropped up in development or was just a simple typo when typesetting the magazine doesn’t really matter now; after 29 years, this bug is fixed.

Usborne Release More 1980s Computer Books

Children of the 1980s who had an interest in technology were lucky indeed. As well as the first generations of home computers at their disposal they had the expectation to program them, something which the generation that followed had lost.

Traditional children’s publishers enthusiastically embraced the home computer boom, and probably for the only time in history there were books aimed at children covering subjects like machine code, or interfacing to microprocessors.

Kid's books were better when we were young! Usborne(Fair use)
Kid’s books were better when we were young! Usborne(Fair use)

If you are British, the most memorable of these books came from Usborne Publishing. Their format of colourful cartoons and easy to digest layout have made them something of a cult object among the now-grown-up generation who first received them, and Usborne themselves have cleverly exploited their heritage to promote their current offerings by releasing some of them as PDFs. And now, to promote their latest title, “Coding For Beginners Using Python”, they’ve released five more (scroll down to see). Titles are “Practice Your BASIC”, “Better BASIC”, “Computer Controlled Robots”, “Experiments With Your Computer”, and “Keyboards & Computer Music”, which join the fifteen they’ve already released.

Obviously they are heavily based around the microcomputers of the 1980s, but of course for most Hackaday readers that will be their chief attraction. Either way they’re an interesting read, and should you happen to have a few old micros lying around then maybe you could have a go at some of the projects.

If the BASIC listings are a little foreign to you, might we suggest some places to find BASIC information.

Flappy Bird is the New “Does it Run Doom?”

Back in 2014 [Johan] decided to celebrate BASIC’s 30 50 year anniversary by writing his own BASIC interpreter. Now, a few years later, he says he feels he has hit a certain milestone: he can play Flappy Bird, written in his own version of BASIC, running on his own home-built computer, the BASIC-1.

Inside the BASIC-1 is an Atmel XMega128A4, a keyboard from a broken Commodore 64, a joystick port, a serial to TV out adapter, and an SD card adapter for program storage. An attractively laser-cut enclosure with kerf bends houses the keyboard and hardware. The BASIC-1 boots into BASIC just like many of its home computer counterparts from the 80s.

Continue reading “Flappy Bird is the New “Does it Run Doom?””

ESP8266 BASIC Sets Up a Web Remote in No Time

One of the sticking points for us with our own Internet of Things is, ironically, the Internet part. We build hardware happily, but when it comes time to code up web frontends to drive it all, the thrill is gone and the project is only half-done.

Including some simple web-based scripting functionality along with the microcontroller basics is one of the cleverest tricks up ESP8266 BASIC’s sleeves. BASIC author [mmiscool] puts it to good use in this short demo: a complete learning IR remote control that’s driven through a web interface, written in just a few lines of BASIC.

Note that everything happens inside the ESP8266 here, from hosting the web page to interpreting and then blinking back out the IR LED codes to control the remote. This is a sophisticated “hello world”, the bare minimum to get you started. The interface could look slicker and the IR remote could increase its range with more current to the LED, but that would involve adding a transistor and some resistors, doubling the parts count.

For something like $10 in parts, though, this is a fun introduction to the ESP and BASIC. Other examples are simpler, but we think that this project has an awesome/effort ratio that’s hard to beat.

Portal Ported To the Apple II

[deater] readily admits they’re a little behind on what’s new in gaming – only having just gotten around to Valve’s 2007 release of Portal. It’s a popular game, but [deater] didn’t want anyone to miss out on the fun – so set about porting Portal to the Apple II.

The port uses the “hires” mode of the Apple II for the flashy graphics that were state of the art around 1980 or so. It’s not a copy of the full game – only the first and last levels, combined with Jonathan Coulton’s now-classic ending theme, Still Alive. As is to be expected, it’s not a wild, fast paced gaming experience, but a cool use of BASIC to put together a fun tribute to a popular franchise.

It’s a little different to the original – portals can be placed anywhere, for example – but it rings true to the original. Source code and a disk image is provided, so you can try it for yourself – even in this online emulator.

We’re looking forward to the sequel so we can use the post title “Portal 2 Ported To The Apple II, Too”, but until then, check out [deater]’s Apple II web server, also in Applesoft BASIC. Video after the break.

Continue reading “Portal Ported To the Apple II”