drainpipe

We are really crawling through the filth with this one…

Over the past few years, I’ve become increasingly tired of Windows, the boot times are slow, applications don’t run quickly, the system is insecure and can be unstable.

I’ve tried almost all of the popular Linux distributions and unfortunately, I have not found one even close to the quality of Windows.

• Most distros boot at a similar speed to Windows (except for Alpine)
• Applications are buggy and difficult to install
• The system can break easily from updates.
• Desktop environments are poorly designed and slow for power users.

I do not believe that the kernel is responsible for this, instead it’s more of a symptom of philosophy and history. Unix was not designed for modern systems and modern requirements.

My only option is clear, build my own distribution (obviously).

I’m calling it drainpipe.

We’ll start with a few basic goals for the system, it should be:

• Simple
• Secure
• Stable

Achieving simplicity

The simpler a system is, the harder it is to break, so what makes Linux complicated?

• Despite modularity being a strength of Linux, it is also a weakness.
• Installing applications is incredibly complex because they are not static isolated binaries.
• Configuration can be complex and confusing to manage.

Applications & DLL hell

I’m sort of glad that this happened to Windows. If it didn’t I don’t think Windows applications would be so portable. Basically every single piece of software on Windows can be thrown around on any Windows machine on any Windows version.

This is not the case for Linux.

Most applications on Linux require installing a number of dependencies(shared libraries). These can easily be broken by the package manager or by the user.

Just fix those issues and make it impossible for the user to do that

That is one approach. However this requires a complex solution to improve the reliability of the system. It’s sort of counterproductive to increase complexity to increase reliability.

We can just make the operating system simpler.

Firstly every application should be sandboxed and self contain its dependencies. It is not secure to have programs share code, they should all be isolated.

If every application contained all of its dependencies it would be simpler to install/distribute and impossible to break.

What about all that redundant code!

It’s just not relevant today, storage space is so much more affordable than it used to be. With the exception of Apple machines 🙄, most desktops/laptops have at least 512GB of storage. I’m not advocating for bloated applications, usually that comes from poor development choices, we just need to be realistic about the current state of computers. The trade offs are really not worth it when you can have static applications which are less than 1MB.

Simplifying the file structure

Currently Linux is a mess of incoherent folders with cryptic acronyms.

• /etc
• /bin
• /sbin
• /usr/bin
• /sys
• /proc
• /dev
• /var

What is all this non-sense? I know what it is, but normal users shouldn’t need to

Here’s my simplified directory structure.

• /os contains everything related to the operating system
• /apps contains user applications (similar to GoboLinux)
• /desktop default desktop folder
• /downloads default downloads folder

Firstly all the noise should be moved into /os and handled privately in there. The user should be able to access system folders or worry about what the operating system does.

All applications should be installed at the user level and should be contained in a single folder /apps. Each application is sandboxed and self contained in their own folders /apps/firefox.

Configuring the system

Currently Linux uses config files in what feels like random and arbitrary locations.

All configuration should be stored in a single file that is a key-value store like the Windows registry. The user does not modify this file instead, they use a GUI or the terminal to set properties. This is similar to the defaults command on MacOS.

This way configuration can be validated and we can tell the user what the accepted values are. There should be a versioned and well defined schema for configuration that describes how things can be configured. This makes it easy for the user, they never need to google any setting because a single terminal command can tell them what is acceptable. This system would allow for useful error messages, something many unix tools are sorely missing.

set brightness
error missing brightness value: set brightness [number: 0 - 100]

set brightness 20
brightness set to 20

This is really nice, because it can never be broken by the user and it’s really easy to backup since all configuration is in a single file. I would love to load a single file and have it setup my system exactly the way I like it.