by shevy-java | 2025-12-31 19:54:11+00:00
So his view is from a programmer / developer. That's fine.

I had an issue on my local computer system yesterday; manjaro would not
boot with a new kernel I compiled from source. It would freeze, at the
boot menu, which I never had before. Anyway. I installed linuxmint today
and went on to actually compile a multitude of things from source. I
finally finished compiling mesa, xorg-server, ffmpeg, mpv, gtk3 + gtk4 -
and the prior dependencies (llvm etc...). So I am almost finished finally.

I had to invest quite a lot of time hunting for dependencies. Most recent
one was glad2 for libplacebo. Turns out "pip install glad2" suffices here.
But getting that wasn't so trivial. The project project at pip website was
virtually useless; respectively I installed "pip install glad" which was
too old. Also took me perhaps one full minute or more to realise it.

I am tapping into LFS and BLFS webpage (Linux from scratch), which helps a
lot but it is not perfect. So much information is not described and people
have to know what they are doing. You can say this is fair, as this is more
for advanced users. Ok. The problem is ... so many things that compilers do,
is not well-described; or at the least you can not easily find high quality
documentation. Google search is almost virtually useless now; AI just hallucinates
and flat out lies to you often. Or tells you things that are trivia and you already
know it. We kind of lose quality here. It's as if everything got dumbed down.

Meanwhile more and more software is required to build other software. Take
mesa. Now I need not only LLVM but also the whole spirv-stack. And shaderc. And
lots more. And also rust - why is rust suddenly such a huge dependency? Why is
there such a proliferation of programming languages? Ok, perhaps C and C++ are
no longer the best language, but WHY is the whole stack constantly expanding?

We worship complexity. The compilers also become bigger and bigger.

About two days ago I cloned gcc from https://github.com/gcc-mirror/gcc.
The .tar.xz sits at 3.8 GB. Granted, regular tarball releases are much
smaller, e. g. 15.1.0 tar.xz at 97MB (at https://ftp.gnu.org/gnu/gcc/?C=M;O=D).
But still. These things become bigger and bigger. gcc-7.2.0.tar.xz from 9 years ago had a size of 59M. Almost twice the size now in less than 10 years. And
that's really just like all the other software too. We ended up worshipping
more and more bloat. Nobody cares about size. Now one can say "this is just
static code", but this is expanded and it just keeps on getting bigger. Look
at LLVM. How to compile this beast: https://www.linuxfromscratch.org/blfs/view/svn/general/llvm.... - and this will
only get bigger and bigger and bigger.

So, back to the "are compilers your best friend"? I am not sure. We seem to
have the problem of more and more complexity getting in at the same time. And
everyone seems to think this is no issue. I believe there are issues. Take
slackware; basically it was a one person maintains it. This may not be the
primary reason, but slackware slowed down a lot in the last some years. Perhaps
maintaining all of that requires a team of people. Older engineers cared about
size due to constraints. Now that the constraints are less important, bloat
became the default.