Hacker News Reader

Comment by fractallyte | Hacker News Reader

Way back in 1985, a seminal 'Computer Recreations' column in Scientific American featured the Mandelbrot set: https://www.scientificamerican.com/media/inline/blog/File/De...

(A K Dewdney's columns were always fantastic - a whole new world of wonder for early 'home computer' users!)

After careful study, my brother coded it in assembly on a C64. We both had the idea to double the display resolution (from 320x200 to 640x400) by 'extending' the screen into RAM. After leaving the computer running overnight (often longer), we eagerly came the next day to check progress, and dump the output to a dot matrix printer. We couldn't use color or even grayscale, so black and white stripes were the only option to reveal the glories of the Mandelbrot set.

Result: stunning, finely detailed, black and white images! I still have the printouts...

View on HN

I learned about the set in '87 or '88 and wrote a BASIC program to calculate it on my Apple IIe using the "obvious" algorithm.

I left my computer on overnight (I had no idea if it would overheat). However, even after a day, it hadn't even got to the interesting parts of the set- it was still off in the big bands of constant color around the set.

When I got to college I had a PC (a 286 with no floating point hardware) so I ran FRACTINT. It was great, fast, and fun. Eventually PCs got hardware floating point but by that time, few people were really exploring fractals.

Yup: 36 hours on a BBC B+ micro for monochrome mandelbrot. I used to leave it running over the weekend, and tried zooming into various parts of the set over some weeks. I used to photograph the monitor, and I'm now searching for the negatives...

"(Up until 1971, British currency was expressed in pounds, shillings, and pence, with 12 pence in a shilling and 20 shillings in a pound. This makes even addition complicated, as tourists often discovered.)"

Just after I had learned to add and subtract pounds shillings and pence, they went decimal! Ha!

I wrote something similar in Apple ][+ Basic. It had a cool optimization: it would scan 16 points around the boundary of each 64x64 pixel block, and if they were all-black (in the set) or all-white, it would assume the rest of the block was the same and finish quickly. My dot-matrix printer had something like 2000 pixels of width and limited-only-by-patience height, so the printouts were amazingly detailed.

I wish I'd had similarly inclined peers at the time. We could have totally geeked out. But I was the only one I knew.

Edit: the wording "assumed" led me to interpret that you didn't know about this mathematical property, but perhaps you did!

You almost hit upon a real property of the set, namely that if you can find a closed contour of the interior, all the enclosed points are in the set...

A common variant of your approach, then, was to quad tree the area of interest and evaluate the boundary of each square, if it was consistent you just fill in the block, otherwise subdivide. This is a massive speed up for locations like the canonical initial view with large areas of the set shown...

... Of course the problem with this is you are sampling discretely, so inferring that the boundary is closed because a sampling of it is doesn't really work. Your filling in of the white blocks like this is particularly problematic, as that can easily cut off "children" in the set.

You can do this sort of approach properly, but it is a bit more complicated.

I haven't been active here, but have an account so I thought I'd chime in (being "the brother"!)...

That was great fun back then and I was (and still am) a total geek. I called the various programs "routines" back then, as they were commonly known.

There was a "plot routine" which would plot points in monochrome or colour, either on screen or on the virtual screen (i.e. the 32Kb of memory that included and went "past" the screen in RAM). The plot routine used fixed point math, which I coded in a separate portion, so was as precise as I wanted it to be. I forgot what that precision was now, but it was something like 4 or 8 bytes.

Then there was the "print routine" which took that memory and output it to the printer.

Finally, the main Mandelbrot/Julia routines were done using a direct translation of the A K Dewdney articles.

All the assembler code was written in a notebook and debugged by hand before even entering it, which was done in the Zeus Assembler. Would be cool if we could locate the notebooks. At least we have the 6510 source code.

I loved AK Dewdney's columns. The Core War [1] columns influenced me profoundly.

Would love to see the mandelbrot printout scans :)

[1] http://www.koth.org/info/akdewdney/

OK, just off the scanner: http://imgur.com/gallery/8z7zP

Generated with a Commodore 64, output on an Epson RX80 dot matrix printer, circa 1986. All coding credit to my genius brother!

Absolutely marvelous.

Do you and your genius brother still write code?

Thanks for posting this fractallyte! We're separated by an ocean, so I'm glad I can see this digitised.

To answer you dang (first, I don't consider myself that), I work as a consultant currently writing C#/.NET code for a large corporation. But hopefully one of my side projects (using various other technology stacks) will pan out one day, and I'll be able to escape, like many of us here dream about (and many have already achieved) :)

I hope you do and also that you continue to participate on Hacker News. Between kens outdoing himself with the wonderful OP, and all the other historical contributions here, this has my vote for the best HN thread in quite a while.

Gorgeous! :)

If you liked his columns check out 'The Planiverse'.

Pix or it didn't happen.

Sorry, what I mean to say is: if you happen to have those printouts somewhere convenient, I would love to see what a 1980s assembly language generated, dot matrix printed Mandelbrot set looks like.

See my post above! ;-)

That's wonderful. Those look a lot better than I imagined from how you described it. It must have been exciting to pull that out of the printer.

I recall writing a mandelbrot program on my Casio (in the awful Casio basic) in the late 90s, after reading Ivar Peterson's "The Mathematical Tourist" (actually started with Sierpinski Gasket variations, as that is much easier, not to mention faster). I was wondering how he managed to do it in 12 minutes on such an old machine -- until I realized he only checked 24 iterations. I believe I started at a 100... and it took ~6 hours to run (more than the time from lunch until I got home, anyway...).

Reply on news.ycombinator.com