Back to the basics with basic

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

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.

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

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.

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.

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.

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.

I’m working on the next in the Cipher series and want to start drawing graphs on a Commodore to show letter freqency analysis. I needed a way to lay out screens by hand to determine how I was going to fit a lot of data on a limited screen. Many books in the 70s and 80s containted templates for this, but I figured we could just make our own.

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.

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

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.

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?

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.

Can we get a little more speed from a 6502 than we did last week? Almost certainly.

The amazing Gregorio Naçu posted the article title graphic this week to bring attention to the venerable 6502 processor and poke fun at Apple’s M2 chip marketing slides. He’s doing probably the most ambitious single-person Commodore 64 project I know of and has a fantastic blog.

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.

I stumbled across a ZX Spectrum version of the 100 Door problem that got me thinking. Wouldn’t it be nice to have PRINT AT in Commodore BASIC?

Quite a while ago, I started playing with random numbers on 8 Bit machines. I don’t think anyone is doing “serious” work on these machines, but playing with Ciphers and Crypto got me at least curious about how a Commodore 64 generates random numbers.

Someone asked me yesterday how to very simply split the Commodore 64 screen to display two solid colors.

Someone asked me this week if I would help him with a graph theory problem on 8-Bit machines. The first task was to get all permutations of 1 to 9. Since the total permutations is 9! (362,880) I knew this would take a while.

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.

I LOVED Ayliean MacDonald’s Tower of Hanoi video on Numberphile this week. I wanted to try it with some “soothing” sounds from the 80s with the SID from a Commodore 64

I’ve been obsessed with the Random number generator on the Commodore computers for a LONG time, and I’m not the only one who is, to be sure.

Back in March, we did a simple set of programs to brute force calculate Pi using a simple and well-known series. It works, even if it’s inefficient.

What’s the 100 door problem?

It’s a just for fun problem in “beginning” math and computer courses. The idea is simple:

The Commodore 64 and PET are fairly similar systems. Other than a few memory location differences, many BASIC programs written for the Commodore 64 that don’t use graphics can run on a PET.

We’re on ANOTHER random number generation technique today. Let’s work on the Lagged Fibonacci Sequence, a fun way to use the Fibonacci Sequence on itself to generate pseudo-random numbers.

One of my favorite videos on the whole internet lately is this hidden gem by Robin. In it, he executes a programming challenge he found on Twitter to draw a pattern without using IF statements.

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.

I posted this on Twitter a few weeks ago, but a young lady has been exploring programming in Python and also with Commodore BASIC which is pretty neato. She’s 11 and asked if there was a way to do modulo functions on Commodore BASIC because she’s using her Dad’s VIC-20 and Simon’s BASIC is obviously not available for the VIC-20.

Cryptonomicon Pontifex/Solitaire

We’re back to my favorite book for another round. We’ve done quite a bit with Cryptonomicon so far. One of my favorite moments is when Enoch Root introduces a cipher that two prisoners used to communicate using just a humble playing card deck.

A while ago, I explained in detail how to generate one time pad sheets and use them to encrypt and decrypt messages.

Hashes

We did an implementation of a once popular hashing function in Part 8 on RC4 without really going into why.

Recap

So far we’ve

• Reversed a string
• Shifted bits left and right (mostly right)
• Brute forced a known simple cipher
• Channeled our inner John Connor by cracking ATM machines
• Searched through a large number looking for matches
• Learned how to use XOR to recover data
• Created a Linear Feedback Shift Register to generate better random numbers
• Implemented a “real” but outdated cipher: RC4

Disclaimer: I’m sure I’ll get an angry email from a mathematician about this, but we’re going for understanding here. No one expects to be looking for large primes on a Commodore 64. Calm down.

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”.

Concept Cyberdeck

I’m fortunate to have a number of vintage computers I’ve collected over the years. Some were fun finds, others donated. One I’ve had since 1983 (we think) and it’s one of my most prized possessions.

Recap

So far in this 8 part series on doing weird things with Ciphers on old computers we’ve:

I have several items from DIY Chris that we’ll review over the next week including a GAL PLA and flash-able ROM drop in that can hold kernal, character or BASIC ROMs.

So far in this 7 part (shocked I’ve made it through 7!) series on doing weird things with Ciphers on old computers we’ve:

Review

So far we’ve:

• Reversed a string
• Shifted bits left and right (mostly right)
• Brute forced a known simple cipher
• Faked it, but then looking for a 4 digit known pin
• Searched through a large number looking for matches

We now have most of the basic skills in Assembly to start doing some real work. Let’s tackle what is arguably the most important of the bitwise operators for ciphers and encryption: The exclusive OR. (XOR/EOR)

If you REALLY want to get into the weeds on how I figured out the Easter Egg(s) inside the Easter Egg on a 35 Year old album on a 35 year old computer then you’re in luck! This video is for you!

A common task in our code is to determine the length of something. In this example, let’s check the length of a string like “are you keeping up?”

Just the BASICs, please

Our friend in retro @NoelsRetroLab has a simple BASIC benchmarking tool that’s fun to use to compare different basic systems execution speed.

Many of you know that you can use a “Jiffy” on a Commodore as a measure of time. Sorta.

Let’s recap a little

So far we’ve:

• Reversed a string
• Shifted bits left and right (mostly right)
• Brute forced a known simple cipher
• Faked it, but then looking for a 4 digit known pin

What we need next in our toolbox is to be able to search through a large number of values to look for something. This will build on the previous skills and also reinforce working with tables and 24 bit math on an 8Bit Processor.

It’s Pi day tomorrow, and you know what that means!

There are many hacks you can do in Assembly language on the Commodore.

Ahh, the quest for a better Vintage computer picture never ends. I’m having fun with it anyway.

A few minutes into Terminator 2, the young John Connor takes his Atari Portfolio out of his bag and inserts a foil covered card into an ATM machine and proceeds to crack a pin number and steal some cash from an unsuspecting account.

Well here we are at part three and it’s a lot to pack into one page.

In Part 1 we did a simple reverse of a string. While simple, these software steps will help build the skills we need going forward in Assembly without feeling like I skipped right to a 300 line after doing a short one. One foot in front of the other and all that.

The output on my newest Commodore 64 (1989) is pretty marginal. The colors are okay(ish) but the text lines are clearly bleeding and the picture is very muddy. Most vintage computers don’t do red text on blue very well, but this one is particularly painful.

Sometime during my weeklong exploration of SHA-256 on a Commodore realized that there was a whole world of exploration that could be explored. Just because a Computer system is old, doesn’t mean it’s not interesting or useful.

Last week, at this bat-time on this bat-channel, I talked about checking off one of my 35 year old bucket list items by learning Commodore assembly language. (shut up, you’re old too.) Coincidentally, I picked this up at the time I was re-reading Cryptonomicon by Neal Stephenson for the ump-teenth time. There are a few books that I consider so good that they’re worth re-visiting, and this is one of them.

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.)

I’m blown away by some modern games still being developed for the Commodore line of computers.

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

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.