tieze

Would be tricky to have your 6502 code running on a Game Boy as it has a Z80/8080.

That is arguably the point. They are taken from the SF city website and are placed in arbitrary order. I personally love this unfiltered take.

There's more to get from these than just aesthetics, precisely because they're not curated.

People here might also be interested in pwndbg, which adds a lot of qol improvements to the typical gdb/lldb experience. Including splitting dialogs over tmux panes, a lot more context info added to debug lines like where do pointers point to. Heap inspection. Colorization. makes for a much more friendly debugging experience.

re Dune 1 and 2 in same year: At some point Dune 1, developed by Cyro interactive, was officially cancelled and Westwood (so a totally different studio) got a crack at developing it. But it turned out Dune 1 kept on getting secret funding as well, and wasn't cancelled when the higher ups found out. So we were kind of lucky to get both of them.

Somewhat related, there's a MiSTer implementation of the Apple II: https://github.com/MiSTer-devel/Apple-II_MiSTer

Well yea, two points:

a) thats awesome b) I am taking a wild leap in deducing you're the same retro-games Benj Edwards journalist that was part of the infamous Retronauts East team. Just wanted to say i always quite enjoyed your presence :)

Yosys, the underlying compiler of ice studio, also targets the much bigger ECP5 FPGA, also by Lattice, which is called Project Trellis: https://github.com/YosysHQ/prjtrellis

Yosys functions more like a software open source tool. So command line compiling. It also has a REPL. It is very quick compared to the commercial solutions. Especially around compile times which can take seconds instead of minutes. YMMV, but I think the consensus is that it's a lot more convenient to use.

In general the hardware toolchains feel very ancient compared to software toolchains.

The GBA is such a good little system to program for.

I'm getting a forbidden on that too. I guess it's a ephemeral link. It's on the frontpage of the site though.

Oh, thanks so much for this pointer :)

I'm just going to chime in as well. OSS tools were a breeze to set up. And the compile loop is so very quick comparatively.

Not extremely cheap, but the ULX3S fits the bill. It's got the inputs and outputs and all.

In Emacs you can set up Python in a (quite neutered) similar way. Whenever I change a function, I just evaluate the whole buffer to load it in the attached Python process, and will switch over to the Python process to play with it if need be.

Also, Forth sports a repl.

I've gotten into GBA homebrew again recently. The community is small but getting a bit bigger. gbadev on Discord is a fun place to hang out.

The tooling doesn't seem to have changed all that much from back in the day, which isn't a bad thing: the best way to get music on the GBA is still to compose something in an old-fashioned tracker and using Maxmod to import it. Sprite conversion tools haven't changed that much.

Programming it is just so lovely bare-metal: poking/prodding registers, writing backgrounds and sprites into memory regions.. Really fun stuff.

I've got a Micro (well, two actually). It's super-cute, but the screen is just too tiny for me to be comfortable. You really need to strain your eyes a bit too much.

It's certainly not trivial, but still an interesting journey. I made a backend for MMIX, heavily influenced by the risc-v implementation, and kept the patches logically consistent by rebasing new changes to serve as an example. The last rebase was a year ago, but I think following a previous implementation is the best way forward as there is so much boiler-plate: - https://github.com/stuij/mmix-llvm-support - https://github.com/stuij/mmix-llvm-backend

That said, those kind of olden CPU's aren't a terribly snug fit for LLVM, due to their peculiarities. You'll have to bend LLVM quite a bit to bend it to your will, which also means that you need to get quite familiar with it as well.

edit: this tutorial is even older still, but for me it was one of the best resources, next to checking other simple backends: https://jonathan2251.github.io/lbd/llvmstructure.html

Note that build attributes are only supported on AArch32, not AArch64.

I read this as 'China took a direct route to spying'.

This page gives a nice overview: https://lispcookbook.github.io/cl-cookbook/getting-started.h...

Basically Quicklisp is your CL package manager, and ASDF is your makefile.

LLVM folks have actually just started on such tooling: CIRCT. With Chris Lattner at the helm, and industry players like Xilinx and Intel seemingly on board.

I think only the sharp decline to build up speed counts. Allegion PLC has just that: http://stockjump.sos.gd/?symbol=ALLEN.MX&currency=MXN&name=A...

Just jump on the flat at the end gets me over 700.

I read this story once about an Inuit fisherman on his death-bed telling his son that throughout his life he was always cold.

Ah yea, I did something like this on top of Common Lisp, but not as interactive yet: https://github.com/stuij/armish

My plan at the time was to use a serial protocol and interface with a Nintendo GBA/DS for this kind of interactive Lisp programming.

It feels a bit dirty mixing implementation and target language like this, but it's great fun to program for.

If you just have ears, History of Philosophy without any gaps is great podcast: https://historyofphilosophy.net/. Great and thorough companion when I do the dishes.

As I understood Linux made a lot of progress in the last couple of years with say zero-copy patches, etc. I thought they reached some kind of parity.

fun fact: the name Britain comes from 'painted people' or 'tattooed people' given by Ceasar as he descended upon the UK: https://en.wikipedia.org/wiki/Britain_(place_name).

That author is just not aware of his heritage.

I wanna thank you fourth! Such a great tutorial, and I used it to build a little Forth for the GBA. It was such a great experience.

yea, I posted with another suggestion on this thread, but the GBA itself is just such a dream machine. It's the sweet spot for retro programming in my mind. All the cool console features, streamlined hardware, simple interface. So good.

not popular I guess; it's not even out yet, but the Pimoroni people are doing a GBA-like handheld kickstarter geared towards developing, called 32blit. Doesn't have all the cool bitmap, sprite, etc hardware I'm sure, but they try and give a pretty integrated environment. Also maybe geared a bit more towards beginners, but I really like the idea. And because it's modern hardware, you can just use all your standard tools. It's also got hardware debugging, looks like.

It might be a practical thing. I've heard from a Googler (a couple of years back) that getting changes in can take ages, and by the time the change lands, there's a good chance that there are merge conflicts, and the cycle starts over. Branches would make this even more painful.