▲ 132 points
back
56 comments
Scoopex has a video series of Amiga demo programming starting all the way from the basics of using an assembler: https://www.youtube.com/watch?v=p83QUZ1-P10
I would have killed for this back when I had an A500. It seemed like dark magic and all I could find was a book on ASM game programming tricks, which was too advanced for me.
I can't remember where I found the documentation for it, but I was able to do some pretty bad-ass stuff with a 68K assembler and an Amiga 1000. IIRC, there was a pointer at a well-known memory location that was the head of a linked list of all the OS libraries, so it was really easy to bootstrap to the point where you could set the screen mode and allocate some buffers for video memory, then you just drew on them like a canvas. The location of video memory was based on a not-quite-turing-complete "script" that the copper(?) chip read -- e.g. when a guru meditation error was showing at the top of the screen, the copper chip script was saying "start reading at 0x2222222 and when the raster gets to row 60 start reading at 0x4444444...". You could do freaky stuff with that script, like draw "pixels" of any of the 4096 possible colors, that would end up being about 8 real pixels wide by one high, which begat raster bars and blocky scrolling text. Ah, but nowadays you can't touch the bare metal, and there's nary an API that does anything but crash when you try to use it in an unintended way.
Yes, AbsExecBase, at 0x00000004 was the pointer to the exec library, from which you could get at anything on the Amiga. I still marvel at how everything was a linked list - quite a beautiful OS in some regards (if it wasn't for the lack of memory protection :(
Expanding on this a bit.
Everything was relative on the Amiga. The only thing absolute was AbsExecBase at 0x4. You get a pointer to this library and then, from there, you can locate more libraries by calling FindLibrary() (or something like that).
AbsExecBase is the ultimate proof of the old adage "Any problem in computer science can be solved with an additional layer of indirection".
exec.library is a great design. The way programs know nothing except for AbsExecBase, and it points to a table of function pointers of which you have the offsets of.
In a sense it was a Component Object Model(COM) like the one in Windows. You call exec->OpenLibrary("name of lib", version_of_lib) and it returns a pointer to a table of function pointers of which you know the offsets of. It could even handle multiple versions of a library in principle. In reality makers of libraries just made sure the function table was the same, and added new stuff at the end.
You have to call CloseLibrary(libptr) to release the instance. Pretty similar to Objective-C's and COM's release().
OpenLibrary was allowed to return a different pointer for each call, but the early exec.library did not do this AFAIK.
Great design really. And how signals and message system works is just beautiful as well. I really get why Matt Dillon(of FreeBSD and DragonflyBSD) wanted something similar in the BSD kernel.
I still have the Amiga Kernel Reference Manual for exec in my shelf.
"... except for the problem of too many layers of indirection."
Actually, I learned 68000 assembly by hex-dumping a freeware assembler to find the full set of OpCodes and some reverse engineering. That, combined with some trial and error (and a few magazine articles that actually had a little bit of ASM {} C), and I was able to do some very cool stuff pretty quickly).
Boy, I miss those days :(
You aren't the only one. I always wonder what we could do today to synthesize new environments which capture some of that feeling and will actually be interesting to people who aren't just suffering a fit of nostalgia.
For me, the Raspberry Pi comes close. It's a limited machine, the specs are the same for everyone with your model and there's plenty of scope to make it do impossible things if you apply yourself.
Is the hardware of the Raspberry Pi really fully documented? The GPU too? How about WIFI chips?
I've tried several times to make a tiny kernel for x86, but always feel it's either too old interfaces like the PIC, TIMER, VGA, IDE etc, or chip specific. I can't give my friend a bootable USB because he/she might have a different hardware setup.
Everything that's needed to make an OS is documented, either directly or (like USB) in the Linux kernel's source code. Even the GPU is much easier to support than on a PC because the OpenGL ES driver is running on the GPU itself. You just talk to it through a mailbox interface.
No, there are plenty of closed components with only binary blobs and header files for the programmer. But bare metal coding on it is still very doable and popular.
Well, I couldn't find anything. Zero.
Plus using BBSs implied buying a modem and paying for long distance phone calls. Both completely out of my parents' budget.
In a sense, Amiga demos were actually open source. Coders wrote in assembly, which is a short step from machine code. As most demos were compressed, it required an additional step to get to the actual machine code before you could disassemble. Alternatively using a cartridge like Datel's Action Replay makes it possible to dump the relevant routines to disk. Granted that reading disassembled code is a little more difficult than the original code, it is enough to learn how various demo routines were implemented.
Ever since the term "open source" was coined in 1998, it has had a precise definition[1], and according to that definition, most (all?) Amiga demos are not open source.
It should have been clear I was referring to the spirit of sharing in the Amiga demo scene itself.
It was no secret people were looking at each other's code. Reviewing the code was a way to learn about how to implement demo routines. But it was also a practical way to learn about programming the machine itself. Things you will not find in any manual.
I was not making a claim about licensing. Perhaps you are not familiar with the notion of a metaphor.
I understand your point but I think that would be stretching the definition of open source, which to me means that the text files used to write the program are available for anyone who want them.
Just shipping a binary that happens to be very close to the language used to write that program wouldn't qualify as open source (and it would still be missing a lot of useful information, such as loop labels, memory location names, etc...).
The fact is there was little distribution of assembly source in the Amiga demo scene. So there is no way this can be called "open source" by the standards we recognize today.
But the demo scene was anti-commercial in nature. The creators gave their demos away in good will. Nobody cared if their work was reused unless it was a blatant rip-off or was used for commercial gain. And disassembly was standard operating procedure to hack on the source code.
So there was some sort of ethos at work, which seemed to arise naturally and spontaneously. And it reminds me of the open source spirit.
> it would still be missing a lot of useful information, such as loop labels, memory location names, etc...
I agree the disassembled code would be missing these things. But they are only conveniences for an assembly programmer.
There is almost 1:1 correspondence between assembly code and machine code, which makes the task a lot easier than disassembling optimized C code for example.
And on a practical level, the lack of labels and names doesn't stop you doing what you want with the code.
For example the IDE used in the Scoopex tutorial above is ASM-One by TFA. But TFA are not the original author. ASM-One was a commercial product. And TFA added some very useful extensions despite not having the source code!
I have used quite a few Amiga music trackers over the years. But they all descended from the disassembled code of Karsten Obarski's abandoned Ultimate Soundtracker [1]. The lack of assembly code was never a practical problem.
Oddly it makes me sad, one because I remember it fondly (the BADGE group some of the early demo contests) and it was fun to code them up, but today its not nearly so fun even though you can make things look so much better. Writing code for the Amiga was so much more fun than writing code for the PC. I'd love to figure out how to create such a fun environment again.
I'm nostalgic for those days, I learned assembler and made simple demos and games which lead to a career in video games. But I'm not sad. Look at the current generation. They have game development tools like Unity and Unreal Engine, cheap fun hobby computers like the Raspberry Pi and perhaps most importantly they have the internet; youtube, twitch, forums, chat programs. When I learned to write assembler I had magazines and a book and I was on my own. Nobody else I knew was programming.
Yeah, me too. For me it was the best community ever. They were pro sharing, pro openness but not anti commercial at the same time. Creativity and sharing was high. And the machine itself was way ahead of its time. I really miss it.
I have never played with an Amiga so I am curious as to what made it so fun to write code for?
Consider that when the Amiga arrived most PCs had monochrome text only displays, and the PC speaker was the only sound option. In 1987 VGA arrived and you would start to get the opportunity to compete with still images, but it still took a while before most PCs would use more than 16 colours. And prior to the Soundblaster in 1989, most PC users still had no proper sound. And until 1995 most PC users had not used a pre-emptively multitasking OS.
Meanwhile the Amiga shipped with a fully multitasking windowed OS, 4096 colours, higher resolutions (until VGA), the copper (a coprocessor that let you update things like the palette and video registers synced to the raster beam, e.g. to let you combine multiple graphics modes on the same screen, or duplicate hardware sprites multiple times on the screen without involving the CPU), the blitter (letting you move areas of memory; geared towards moving graphical objects while the CPU did other things), 4 voices of sampled music, and a CPU (M68000) that was simply far more pleasant to program for.
For most of us who saw Amigas in the early days, the PC looked like a dinosaur.
The Amiga was ridiculously ahead of its time until 1995, when Windows 95 came out and pretty much crushed everything else.
That year is when I realized it was time to sell my Amiga and buy a PC because the future had just jumped to a different hardware architecture.
To me, booting Windows 95 was as jaw dropping as seeing the ray traced juggler demo and Marble Madness on an Amiga 1000 Kickstart 1.0 in 1986.
Windows 95 was pretty uninteresting to me. The only thing it had over the Amiga was memory isolation, which wasn't seen as a big deal by most Amiga users at the time. In most other respects AmigaOS still beat the pants of Windows95, with things like Datatypes, deep Arexx integration in most applications etc. There are parts of AmigaOS I still miss.
What killed the Amiga apart from the Commodore bankruptcy was hardware costs and lack of viable 3D support on the low end far more than Windows 95.
Yea, the Commodore bankruptcy predates Win95 I think.
Ultimately the Amiga painted itself into a corner; so finely tuned for 2D that it couldn't easily just slot in a 3D card like a PC could.
I still have mine, suped up with a 68010, that'll get you 5% in a tight loop.
I wonder where the Amiga would have been today if those chips had been sitting on one or more easily swappable boards like what most of the PC did.
What seemed to sink the Amiga in the long run was that to go from OCS to ECS or AGA you basically had to buy a new computer.
But a PC could go from EGA to VGA by swapping out a card.
Never mind that the first 3D accelerators were pass through concoctions, where the VGA card had a short cable run over to the 3D card that in turn was connected to the screen.
And if you weren't impressed by Windows, by that time Linux was quite good on the PC if you built it with Linux in mind. And you could still dual boot to DOS games.
Linux was horrendous on PCs in 1995. First of all, OP is talking about hardware support: switching OSs doesn't give you a copper, or a soundcard with four voice wavetable synthesis.
Linux was slightly convenient on PC in 1995 if you really cared about: (1) a basically Unix-y userland, with all the good and bad that implies. Shells and stuff worked better than cygwin (2) tcp stack (3) gcc
That's really it. X was a fucking nightmare to get to work "correctly" and then, as now, "correctly" on X means "it handles a remote networking case no one cares about better than the alternatives but still poorly, and everything else about it is totally broken."
Hardware support for every feature that was becoming interesting in PCs in 1995 (basically anything where economies of scale were making interesting stuff cheap) was absolutely terrible on Linux. Drivers for PC hardware, even the kind of PC hardware nerds liked (SCSI CD-ROM drives) were super flaky or non-existent. Application software was horrendous. There was no support at all for anything that still had a licensing regime around codecs, which, at the time included all the media software.
Linux was "quite good" in that you could set it up in a corner of your house and run httpd. That was dope in 1995. But compared to Amiga as a user-facing hacking desktop, it sucked shit. Hell, it sucked shit compared to a PC running Windows or a Mac.
Seriously, find a 486SX/25 w/ 4MB ram, a 160MB disk, a decent modem, and an S3 video card and put like, Yggdrasil on it. It will be way less fun to fuck around w/ than an old Amiga/Mac/NeXT/BeBox/SGI....at least in 1995 an Intel machine running DOS could run DOOM. It's probably the least-fun hardware/os combo from 1995 you could dredge up to play with.
I've owned one, though i never programmed for it. But from what i know, i guess the answer is that the amiga is very close to a modern computer, in that it has specialized chips for graphics and sound (Denise and Paula), making many tasks quite easy, but is still weak enough to force most programs to be relatively simple.
At the same time there's also still a very active competitive amiga programming community², making things like these:
https://www.youtube.com/watch?v=GE7vbzMYYRc -- https://www.youtube.com/watch?v=EpK3Kp7-0zU -- https://www.youtube.com/watch?v=RPdB_zdyMbM -- https://www.youtube.com/watch?v=7cOjC-nhs_o -- https://www.youtube.com/watch?v=jziQBWQxvok
² http://www.pouet.net/prodlist.php?platform%5B0%5D=Amiga+AGA&...
There was a very thin layer between writing code and having something on the screen. The original 3Dfx voodoo libraries had a similar feel. You could write 30 - 40 lines of code and poof, something neat would be on the screen. In contrast at PCs picked up more interesting graphics they also got DirectX which always felt like you needed 500 lines to do what you could do on other platforms in a tenth of that, and CaMeLCaSe drove me NUTS at first. As a result I spent more time trying to figure out how to say what I wanted in DirectX3 than actually thinking about the code that actually drew interesting things into the frame buffer. The Amiga it was just a call to open screen with some allocated "chip" ram for the frame buffer and you were off to the races.
You might want to try coding your entire demo in shaders, it gives you a similar feel, and you can skip all the gl/d3d mess.
For examples, shadertoy.com is full of cool shader-only effects and entire demos.
Absolutely amazing book on the tech and history behind the Amiga http://www.amazon.com/The-Future-Was-Here-Commodore/dp/02620...
For one thing, it was very easy. As there were no protection mechanism in the 68000, you had direct access to all the hardware in your programs (basically, your programs ran in kernel mode). So you could bypass all the OS layer and program your coprocessors and graphical cards. With enough perseverance, a little documentation (that we found here and there) and a logical mind, it was very easy to produce cool things, even for a kid.
Something modern on Amiga:
https://www.youtube.com/watch?v=XsJnMWX1qa0
There is a Bad Apple on an oscilloscope and a TI calculator so obviously there would be an Amiga version. Not as impressive as the Commodore C64 version which is an insane feat of compression: http://csdb.dk/release/?id=131628 (reminds me of the famous state of the art amiga demo).
Briefly Bad Apple was a sport akin to porting Doom to the most unexpected platform you could think of.
Like the Amiga! http://aminet.net/package/game/shoot/ADoom-1.3
That shadow demo is all pre rendered though right? Like stats of the art?
The file extension was .anim, It's probably a standard IFF ANIM file. It's a format that contains RLE encoded diff-XOR-data(so you can play the video backwards).
C64 version of Bad Apple. https://www.youtube.com/watch?v=fu7rRYkWsyk
There are still a number of groups making amazing Amiga demos for the original hardware. For example, this is Rift by The Black Lotus (2014): https://www.youtube.com/watch?v=DXDlWHqzSTg
It's strange but when I see a video of the Amiga demoscene I feel nostalgia for a time I didn't experience (I started with a 286).
It was this kind of demo-scene programming in which DHH was utterly uninterested in.
"I had a bunch of friends who I loved dearly, but in many ways were exhibiting all the traditional programmer stereotype themes of being just overly focused on things I didn't think mattered and at that time programming perhaps also was a little bit different. Growing up, programming was assembler and C. I had a lot of friends in what was called the ‘demo scene’, which is mostly an European thing where you had all these guys on the Commodore 64 and on the Amiga writing these really awesome visual displays of various kinds, and all that stuff was usually in assembler. I had absolutely zero interest in learning or doing anything with assembler, it just didn't make any sense to me at all.
I only really got interested in programming when I stumbled across languages that made sense to me on the level that makes sense to me, which is at the very least high level languages like Java, PHP, or whatever have you, anything that's above the “I have to dick around with pointers” or I actually have to move memory spaces around; that stuff has absolutely zero interest to me at all.
I didn't start programming until I was in my late twenties, and even then I didn't start programming because I wanted to be a programmer. I started programming because I wanted a few programs. And that was apparently the easiest way to get there because the other way of getting programs is that you actually have to talk to programmers, which is surprisingly painful at times. I found that the easiest way was just to pick it up and learn it myself."
Source: http://www.transcribed-interview.com/dhh-rails-david-heineme...
Thanks for the DHH quote. When I first watched the vid, I couldn't figure out what was going on and what the purpose was. The DHH quote was perfectly timed because it explained the context of these types of demonstrations: to make cool looking stuff for its own sake, rather than writing super practical programs.
I first got into programming in high school when I took AP Computer Science. To be honest, I hated it and didn't pick up web development until several years after that experience. I thought programming sucked. I literally said multiple times, "I will never program. This is the worst!" I think there were two reasons for this: the programs I was writing were impractical combined with pressure to perform well in the class. It's tough teaching a beginning programming class because most start at the CLI. Although the CLI is great at helping students learn the basics of programming (e.g., loops, conditionals, OOP, etc.), it still left me wanting more. Back then, I was still at a loss as to how someone would write a GUI program, similar to the programs I used all of the time on a computer, not the CLI "junk" I was writing for class.
Nonetheless, I picked up web development on my own time and the experience has been incredible. I even developed a preference for the CLI in the practical productivity CLI tools afford a web developer (e.g., git, touch, mkdir, ssh, psql, etc.) And I must admit that basic programming skills that I learned in AP Comp Sci gave me a leg up in getting started, thereby making the path to writing practical stuff for the web a lot shorter.
I guess it's kind of vain for me to share my personal story here, but I bet others had a similar experience. If you took an intro programming class in HS or University and you hated it, give programming another shot. This time, you won't have to worry about a grade or writing shitty programs you don't care about. Start a project, get coding, and I think you'll fall in love.
This kind of comment frustrates me. Not the original DHH comment, but the above one. So because DHH didn't like it, we're also obligated to? God forbid people enjoy things! It's a sad cultural meme to go to any post and see the top comment be something that tears down the content.
Putting that aside, I think the DHH comment isn't the full story on demoscene. Demoscene people were interested in those languages because that's where you perhaps could do the most interesting things at the time. Some people still cling to that, and some don't. For example Farbrausch, one of the most famous demo teams, released the tool they were using themselves, called werkkzeug, which was basically a GUI way to generate cool demos that still were tiny and had procedurally generated textures and effects etc etc. Similarly, I've seen a neat demos that use modern tools, a lot use GPUs and shaders these days, but it depends what they're trying to do. Sometimes they want to squeeze all that into a tiny binary - can we have a fully running game engine in smaller size than a jpeg of my face? But a lot of times size isn't a consideration, and it's about how cool of a thing can you do!
One example that comes to mind is Agenda Circling Forth. I think it's very beautiful. I wouldn't hesitate to call it art at this point. Here is a video of it running: https://www.youtube.com/watch?v=L5w7Gh7WBjw
Some articles with more technical details: https://directtovideo.wordpress.com/2010/04/19/agenda-circli... https://directtovideo.wordpress.com/2009/10/06/a-thoroughly-...
Tens of millions of particles, and in 2010! Very impressive, and you'll notice that almost none of the discussion is about assembly and compilers and bit twiddling.
So what did all this effort accomplish? First of all, fun! I don't think anyone worried about any of this if they didn't think it was enjoyable. Second, a lot of interesting ideas were created and popularized that made their way into the roots of the computer graphics and video game industries of today. And a lot of the people came from there too. A lot of these people work at Unreal, CryTek, etc where they build the engines that power games we play today. Unfortunately I think it's hard for a small demo team today to "beat" the output of years of concerted effort and millions of research and man hours that goes into something like the Unreal Engine. So fun matters more.
I guess there's also an interest in those things because of a "back to the basics" feel. If you want to do any computer graphics today you need tools upon tools upon tools upon languages and it's all a bit too much. Some folks yearn for the days where they can write some code that looks like "top left pixel is green". A bit similar to why people had so much fun with neocities recently.
Anyway, these are my two cents on why people enjoy this. Raining on people's parade is not a nice thing and I keep seeing it happen here.
For those interested in digging deeper :)
WinUAE Demo Toolchain 5: http://www.pouet.net/prod.php?which=65625
And here you can find plenty old and new demos for all sorts of platforms: http://www.pouet.net/prodlist.php
Enjoy!
My favourite demo, blows me away even now...
If you like this, you would probably appreciate http://www.mindcandydvd.com/