Qt solves a lot of platform abstraction for the programmer. You might even say it solves too much.
The downside is that it is a hulking behemoth of a dependency with a nontrivial build process.
But, it enabled me to make some windows and fiddle around with some code.

Rust seemed like a cool alternative to C++ because it had fancy new programming language features
like not requiring .h files. More seriously, the 3 problems with using Go are resolved with
Rust, since it can call C code directly, C code can call it, and there is no garbage collector.
Further, the safety guarantees it made were promising.

But nothing in life is free. GTK is sufficiently complicated that a Rust "safety wrapper" is in order.
The one available was not complete.

At this time I began to have a new philosophy: Stop depending on libraries that hold the project down.

This led me to ditch the idea of using GTK or Qt and instead code the user interface toolkit from scratch.
This would work out better anyway if I wanted to sandbox plugins and provide a user-interface API for them
to use.

At this point I felt like I needed a direction, something to work towards. So I created a goal:

Open an audio file with libav.

Display the waveform of the audio file in the display.

Next I began to experience Rust development. I went back and forth between GLFW and glutin for
window library as one or the other seemed to be better.
I created groove-rs - bindings to
libgroove.
I wrote my own
3D math library because
the existing one's API was too hard for me to understand.
I fixed a lot of code after updating to the latest Rust compiler each day.

Finally, I got font rendering working. It took me 16 days, but I felt like I had learned enough
about Rust to finally let me develop efficiently.

And then I tried to abstract the font rendering code into a widget concept, and everything broke down.
The Rust compiler has many false negatives - situations where it is a compile error due to safety,
but actually it's pretty obvious that there are no safety problems.

This is so frustrating and demotivating that I realized the benefits of Rust did not outweigh
the slow development pace that I had taken on.

I felt guilty for allowing myself get distracted from actually making progress all this time.
From now on I would be lazer focused and in general avoid depending on other people's code.
If it's a bug in my code, then I know how to fix it. New roadmap:

Load all the audio file's channels into memory.

Display all of the audio file's channels in a list.

Render channels graphically.

Ability to make a selection.

Playback to speakers.

Delete selection.

Undo/Redo

Multiplayer

So I knew I would be switching to C++. But I did not want to fall into the same trap in C++-land
that I did in Rust-land: instead of solving the actual problem of making a DAW, trying to understand
how Rust or C++ works and get my code to compile.

But some C++ features are too good to ignore, such as template data structures. For example, in C
if you want to create a list data structure, you have 3 options:

Make it generic using preprocessor directives.

Make it generic using void * instead of actual types.

Don't make it generic. Reimplement the same data structure over and over for each type.

This sucks. Preprocessor directives are the devil, Too much void * leads to
runtime memory safety errors that the compiler can't catch. And what if it wasn't a simple list
data structure, but instead a hash table or something? This is crazy, we can't reimplement the
same data structure a bunch of times.

Another example. In C you use malloc to allocate memory. It typically looks something
like malloc(sizeof(MyType) * count). If you forget to multiply by count or sizeof, oops.
segfault. Meanwhile if you can use templates then you can define a function like this:

So I wanted templates from C++. And atomics
from C++11. But that's about it. Other than that, I want to code like I'm in C. The beauty of C-style
coding is that the control flow is so simple, it's impossible to not know what code is doing. Contrast
that with fancy C++ stuff and you never know what's going to happen or what each line of code is going
to do.

I figured out how to have my cake and eat it too. I discovered that you can compile with g++
and link with gcc, like so: