My MEGA65 is finally here
lyonsden.net
lyonsden.net
I've been feeling lately that as computers have become more advanced and software has become more inscrutable, our relationship with our computers has changed, for the worse. This essay hit home for me: https://explaining.software/archive/transparent-like-frosted...
These old-school computers viewed their users as creators, as developers. Modern computers (read: smartphones) _are_ the users, and the "used" are just ad-watching revenue cows. I passionately hate this arrangement.
When I have children, I want them to know what computing should feel like---empowering, creative and stimulating, not controlled, consumptive, compulsive and mindless. I want to give them a computer that builds up their spirit, rather than grinding it down.
I think this computer should have several qualities:
0. The computer should be about _creation_ and not consumption.
1. The computer should be _local_, not global. Intranet should be prioritized over Internet.
1.5 A corollary, the computer should be _personal_. It should encourage and reward in-person interaction, physical sharing of information and programs, and short-range connection between computers.
2. The computer should be _limited_. Because the medium is the message, we have to restrict the capabilities of our media to better promote the messages we value.
2.5. A corollary, the computer should be _text-oriented_. Graphics shouldn't be impossible, but text should be primary. The computer should cultivate a typographic mind, not a graphic mind (in Marshall McLuhan's terminology).
3. The computer should be _focused_. It should never distract you from what you want to work on.
4. The computer should be _reactive_, not proactive. It should never give you a notification. You should be in charge of retrieving all information yourself, like a library, not a call center.
5. The computer should be _physical_. It should be oriented around physical media.
6. The computer should be _modifiable_. It should encourage and reward inspection into its internals, and be easy to change.
7. The computer should be _simple_, understandable by a single person in its entirety with time and study.
The Mega65 is amazing and checks these boxes, but unfortunately it's a tad expensive for me. What other machines are out there like this?
It feels like people aren't interested in being creators. Just consumers. And that shows in how media and companies refer to people as consumers.
I wish there was a way to reverse this trend. It feels in many ways like a Plato's cave kind of situation.
Such a thing doesn't seem to have been invented yet. The remarkable might come close (or that weird typewriter like thing?) but I haven't been able to justify any of those purchases yet...
I'm not 100% sure about e-paper (the lag may actually be a feature reducing addictiveness), I'm also amenable to those transflective Sharp LCDs! (Though I think they're a bit too small for a daily driver.)
I also could have done so much more with all my computers, from my Commodore 64 to my 286, if had I had the vast information resources that are available now.
So, the society that you craved connection with no longer exists now that you are able to connect. This is another thing that, seemingly, has to be rebuilt from the ground up locally.
You can still take trips down memory lane.
And that large plastic shell of the C65 was always an ugly design, and I can't imagine it's comfortable to type on with that floppy drive protrusion so close to the arrow keys?
Or if that it is too limited, go for the Amiga. It is more modifiable.
As a sidenote, I got my Mega65 just the other day. Been waiting almost a year for it :)
https://ultimate64.com/Ultimate64
Got one of these too (the now discontinued non-Elite version) and it is pretty cool running stuff at 48MHz:
https://youtube.com/shorts/fF2IXTwWDPQ?si=ww3IXp7CVWDT3SZy
In above video, I hacked the awesome demo Andropolis to utilize U64’s turbo mode during vblank.
This clip shows it running in full turbo mode:
If practical and simple were the goals, it wouldn't be using an 8-bit chip nor would it be focused on things like BASIC as these kinds of things make things harder rather than easier.
Mega65 is about working within constraints, but (to me), the bend of the complexity curve where things are simple enough to understand, but powerful enough to do necessary tasks requires much larger software and hardware resources than what a system like Mega65 offers.
At a bare minimum, I believe you'd want a much more powerful single-core machine with the ability to do floating point and vector calculations while having access to at least a couple hundred megabytes of RAM and a few gigabytes of storage. Something more along the lines of a Pi Zero, but based on open hardware and open chip designs seems to be around the point where it is powerful enough to do all the common, non-connected tasks a user might need to do while still being simple enough that you could understand most of the moving parts if you wanted to take the time.
https://www.raspberrypi.com/products/rp2350/
The documentation is pretty good. Reading it reminds me of going through the documentation provided with my Tandy Color Computer as a kid.
A 32-bit word size is the absolute minimum that I would consider “practical”. With that you can comfortably implement reasonable floating point and integer arithmetic that can solve most of the common practical problems you encounter in science, business or engineering. Still people criticised the System/360 because it was 32-bit, saying it wasn’t enough compared to the 36-bit word size computers that preceded it. Mechanical calculators generally had ten decimal digits of precision so the thinking was that digital computers needed to at least match or exceed that.
The advantage of 32-bit word size is more for interoperability with modern systems and familiarity to modern programmers and programming languages.
> Plenty of older microcomputers got by just fine with only 8 bits in a word.
They got by fine on your kid’s desk. Those processors were better suited for implementing smart terminals that people would use to interface with the computer that would actually solve your problem.
> That's enough room to fit two binary-coded decimal digits and thus perform all the common arithmetic operations one or two digits at a time.
Why perform them one digit at a time when you can perform them 10 digits at a time? Why force your users to adopt a programming model where you have to implement arbitrary precision arithmetic anytime you want to use a number larger than 255? Or have to implement a useful floating point in software? Or be forced to pull in libraries or use some environment were that stuff is pre-implemented in order to do basic operations that previously could be done in a single line in assembly?
>...albeit at speeds far below the billions of operations per second expected of modern computers.
They performed at speeds below what was expected of computers from the 50s and 60s.
> The advantage of 32-bit word size is more for interoperability with modern systems and familiarity to modern programmers and programming languages.
No it is not about modern computing or modern programmers. 32-bit or similar word sizes were the standard for electronic computing since the earliest times because there are intrinsic advantages. Nobody did 8-bit computing before micro-processors from the 70s because it would have been stupid to limit yourself that way if you didn’t need to.
Taking such a hostile tone over what is obviously already settled seems strange to me. Of course you don't design modern systems with 8-bit words. There are many advantages to larger words besides those I mentioned or implied. But calling the elements which were good enough for the second wave of the computer revolution completely impractical is also absurd to me.
Again this is not about contemporary computing or computer technology level in general, as I have already made clear. What is good or bad design for general computing is independent of those things, it is timeless. Why do you keep referring to some arbitrary “modern computing” as if that is somehow relevant when word-size in particular is a design decision that is not really dictated by technology level? It is often possible to compromise on other aspects of the design in order to have the width you want.
What you mean to say is “you don't design any general purpose system with 8-bit words.” but you won’t because it would undermine your whole argument.
> But the designers of early micros did need to limit themselves,
It would have been more difficult but not impossible to create an IC with a larger word-size in the early 70s. The 8-bit word size was not entirely chosen for technical reasons but also because they were targeting a specific market, one that did not have to meet all the demands of general computing and one for which the general computers were ill suited so this made the most sense. Would you really not say they were designed for and are better suited for the subset of computing applications that is called “embedded” computing? Don’t forget that most of them were designed before the desktop computer market existed and were never intended to be used that way. You can force them to be more than what they are (and people did) and pretend that they are but it doesn’t mean you should.
> But calling the elements which were good enough for the second wave of the computer revolution completely impractical is also absurd to me.
Design concessions which are intrinsically bad, awkward or inappropriate do not become good because it “still worked” or succeeded in a particular market. Not that it counts for much since those computers were not marketed in the same way or purchased for the same reasons. You say it was “good enough” but a lot of people didn’t think so but I guess most of them are dead now (like Wirth). The word-size was not a selling point, and only not enough of a hindrance to upset the novelty of the overall product. What it takes to introduce people to electronic computing is not the measure of general computing.
What is absurd is people like yourself insisting those particular machines, out of all machines, should be used to inform us as to what is reasonable for general computing when, considering the context of their creation, it is completely unwarranted.
We're now entering an era where, despite sophisticated hardware with wide words and layered caches and security rings and SIMD units and all this other fanciness, the end-user increasingly doesn't own their computing experience. While 8-bit and 16-bit computing may not meet your arbitrary definition of sufficiency, it still provides an avenue for people to access, understand, and control their computing. If it wasn't good enough for Wirth, so what?
What we want out of computing is constantly evolving but in most cases the new things boil down to solving the same old set of basic problems. A large portion of modern cryptography is simply arithmetic with large numbers for instance.
An 8-bit machine can be used to solve these problems but often inefficiently or awkwardly, which is not the point of automatic computing, hence the impracticality of that word size in a general purpose computer.
Since word-size mostly determines the magnitude and precision with which we may conveniently represent a quantity it is pertinent that we consider what scales we might be expected to work at. There are 13 orders of magnitude (~43 binary orders) between a pauper with a single dollar and the nominal GDP of the USA. It is therefore unlikely your adding machine will need more than that many columns. There are 61 orders of magnitude (~203 binary orders) between the diameter of the observable universe and a Planck length. Those are the opposite ends of two extremes and we could reason that common calculations would involve a more Earthly scale. We should also consider the other natural quantities but the point is that in this world we must expect to operate at scales which have been determined by economic or natural forces. A machine that doesn’t acknowledge this in its design is not practical. Continually applying one’s reason in this way we can arrive at a sensible range of scales with good generality.
These are the principles which should guide us when determining a practical word length. Like considerations have guided the design of all our calculating tools. What good would an abacus be if it had so few rods as to make common mercantile calculations more awkward? Perhaps it seems less arbitrary now.
Many aspects of the universe appear continuous so it is natural we would need to do calculations involving numbers with fractional parts (rationals are a useful abstraction for many things besides). We could use fixed-point arithmetic but we have found that floating point is generally more efficient for most applications. A general purpose computer should have a floating point unit. Even Zuse’s Versuchsmodell 1 had one in 1938. A 16-bit float is useful in some applications, but a 32-bit or higher floating point is what scientists and engineers have always asked for in their computers.
If you want to talk about market success the fact that computers across many different eras, technologies and sizes with 32/36 to 60/64 bit word sizes have existed and continue to exist despite our evolving computing needs, suggests some level of generality which a smaller word size does not provide. The short career of 8-bit words in (semi) general purpose computing counts against it more than anything. It is even being displaced in its traditional avenues.
> the end-user increasingly doesn't own their computing experience. While 8-bit and 16-bit computing may not meet your arbitrary definition of sufficiency, it still provides an avenue for people to access, understand, and control their computing.
What does this have to do with word-size? Why even bother mentioning this? You seem to endlessly conflate larger word-sizes with “modern computing” and smaller word-sizes with specific past implementations or genres of computers. Don’t bother arguing the merits of a smaller word-size by appealing to unrelated virtues or ills.
By the way Wirth was not against the idea of small computers, he just though it was being done badly so he designed his own. People have always thought that computing could be done better, this shouldn’t be a surprise to anyone here.
> If it wasn't good enough for Wirth, so what?
It means that there are people with a far better sense for what is acceptable and unacceptable in computing than you.
I struggle to get my kids to experience computers with the same sense of wonder and amazement that I had. This could be inevitable (I've always taken flipping a light switch or refrigerated food for granted) but it still makes me sad.
For myself, I fell into video game hacking (and related hijinks) because I loved a particular game, and happened to hang out with some smart people on some forums online, and that set the course of my life to a large degree. But it seems like accidentally having these experiences is harder and harder these days.
How do we set our kids up, or set the world up for our kids, to have these experiences organically?
This particular product might not be exactly what you want, but it shows that you can use these technologies to build a computer that is much simpler and more malleable than a modern PC in both hardware and software, but is still very capable, and intriguing to use.
1. https://github.com/shorepine/tulipcc 2. https://news.ycombinator.com/item?id=41122986
Very much so. Technology stopped being about empowerment some time ago - it's been subverted into a tool for erecting virtual tollbooths.
> This essay hit home for me: https://explaining.software/archive/transparent-like-frosted...
Thanks for that - I just read it. This made me grin:
> "By the mid-1990s," Turkle says, "when people said that something was transparent, they meant that they could immediately make it work, not that they knew how it worked."
... and by the late 1990s people meant they could see its PCB through the case!
I think we all know how impactful the smartphone has been, but your way of putting it is especially succinct. It's not the iphone that mattered in particular, it's the convergence of phone and computer. The telephone was one of the first pieces of "noisy" technology, i.e. it yells at you when it wants your attention. Merging that with the versatility and sheer power of the computer was... consequential, to say the least.
Possibly the joy of the golden age was in ruining computing for everybody who came after.
Your list of qualities remind me of what I liked most about the Amiga and its OS. The (desktop) system was manageable by one person and you learned as you went. It did not "mollycoddle" the user, and it did not require you to spend years of study (as with Unix, Linux and the internals of MS-Windows).
One older principle (1967) that is related to several of yours, and apparently largely forgotten these days is "The principle of least astonishment" [0].
Other lists of computing principles I've come across that I find interesting (even if I do not always agree): Loper-OS's seven laws of Sane Computing [1], and the principles of Permacomputing [2].
[0]: <https://en.wikipedia.org/wiki/Principle_of_least_astonishmen...>
Quite a few.
* Feonix 256
* Commander X16
* ZX Spectrum Next
* ZX UNO / ZX DUO et al.
* Chloe 280SE
A program most nerds (including me) used to run on every computer we came across in department stores back in the 80’s. The salesmen must have been sick to death of kids doing this all day every day – some of the messages weren’t always so polite either!
As a diehard Amiga fan, I would always stop at the Macs on display at office supply stores and switch the color setting from "thousands of colors" to grayscale. Just doing my part.
In programming class at school, we'd be taught for a bit, then go to the computers to practice what we'd learned in BASIC. When class was over, we'd write programs to loop for maybe 15 minutes, then emit an obnoxious sound to interrupt the next class. Ideally, the chosen frequency would be high enough that the teacher couldn't hear it, but the class could. Truly madlads.
(The ez80 is capable of 50MHz, I'm not entirely sure why they limited it to 20Mhz in the Agon Light).
Wikipedia says three times faster at the same clock speed. So 20*3/4=15 give or take.
As an aside, last time I did napkin math estimation on the 8-bit AVR it was faster than a 68000 at the same clock speed. The 68k took 4 clocks to do register to register, AVR is mostly one clock so could do most 32 bit operations as fast or faster using multiple instructions.
https://k8.fingswotidun.com/static/ide/?gist=78d170a65bc6c9d...
In hindsight, it's not the best for emulation, I think most of the emulator time goes into extracting the bits from instructions. I really should make a translator that turns it instruction by instruction into something easier to decode.
The ESP32 has a huge amount of potential for emulating other things, see
https://github.com/breakintoprogram/agon-vdp
For a display controller implemented for ESP32.
I find the all-in-one kind of retrocomputers more appealing than the DIY projects (knowing nothing of electronics or of sourcing parts, cases, etc, DIY is not for me).
The reason it worked so well was the cursor control characters. Just by printing a string, for example, you could draw an outline box with text in it, or a little man, or whatever, in an instant.
The speed of BASIC was still an issue. I animated a train driving across the screen, about 10 characters high, and it worked fairly well but you could see a bit of a ripple. I don't remember how exactly, but, for example, each 1-character wide "slice" of the train could be a string, then you just print your 40 "slice" strings in a row and there's your train; pick your starting offset in a larger array to draw it in different phases of motion.
A faster CPU totally solves this. Now you have a machine where non-programmers can do really cool graphic stuff and smoothly too, without ever leaving BASIC.
The next step, generally, was about reprogramming the character set. Now your BASIC, character cell based graphics could have custom pixels, not just the preformed PETSCII characters.
I once saw a cute little character based platform jumper game on someone's VIC20 and went home and implemented it, from scratch, on the C64 in an afternoon. In BASIC, with a few custom characters.
But what may be missing in this retro scene is being able to show off your creations to everyone else who has the same computer. Without that, kids may not get interested.
More can be found on her website: https://www.raquelmeyers.com/
*) Realtime meaning that she‘s typing in the images as you watch them come into existence
My DSC-30 came with a metal floppy disk that has no moving parts. But you could insert a Memory Stick into it, and then stick it in any 3.5" floppy drive and read the stick as FAT.
Every time I see someone on the VCF forums struggling with the latest floppy drive replacement board I wonder what ever happened to that technology.
A floppy emulator board which reads SD/CF cards or USB sticks doesn't have that problem at all since it's purely solid state electronics and directly connected to the electronic interface of the FDD instead of the real FDD, and usually you can put thousands of floppy disk images onto such a memory card/stick and select which disk image is to be put into the emulated floppy disk drive ⇒ there is simply no need for the "emulator disk" technology you mentioned anymore.
That's an interesting combination of words!
They are available in 8, 16, 24 and 32-bit systems with a variety of CPUs such as the 65c02, 6809, 65816, 68000, or 68040.
Main website: https://c256foenix.com/
https://shop.trenz-electronic.de/media/pdf/ca/ca/31/Mega65-P...
[1]: https://digilent.com/reference/pmod/start [2]: https://en.wikipedia.org/wiki/Pmod_Interface
Now where’d I leave those Galaksija resistors…