As you are probably aware, I’m something of a retro
fan and also easily distracted. Consequently I’m in the
process of working out how to use a Commodore 64 to
type documents and avoid distraction before
transferring them to a memory stick and posting them
on the web. Hence whereas this idea
may appear to be
decades out of date, it is in fact very much a current
issue for me.
One of the odd things about late-’70s and early-’80s
home micros was the huge mismatch between their
video and cassette interface bandwidths. For instance,
the ZX81 averaged about 250 baud on the cassette side
but was able to fling six kilobytes of pixels (albeit
character-mapped) at a TV screen twenty-five times a
second. Although this might at first suggest the use of
VHS cassettes to store data, this doesn’t work because
VHS cassettes have rubbish bandwidth. Even so, this
means that the cheapest computer ever made was able
to achieve a bandwidth comparable to broadband back
in 1981. Of course it’s not much use nowadays and
unclear how this could’ve been exploited. I still
steadfastly maintain, however, that this is an absurdly
uneven asymmetry present in all first generation home
computers.
I am currently confronted with the difficulty of getting
a Commodore 64 to communicate with laptops, tablets
and the like without further financial outlay. However,
there does seem to be a straightforward way round
this: use a QR-code style system.
Write a program which displays 2x2 pixel characters on
a 40x25 text screen with appropriate simple
compression algorithms. This is, due to caution, way
below the maximum limit on bandwidth. Proceed to
take screenshots with an ordinary digital camera,
perhaps part of another device. This would enable a
minimum of 750 bytes per screen to be transmitted,
allowing an uncompressed 64K address space to be
transmitted in eighty-seven frames. In fact rather less
than this would need to be transmitted since the video
RAM, firmware and whatever space is taken up by the
software in RAM are all out of action. I’m primarily
talking about text as well, which can fairly easily be
compressed.
At this point you might imagine I’m going to suggest
taking a video and allowing the whole 64K to come
across in less than two seconds. I’m not, because this
is about a quick and dirty solution to the problem.
However, I am going to suggest borrowing an idea from
video compression and only recording the pixels which
change. The idea is that you do something like press
the spacebar to change the screen and take another
photo.
This could also, in fact, even have been done back in
the day with an instamatic camera, but the problem is
that without a scanner or some other optical device it
would’ve been difficult to get the information back
into the computer. There are various ways round this
though, such as printing the photo using magnetic ink,
and in fact even the camera could’ve been bypassed by
just outputting the data on a thermal printer or
something.