Video Poker Takes Your Money In 10 Lines Of BASIC

It wasn’t easy, but [D. Scott Williamson] succeeded in implementing Jacks or Better Video Poker in 10 lines of BASIC, complete with flashing light and sound! Each round, one places a bet then plays a hand of 5-card draw, hoping to end up with Jacks or better.

This program is [Scott]’s entry into the 2024 BASIC 10 Liner Contest, which at this writing has concluded submissions and expects to announce results on April 6th 2024. Contestants may choose any 8-bit computer system BASIC, and must implement their program within ten lines of code (classically limited to 80 characters per line, but there are different categories with different constraints on line width.)

10 lines of BASIC is truly an exercise in information density.

We’ve seen impressive 10-line BASIC programs before, like this re-implementation of the E.T. video game. (Fun fact: while considered one of the worst video games of all time, there’s a compelling case to be made that while it was a flop, it was ahead of its time and mostly just misunderstood.)

These programs don’t look much like the typical BASIC programs many of us remember. They are exercises in information density, where every character counts. So we’re delighted to see [Scott] also provides a version of his code formatted and commented for better readability, and a logical overview that steps through each line.

He spends a little time talking about the various challenges, as well. For example, hand ranking required a clever solution. IF…THEN conditionals would rapidly consume the limited lines of code, so hands are ranked programmatically. The 52-card deck is also simulated, rather than simply generating random cards on the fly.

The result looks great, and you can watch it in action in the video, just under the page break. If this sort of challenge tweaks your interest, there’s plenty of time to get started on next year’s BASIC 10 Liner Contest. Fire up those emulators!

Continue reading “Video Poker Takes Your Money In 10 Lines Of BASIC”

A ZX Spectrum Raytracer, In BASIC

[Gabriel Gambetta] knows a few things about ray tracers, being the author of Tiny Raytracer, a raytracer written in just 912 bytes of JavaScript. As a long-time fellow sufferer of the UK-designed ZX Spectrum, could these two love affairs be merged? Could the Tiny Raytracer fit on the ZX Spectrum? In BASIC? The answer is an affirmative, albeit with our beloved speccy’s many limitations.

Ray tracing with only 15 primary colours

The story starts with [Gabriel]’s Computer Graphics From Scratch (CGFS) raytracer algorithms and an existing code base that was ported to the ZX Spectrum’s very limited BASIC dialect, using VSCode for editing, BAS2TAP to generate a tape image file (essentially an audio track) and executed with FUSE. With the toolchain sorted, [Gabriel] adds just enough code to deal with the ray intersection equations of a sphere, and renders a three-sphere scene to a 32×22 pixel colour image, taking a mere 15 minutes of runtime. Fellow sufferers will remember the spectrum had a 32×22 block attribute array (or colour array) with two colour values for foreground and background pixels. Each attribute block contains 8×8 pixels, each of which could be foreground (on) or background (off.) The next stage was then to expand the code to handle pixels as well as blocks, by simply expanding the raytracing to the full 256×176 resolution, and for each block simply determine the two most common colours, and run with those for the whole block. It sort of works, in a very spectrum-esq ‘attribute clash’ kind of fashion.

Continue reading “A ZX Spectrum Raytracer, In BASIC

BASIC In Your Browser

If you are a certain age or just like retrocomputers, you probably have a soft spot for good old-fashioned BASIC. If you miss those days but don’t want to install a modern interpreter, you don’t have to. Just load a web page containing the “BASIC Anywhere Machine” from [CJ Veniot]. Worried about it being “in the cloud?” It isn’t? It runs in your browser, and if you are a TiddlyWiki fan, it will even live inside your Wiki, which you can host as you please.

The project has lots of features, including some integration back into TiddlyWiki, which we haven’t tried. But you can use graphics commands, work with the mouse, and do other fun things.

Continue reading “BASIC In Your Browser”

Is Microsoft BASIC Hidden In This Educational Child’s Toy?

The VTech PreComputer 1000 is a rather ancient toy computer that was available in the distant misty past of 1988. It featured a keyboard and a variety of simple learning games, but does it also feature Microsoft BASIC? [Robin] of 8-Bit Show and Tell dove in to find out.

Officially, the PreComputer was programmable in a form of BASIC, referred to by VTech as PRE-BASIC V1.0. Given that the system has a Z80 CPU and there’s little information in the manual about this programming language, [Robin] was suspicious as to whether it was based on Microsoft BASIC-80. Thus, an examination was in order to figure out just how this BASIC implementation worked, and whether it shared anything with Microsoft’s own effort.

We won’t spoil the conclusions, but there are some strong commonalities between VTech’s BASIC and Microsoft’s version from this era. The variable names in particular are a strong hint as to what’s going on under the hood. The video is worth a watch for anyone that’s a fan of early microcomputer history, BASIC, or just the weird computer-like devices of yesteryear. We also love the idea that the PreComputer 1000 was actually quite a capable machine hiding behind a single-line LCD display.

Continue reading “Is Microsoft BASIC Hidden In This Educational Child’s Toy?”

The End Of Basic?

Many people, one way or another, got started programming computers using some kind of Basic. The language was developed at Dartmouth specifically so people could write simple programs without much training. However, Basic found roots in small computers and grew to where it is today, virtually unrecognizable. Writing things in something like Visual Basic may be easier than some programming tasks, but it requires a lot of tools and some reading or training. We aren’t sure where the name EndBasic came from, but this program — written in Rust — aims to bring Basic back to a simpler time. Sort of.

You can run the program in a browser, locally, or connected to a cloud service. It looks like old-fashioned Basic at first. But the more you dig in, the odder it gets. The command line is more akin to a Python REPL. You type things, and they happen. It took a while to figure out that you need to enter EDIT to write a program. Then, what you type gets saved until you press escape. The syntax is Basic-like but has oddities. There are no line numbers, but you can use labels that start with an at sign.

Continue reading “The End Of Basic?”

TinyBasicLike: A Target-Independent BASIC Interpreter

In the long and winding history of BASIC, it’s sometimes hard to keep track of all the different variants and dialects. Some may still remember TinyBASIC, which was published in 1976 as Palo Alto Tiny BASIC by [Gordon Brandly]. Later, TinyBASIC was modified by a number of people including [Scott Lawrence] who created TinyBASIC Plus (TBP). Inspired by this, [Karl] figured he could improve on TBP by making the original C-based project even easier to port by removing whatever platform dependencies he could find, creating what he calls TinyBasicLike.

The main change is that TinyBasicLike consists out of two C files, with one containing the core code, and the second the platform-specific details that can be used by the core. Although [Karl] started off with the Palo Alto Tiny BASIC-like code by [Scott Lawrence], he decided to make it into his own by making a few alterations, such as adding left and right shift operators, adding an ADDR() function, expanding the features of INPUT and adding multiple logical operators.

In the example STM32F4 project linked on the project page it is demonstrated how to target a new platform with TinyBasicLike. Performance on the STM32F4 Discovery board with a simple counting loop yielded about 6 lines of TBL program code per millisecond. For a 168 MHz STM32 MCU that’s definitely not astounding, but considering how straightforward Tiny BASIC (and TBL as a consequence) is, it’s definitely no slouch.

This is probably a good time to remind that BASIC was the original champion of cross-platform programming and the source of countless fond (and frustrating) memories.

Quantum Computing On A Commodore 64 In 200 Lines Of BASIC

The term ‘quantum computer’ gets usually tossed around in the context of hyper-advanced, state-of-the-art computing devices. But much as how a 19th century mechanical computer, a discrete computer created from individual transistors, and a human being are all computers, the important quantifier is how fast and accurate the system is at the task. This is demonstrated succinctly by [Davide ‘dakk’ Gessa] with 200 lines of BASIC code on a Commodore 64 (GitHub), implementing a range of quantum gates.

Much like a transistor in classical computing, the qubit forms the core of quantum computing, and we have known for a long time that a qubit can be simulated, even on something as mundane as an 8-bit MPU. Ergo [Davide]’s simulations of various quantum gates on a C64, ranging from Pauli-X, Pauli-Y, Pauli-Z, Hadamard, CNOT and SWAP, all using a two-qubit system running on a system that first saw the light of day in the early 1980s.

Naturally, the practical use of simulating a two-qubit system on a general-purpose MPU running at a blistering ~1 MHz is quite limited, but as a teaching tool it’s incredibly accessible and a fun way to introduce people to the world of quantum computing.