yamaha_dx7_rom_disassembly VS Sonic Pi

I wrote the article mentioned by Ken: https://ajxs.me/blog/Yamaha_DX7_Technical_Analysis.html

I've unwittingly become a bit of a Yamaha FM Synth historian!

Here are some other contributions to reverse-engineering the DX7:

A fully documented disassembly of the DX7 ROM: https://github.com/ajxs/yamaha_dx7_rom_disassembly

A new firmware ROM that makes the DX9 function like a DX7:

I browsed through the repository as discovered by colejohnson66 downthread https://github.com/ajxs/yamaha_dx7_rom_disassembly. This is an example of superb, meticulous, lovingly documented work. The kind of thing you don't see every day, congratulations. The attention to detail is really just chef's kiss, starting with a really good repository name (a small thing, but still), continuing through clear and apparently comprehensive documentation of what you did and why, then on to beautifully formatted and commented assembly language (much better than the original source code I'd wager) with coherent and consistent paragraph commenting a particular delight, and finally (and very importantly) dedication to making sure others can reproduce your results and generate a matching binary too. There are likely to be other things of beauty in there I have forgotten to highlight, it's just that good. Oh the FAQ of course, what a great FAQ. Really I am being very wordy for someone that's lost for words.

BTW, I love retro computing too, this is my best attempt so far in the field https://github.com/billforsternz/retro-sargon. I aspire to similar standards to your good self, but I'm not there yet.

Very cool! This is really great work! It's awesome that there's been so many synthesiser related topics on Hacker News lately. I did a similar project myself to disassemble, and fully annotate the firmware for the Yamaha DX7: https://github.com/ajxs/yamaha_dx7_rom_disassembly

The biggest hint I could give anyone looking to disassemble a synthesiser operating system is to direct your attention towards the code processing individual MIDI messages. The code is invariably is huge mess, however you'll be able to very quickly identify the operating system's core functions, since the corresponding SysEx parameter numbers clearly identify what functionality you're looking at.

Anthony just released his annotated DX-7 ROM listing:

https://github.com/ajxs/yamaha_dx7_rom_disassembly

I have wondered what grooves it could come with using https://sonic-pi.net/

Something fascinating about seeing a 'score' for generative music written out as a sort of specification like that.

There's enough detail there that you can take those instructions and reimplement your own version of it, and you'll end up with essentially the same 'piece of music', but certainly a different interpretation of it. Because while the score lays out some details precisely, it leaves other choices less clear. What does 'all inversions' really mean when enumerating chords? Does it include open, spread voicings? What durations should we choose from for our random waveforms? How short is 'short' when deciding to repeat? And of course, what wave synths should you use, and how should you modulate them?

All those are similar to the decisions a traditional instrumentalist makes when interpreting a sheet music score for performance - here, a generative music coder can follow this 'score' and produce a program that represents their own interpretation of the piece.

Coding it up in Sonic Pi (https://sonic-pi.net/) was a fun exercise, and I feel like I was able to produce something along the lines of what the composer intended. It carries the same kind of mood that the recording in the video has. But it's my own 'performance' of the work, if that makes sense (even if it's actually Sonic Pi 'performing' it at runtime...)

All of which got me thinking about the relationship more generally between specification, and implementation. Considering different programmers' implementations of algorithms as individual 'performances' of scores from the overall design - and then thinking about developers building elements of a larger system architecture as individual performers working to deliver their part of the performance as part of a band or orchestra. Some groups, maybe they're directed by a conductor-architect; others maybe are improvisers, riffing off one another and occasionally stepping up to deliver a solo. And some are maybe solid session performers, showing up and delivering strong but unflashy performances to a producer's specification.

So overall, a nice meditative coding exercise for a Sunday afternoon, and a shift in perspective. Thanks for sharing it.

On a seriously light-hearted note, Herve Aniglo, talked about teaching children to code with music using Sonic PI, a language agnostic platform that helps you learn recursions, looping, circuit breaking and functional programming by creating simple tunes.

https://www.youtube.com/playlist?list=PLPYzvS8A_rTYEba_4SDvR...

- Sonic Pi is built on-top of SuperCollider, but it's MUCH easier to get started with making bleeps and bloops. Sam Aaron, who originally created Overtone (a Clojure front-end for SuperCollider) created Sonic Pi initially to teach kids computer programming and music, but now it's turning into a pretty nice live-coding setup. The language is basically a DSL extension of Ruby, and although it's very elegant, I feel like it's a little nerfed in terms of a full language when compared to SCLang, so I'm sticking with the latter for now. High recommend checking it out if you're new to making music or code. https://sonic-pi.net/

- This 'Intro To Live Coding' vid from Alex McLean is great. Gives a good overview of a few fun tools out there that I won't mention here for sake of time (check out Gibber and Hydra for web-based coding things. Gibber is really slick). Alex invented Tidal Cycles, which I feel is like god-tier in terms of power and conciseness. Maybe I'll tinker with Tidal someday, but I want to start with SC.

Strange dice that it seems to mostly be c++, sponsored by 3 prominent elixir shops, with an original OSC server implementation by Joe Armstrong.

https://github.com/sonic-pi-net/sonic-pi/tree/dev/app/server...

There is a programming language+IDE called SonicPI. It's designed to create music by writing code. You can install the program from the lin, then ask chatGPT to generate some sonic PI code that produces some nice melody. Then just copy the code and paste it into the sonicPI program, and run it by clicking the run button. Here's a conversation for example