Hmmm... sounds like they should have gone for a more modular kernel, and separate legacy stuff to have it as a separate module which gets injected when needed. Or maybe i'm thinking too much like Linux and thinking of how easy that is to do.

Though kernel bugs that are relied on would be annoying...

Linux didn't remove a.out binary support until rather recently. (This feature had been obsolete for *decades* prior to removal.)

Or shared library bugs. For example, if you look through the sqlite3 API, you'll notice things like sqlite3_prepare_statement and sqlite3_prepare_statement_v2 (or something like that), where the former has some undesired behavior that has to be retained or it will break older applications that rely on it.

Odd, often when compiling c applications in gcc i get a.out usually. Though i think it's actually an ELF application when the file is checked.

Mhmm. I wonder if it would be better not to, and just statically include libraries rather than use shared libraries. Yes it makes the executables a bit larger but version changes won't affect them. Not much better than using dll's with windows applications, as a lot of applications include their own copies of common libraries like zlib.

I don't know, there's advantages and disadvantages of both, the bigger problem being that when the programmers are done they tend not to want to go back and make fixes to library changes. To which for the linux kernel is a bit better where for like the ext filesystem when they introduced new features that would break it, it forked to it's own so you get ext2 ext3 ext4, etc etc. While most software libraries want you to update to the newest version.

There's two things here that are both called a.out, and they are not the same:
* The a.out executable file format, which was used by Linux in the earliest days, but has been obsolete for decades.
* The filename "a.out", which is, by tradition, the default exectuable file name when you compile a C program. (It seems that Fortran, at least gfortran, also uses a.out as the default filename.) Worth noting that this can be easily overridden with the -o command line option.

Linux is a monolithic kernel.
When comparing monolithic vs micro kernels, the distinction is whether only the most essential core runs in the most privileged level, with e.g. device drivers running in a less privileged ring, or whether the entire kernel, including most drivers, runs in the most privileged level.

Compiling drivers as modules and loading them dynamically doesn't in itself change that.
Linux is modular, but it still runs the modules with full privileges and is nothing like a micro kernel.

Mhmm. There's a lot of things that are by tradition.

You are correct in that assumption.