Introduction

We’ve done 10PRINT on a lot of machines.

But we haven’t done a comparison between Rust and C.

For no particular reason, I thought it would be fun to compare the two languages side by side.

A race? Yes, please.

10 PRINT Quick review

10 PRINT is a one-liner program that generates a maze-like pattern using the characters / and \.

The program is based on a one-liner BASIC program from the late 70s and 80s. There’s even been a book written about it called: “10 PRINT CHR$(205.5+RND(1)); : GOTO 10”.

Wax

Over the years, I’ve looked for an Assembler for the VIC-20. Sure, there are great cross-assemblers like Kick Assembler, but I wanted something that would run on the VIC-20 itself.

Is the VIC-20 a good machine on which to write assembly? Maybe not ON the machine. The 22-column screen is a bit limiting, but after spending so much time in Turbo Macro Pro on the C64, I wanted to see what I could do on the VIC-20 natively.

Over the years, I’ve been on a silly quest to do 10PRINT on as many things as I can. They end up on X, here, or sometimes both.

I hadn’t considered it before because I just figured I couldn’t print the "/" and "\" characters on the HP-42s.

I was wrong. It’s pretty easy. After a few minutes in the manual, I figured it out.

00 { 45-Byte Prgm }
01▸LBL "TEN"
02 RAN
03 RAN
04 X>Y?
05 GTO "\"
06▸LBL "/"
07 ├"/"
08 AVIEW
09 PSE
10 GTO "TEN"
11▸LBL "\"
12 ├"\"
13 AVIEW
14 PSE
15 GTO "TEN"
16 END

The program is pretty simple. It generates two random numbers and compares them. If the first is greater than the second, it prints a "/" and goes to the next iteration. If the second is greater than the first, it prints a "\" and goes to the next iteration.

My son, now 25, was a McNuggets fan. Can you blame him? They’re delicious. He’s always been into numbers and puzzles, so I introduced him to the McNuggets problem when he was about 10.

This classic puzzle was a fun way to keep him occupied and teach him programming. The problem is simple: McDonald’s used to sell Chicken McNuggets in 6, 9, and 20 packs. What is the largest number of McNuggets you cannot buy using these package sizes?

Back to the basics with basic

Let’s say for a moment that we’ve got an ordered list of numbers.

1,3,5,7,9,11,13,15,17,19,21,23,25

There are 13 values here and we want to check if the number 25 is in this list.

One way to do this would be to loop over each element in the list and check to see if it matches what we’re looking for.

In BASIC, we’d do something like

I’ve done a lot of silly math, ciphers and asked a lot of my vintage hardware on this site over the years. But I’ve not talked a ton about optimizing code for faster results.

Today, we will count from 0 to 2^24-1 (16,777,215). Nothing else. Count, time it, and see how fast we can get it to go.

Rust

In Rust on my 2020 MacBook Pro:

use std::time::{Instant};

fn main() {
    // Start timing
    let start = Instant::now();
    // Loop from 0 to 16777215
    for _i in 0..=16777215 {
        // The loop body is empty, just like in the BASIC code
    }
    // Calculate elapsed time
    let duration = start.elapsed();
    // Convert elapsed time to seconds
    let elapsed_seconds = duration.as_secs() as f64
        + (duration.subsec_nanos() as f64 / 1_000_000_000.0);
    println!("Counting to 16777215 took {} seconds", elapsed_seconds);
    println!("That's {} additions per second", 16777216.0 / elapsed_seconds);
    println!("On 2 GHz Quad-Core Intel Core i5")
}

Recently, we looked at a simple LFSR and how it works.

1. Shift the bits
2. XOR some of the bits together; we call these the taps
3. Replace a bit with the XORed value.
4. Repeat

Easy peasy.

I’ve long been fascinated by the Sound Interface Device (SID) in the Commodore 64, mostly because you can use it to get random numbers.

But how does it work?

The Commodore 64 SID LFSR is 23-bits. It’s a maximal length LFSR, which means it will cycle through all 8,388,608 numbers before repeating. It’s often used to generate random numbers in games. Or if you’re nuts, you can use it to do cryptography on a Commodore 64. Who would ever do that?

What is an LFSR?

An LFSR is a Linear Feedback Shift Register. It’s a simple way of generating a sequence of numbers that look random.

Used in cryptography and in generating pseudo-random numbers, they are interesting because they are so simple. Shift bits and feed a few of them back into the sequence. That’s it.

Important note: LFSRs are not cryptographically secure on their own. ESPECIALLY 8-bit LFSRs. More on that in the next post on this topic.

Commodore BASIC 2.0

A lot of fun with binary numbers can be had by printing them to the screen. This is a quick post to show how to do that with Commodore BASIC 2.0. This is a follow up to Quick Post: XOR in Commodore BASIC 2.0.

We’ll be using both of these in upcoming posts, so it’s good to have them handy.

5 REM PRINT ALL 8 BIT NUMBERS IN BINARY
10 FOR N= 0 TO 255
20 FORI=7 TO 0 STEP-1
25 B=0
30 IF N AND 2^I THEN B=1
40 PRINTMID$(STR$(B),2);
50 NEXT
60 PRINTN
70 NEXT

This prints all the numbers from 0 to 255 in binary. It’s a little slow, but it’s easy to understand and fun to watch.

The “famous” 10PRINT program on vintage computers was a delight for many in the 70s and 80s. It’s fun to port to other platforms and machines.

I’m always looking for calculators that can do it. It requires both a slash - ASCII character 47, and a backslash - ASCII character 92. Most calculators can print the forward slash, but the backslash is only sometimes implemented.

I was recently on a video call with a friend, throwing around some ideas for a new product. I mentioned adding large signed numbers in assembly and using two’s complement. He asked me what two’s complement was. I was a little surprised that he didn’t know. He’s been a Java programmer for more than 30 years. Java and Python programmers (and others like gasp Commodore / MicroSoft BASIC) don’t have a native unsigned integer type. The language takes care of the details for you.

N-Queens Problem

The N-Queens problem is a classic in computer science. Place N queens on an NxN chessboard such that no queen can attack another queen.

Wut.

Imagine you’ve got a chessboard and a bunch of queen pieces. Your mission is to place these queens on the board so that none of them can attack each other. That means no two queens can be in the same row, column, or diagonal. It’s like a puzzle where you’ve got to keep the peace in the royal family by making sure each queen has her own personal space.

I have a BUNCH of nieces and nephews. Over the years, doing some secret message passing with them around birthdays and holidays has been fun.

The “secret” location of hidden Christmas presents is a favorite.

Traditionally, we’ve used a transposition cipher like the Shift or Ceasar Cipher

For something different, we’re going to use another transposition cipher called the Rail Fence Cipher. It is easy to implement and understand. Plus easy to break, so it’s a good teaching tool.

Rockwell International was a powerhouse of the 1970s and 80s.

The Rockwell AIM 65 computer, also known as the Advanced Interactive Microcomputer 65, is an early microcomputer produced by Rockwell International in the late 1970s. It was essentially a development system, intended primarily for engineers, educators, and hobbyists, and was named for its built-in alphanumeric keyboard and LED display.

The AIM 65 was built around the 6502 microprocessor, the same chip used in popular systems like the Apple II, Commodore PET, and Atari 2600. The AIM 65 was designed as a single-board computer, with the processor, memory, input, and output all integrated into one circuit board.

Modern and retro mix

One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.

I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.

In the world of tech, including vintage tech, the lure of the blinkenlight is strong.

And if you don’t like blinkenlights, can we even be friends?

My PiDP-8 might be the ultimate in blinkenlight flexing, BUT we can probably do some other fun stuff if we use math. And science!

My friend Robin’s favorite demo is 10 print. And what’s not to love about 10 print? After all, there’s even a book about it.

My Favorite Demo

My favorite demo is more complex but still simple enough to understand. The Maze Generator, from Compute! December 1981 by Charles Bond has been a favorite of mine since it came out. In the filing cabinet of my mind, I even remember it as the “Page 54 Maze”.

Have you ever sat down at your old Olympia typewriter and felt compelled to write poetry in which each word is the same length as successive digits of Pi?

Me too!!!

This is called a Pilish:

The idea of writing a sentence (or longer piece of poetry or prose) in which the lengths of successive words represent the digits of the number π (=3.14159265358979…) has been around since the early 1900’s. - Writing in Pilish

I’ve participated in National Novel Writing Month for the last two years. While I don’t have aspirations of being a fiction author, I think there is a ton of value in writing 1500 words daily. Good writing or bad, 45000 words in a month is worth the effort.

In 2021, I used a DOS 386 with Wordperfect 6.22 to complete the writing for the month and produced a pretty terrible Techno/Wilderness thriller that no one should be subjected to reading. Using a 386 Laptop was a fantastic experience, and WordPerfect for DOS remains one of the best distraction-free word processors ever created.

I built the world’s worst paper tape reader some weeks ago. It works pretty okay on anything with a USR-style port like a KIM-1 clone or a VIC-20.

It at least attempts to live up to the world’s worst name. Paper tape was (and is) an interesting medium. Sure it’s hard to work with and fragile, but it also has the advantage of being slow. I mean, what’s not to like??!!!

Dealing with large numbers in computing has been an attractive problem area for a long time. Using an average calculator might lead you to believe that it’s too tricky for most applications.

But it’s not that difficult. And to prove it, we’re going to implement this calculation on machines with 8 Bit registers (I mean, cmon, on this site, you can’t even pretend to be shocked).

There’s a wonderful yearly online event called Advent Of Code (#adventofcode). Each day there are two code challenges that follow a holiday narrative. Some of them are easy, and some of them are quite difficult.

This year I’ve attempted to do as much of it as I can on 8-Bit Machines. Mostly Commodore 64 because it’s what I know the best, and also what I like most to actually code on.

I’m a Commodore guy through and through. This isn’t tribalism, it’s what was in my room from 1983 to when I graduated High School in 1993.

After my sorta failed attempt at spending the month of September with my Coco 2, I decided for October to try spending a week at a time with a particularly less familiar computer.

So starting on October 1st, and ending on the 7th, I spent my free time with the Atari Systems that I have.

One of my main goals in sharing retro computing is to help people DO things with these machines. They are useful for all sorts of reasons, not the least of which is education and demonstration. The constraints are wonderful for this.

Using 30-50 year old hardware comes at a price. They are, well… old.

They require constant care and maintenance and parts are becoming more and more scarce.

Enter the retro pinout project

In fixing or maintaining these old computers, one of the best resources you can have is a similar working model next to it. Being able to test things out on a working example is invaluable.

An “almost teenager”, Josh, sent me an email yesterday asking how I do slow text on the Commodore. He is just starting assembly at 12 which is pretty impressive. He’s been using KickAssembler, but wants to try it “on hardware”.

It’s not difficult really. There are probably a lot of ways to do this, here’s how I do it in Turbo Macro Pro.

Let’s start with some text: ARE YOU KEEPING UP?

Some time in the month of September 2020 I dug out the old Commodore 64 that my Dad bought for himself in 1983. It quickly migrated its way into my room and stayed there until 1993 when I joined the Navy. Someone in my family, probably Mom, carefully packed it back into its original box and put it into storage. Despite its many years of use/ abuse by a messy teenager, it’s in surprisingly good condition, 38 years later. (You’re old.) Back then, I had attempted some programming on it, but I had the patience and focus of your typical suburban kid. Over the years I’ve thought about the many hours I spent on that machine (remember when computers lasted more than a single year?) and as a seasoned developer I began looking at the computer and seeing more potential than I was able to realize as a kid. Modern software is very powerful. Unfortunately, if you program with it long enough, it stops feeling “real.” It’s like learning to fly on Microsoft Flight Simulator, versus taking private pilot lessons to actually control and fly a real aircraft. My experience with flying actual planes prepared me to recognize the distinction that afternoon in September when I pulled out my old machine. I had the idea that if I could get closer to the bites, I could become a better programmer. And if that didn’t work, I could at least have fun with it. (nostalgia is a hell of a drug.)

People are funny on the internet. We always seem to divide into tribes even when it’s not necessary or advantageous to do so.

I wasn’t surprised to see someone (there’s always one isn’t there?) comment that I might be using real hardware, but for only part of my retro setups.

“I’m disappointed that you’re using an LCD monitor on your retro computers”

You’re… disappointed? Kinda dramatic isn’t it?

Do I get more pleasure out of doing retro on real hardware rather than emulators? I do. Do I think less of someone who only uses emulators? Absolutely not, it would be silly to. Besides, emulators like VICE are incredible feats. They work REALLY REALLY well and represent many thousands of hours of hard work over decades. I’m in awe of these kinds of projects, not ashamed of them.

It was just a few months ago that I started to get back into 8-Bit computing. It started with Ben Eater’s Breadboard 6502 build. Something about his complete exploration of that build including single stepping the clock and watching the processor registers was really compelling to me.

I built Ben’s project by following along with the videos. It’s currently inside a shadowbox in my office wall blinking away :-)