Linux and the BSDs

Throughout my many months of using various open-source and proprietary operating systems I have made certain observations that might be useful to some. I started with Linux, though at some point migrated to the BSDs for personal and slightly more pragmatic reasons. I quickly became a lot more familiar with FreeBSD and OpenBSD than I ever was with openSUSE or Ubuntu. It may seem odd as Linux is far easier to get into, however seasoned UNIX admins will surely understand. BSDs have this technical appeal, which Linux steadily loses in favor of other features. To the point, though:

1. Save for Windows, most operating systems are extremely similar. macOS X, as it is now referred to, relies on a huge number of BSD utilities, because at one point in time they were more accessible (well-documented and permissively licensed). In turn, the open-source BSD family operating systems, such as OpenBSD and FreeBSD adopted Clang with its LLVM back-end (Apple’s compiler toolchain) as their main system compiler. A number of former, now defunct, proprietary operating systems were based on some revision of UNIX – IRIX, HP-UX, Solaris, etc. There is also a significant overlap of other tools, such as sysctl and ifconfig, which were forked, modified and adjusted to fit individual systems, but bare functional resemblance between various flavors of UNIX. The remainder (text editors, desktop environments, etc.) is typically BSD/MIT/GPL-licensed and available as packages or ports. Therefore, the high-level transition between BSDs and Linux isn’t as dramatic.

2. Above being said, the BSDs and Linux follow different philosophies, of which the BSD philosophy seems a lot more practical in the long-run to me. What most people forget (or never become familiar with) is the fact that Linux is just a kernel and development teams creating distributions (the actual Linux-based operating systems!) can do almost anything they want with it. This leads to myriads of possible feature sets already on the kernel level. It is also up to the distributions to assemble the kernel and userland utilities into a full-fledged operating system. Unfortunately, distribution teams are often tempted to add a bit of an artistic touch to their work, which causes Linux distributions to differ in key aspects. While on a higher level this is hardly noticeable, it may bite one back when things get sour or manual configuration is required. This Lego blocks or bazaar concept makes it difficult for upstream software developers to identify bugs and for companies to support Linux with hardware and software properly. Eventually, only certain distributions are recognized as significant, such as Ubuntu, CentOS, openSUSE, Fedora or Debian. BSDs take a more organized approach to system design, which I believe is highly advantageous. An operating system consists of the kernel and basic utilities, which make it actually useful, such as a network manager, compiler, process manager, etc. Depending on the BSD in question, the scope of the base system is defined differently. For instance, OpenBSD ships with quite some servers, including a display server (Xenocara). FreeBSD, in turn, focuses on providing server capabilities.

3. Recently (or not so much), the focus of Linux has switched from being merely a server platform to a desktop replacement. That’s the ballpark of MS Windows and macOS X, both of which are fairly tried as desktop platforms. The crux of the matter is that utilities had to be adjusted to fulfill more GUI-oriented roles, making command-line work slightly trickier. The other problem is that the software turnover in Linux-land is extremely rapid and programs either become stale way too quickly or they break too often. That’s clearly a no-go for server scenarios. This is where BSDs come in. FreeBSD was designed as a multi-purpose operating system, however with a strong focus on networking, process sandboxing and privilege separation, data storage, etc. In these aspects it clearly excels. NetBSD favors portability and supports many server and embedded platforms, which act as routers, switches, load-balancers, etc. OpenBSD emphasizes code correctness, security and complete documentation. Last, but not least, DragonflyBSD focuses on multi-processing and leverages filesystem features to improve performance. One could say that due to greater resources Linux surpassed all of these operating systems. However, one should not underestimate quality BSD utilities and the almost legendary stability of Berkley-derived OS’. One of the main problems I ever had with Linux was the inconsistent breakage of individual distributions. Upgrading packages would eventually render them useless or impossible to troubleshoot due to uninformative error messages. The lack or staleness of documentation made matters only worse. Having to deal with above problems, I simply jumped ship and joined the BSD crowd. Granted, neither OpenBSD nor FreeBSD make my PCs snappier. Quite the opposite, Linux still wins in that respect. However, I now have full access to the operating system source code and can fix issues first-hand should such a need arise. Not to mention being actually able to read clearly written documentation and learn how to use the tools my operating system offers. I doubt Linux can beat that.

Advertisements

On Using Computers

I’ve been planning to write this piece for a while now, though due to work related stuff I was somewhat hampered in my efforts. It’s a bit harsh at times, but I feel it should become a must read for beginner Linux users nevertheless.

I am a part of the open-source community and as a member I try to contribute to projects
with code, documentation and advice. I fully understand that for the open-source way of
producing content (not merely software!) to succeed, everyone has to give something. However, in the recent months I noticed a sharp influx of new users (newbies), who want to be part of the community, but are extremely confused as to its principles. Incidentally, these newbies “contaminate” the open-source community with former habits and expectations, and make it harder for both existing members and themselves to cope with this temporary shift in the user expertise equilibrium. I blame two main phenomena for the confusion of new users:

1. The open-source way is advertised as inherently “better”, which is misleading.

2. The open-source way requires members to think about what they do and possibly to contribute however they can.

Since the imbalance has reached a peak of being unbearable for me and other existing members of the open-source community, I decided to write this introductory article so that newbies quickly adjust and the equilibrium is restored.

I. User-friendliness is a lie
Following up on the thoughts laid out at over-yonder.org, I want to make this statement extra clear. There is no such thing as user-friendliness. It.does.not.exist. The Internet is crawling with click-bait articles entitled “The best user-friendly Linux distribution!” or “The most user-friendly desktop environment!”. These articles were crafted in order to increase the view count of the host website, not to provide useful information on the topic. Alternatively, they were written by people who are as confused as newbies. “User friendly” just like “intuitive” is a catchphrase – an advertising gimmick used to get you to buy/get a product. There is no extra depth to it. What people wrongly label as “user-friendly” is in fact “hand-holding” – the software/hardware is expected to do something for the user. Not enable the user to perform an action, but actually do the action for him/her. A stewardess on a cruiser or an aircraft is helpful, because she answers passengers’ questions, however she does not hold anyone’s hand, as that would mean leading every single passenger to their seat. If anyone ever tells you that something is user-friendly, ignore them and move on. You know better :).

II. Qualities, quantity and gradation
Generalized comparative statements are being thrown about virtually everywhere. This annoys me and should also annoy you after reading this paragraph. The truth is that most of those statements are fundamentally wrong, because they assume objects of different qualities can be compared using abstract terms. They CANNOT. A useful reference point is comparing apples to oranges. Can it be said that oranges are better than apples? No. What about apples being better than oranges? Neither! “Better” is an abstract term, which by itself means nothing. Therefore, saying “OpenSUSE is better than Ubuntu” means absolutely nothing, also! However, what can be done is comparing specific features of A and B. You cannot say “Apples are better than oranges”, but you can claim that an average apple is heavier than an average orange with specific examples of both. Color-wise, you can say that apples tend to be green-red, while oranges yellow-orange-reddish. You cannot directly compare colors, mind you, unless you express the color of A and B in a uniform color scale, like “the amount of red”. No fallacy has been committed that way. Therefore, neither software, nor hardware can be directly compared, though you can say, for instance that “openSUSE has a number of tools like YaST, which make it potentially more convenient for system administrators than Ubuntu”. Remember that!

III. The “use case” concept
Knowing that user-friendliness does not exist and that many things cannot be directly compared, the next step is understanding the “How” inherent to all problems. You have an issue or an inquiry. What is that you want to achieve? What are the exact requirements to reach your goal? What is the situation in which you experienced your problem? Being specific and being able to disassemble large problems into smaller tasks is paramount to understanding the problem and finding the possible solutions to it. This is true not only for computers, but for everything in life alike. Once you know your “use case”, you will know which hardware and software (including the operating system) to choose. Different operating systems cover various use cases or use scenarios, thereby understanding  your use case well will allow you to find the perfect operating system or any other piece of software quicker.

IV. Options, decisions and the “good enough”
All of the above being said, humans have this need to always aim for optimal solutions. Subconsciously,  they want only the “best” for them. What if it’s impossible to identify the best option? What if all of them satisfy our requirements equally well? Thus, the concept of “good enough” comes into play. Sometimes, the “best” solution is the first solution we decide upon and stick with it. No second thoughts allowed! Until we identify a legitimate reason why solution #1 no longer satisfies our needs for a prolonged period of time. Wondering which operating system to choose? Linux Mint? Ubuntu? Debian? Fedora? Perhaps not a Linux based OS, but a pure UNIX-like BSD? There are so many! If you’re a beginner, it doesn’t matter which you choose. Pick one, stick with it and change only if experimenting or your first choice was completely wrong.

V. Thinking and the individual responsibility
This will be a harsh one. Proprietary operating systems create this illusion of user friendliness (it’s a lie, we know it now!) and that the user is not required to take responsibility for his/her actions done on his/her software/hardware. This is one of the major fallacies in the computer world. The moment you buy a computer, you are completely responsible for it. Consider it your “child”. You need to make sure it’s always clean, powered up etc. No one will ever do it for you. Others can recommend solutions, give advice, provide support even, but the final decision is on you and you alone. Whatever you do with your computer, it is your success or failure. The primary reason why malware spreads like wildfire is that people are convinced that they don’t need to actively care for the safety of their computers. Dead. wrong.

The open-source way is not better than the proprietary/closed-source way. It’s different, nothing else. I chose it, because it aligns with my personal preferences well and I believe that it will prevail. It is for you to decide whether you can accept that. If the answer is “Yes”, I congratulate you. Go forth, learn and become a full-fledged member of the open-source community :).

GNOME3 Oversimplified?

gnome_logo

Seeing as how GNOME3 and KDE (4? 5? Plasma? Neon? Ion?) are the leading desktop environments nowadays, I decided to give GNOME3 a try on my openSUSE Leap 42.3 workstation (my current main distribution on most hardware, including a Raspberry Pi 3). There are good and bad things and some of it agrees with my former assessment of GNOME3. However, I assumed that since I’m more pro-desktop now, my opinion might change. Well, it did perhaps…

The Good:
In material design alone GNOME3 wins a trophy. There is a lot of MacOS X mimicry and I think that speaks well of the project. The guys (and gals!) from Apple know their stuff so why not get inspired by them a little? The overall UX (user experience) is also positive. Thanks to the highly intuitive interface finding important desktop features is a breeze. One just needs to browse a bit and not follow the imprinted this option must be hidden somewhere philosophy that other desktop environments teach us. Also, I greatly appreciate the attention to useful features like the one-click offloading of graphically intensive applications to the discreet nVidia card on Optimus laptops. If our day-to-day tasks focus on office work and leisure, GNOME3 could potentially be the desktop environment of the future. It stands to reason, because it’s an open-source project, molded and shaped into perfection by the user and developer communities. It constantly evolves so there is no limit to its improvements.

The Bad:
Unfortunately, it seems that simplicity of design has its price. Troubleshooting GNOME3 is extremely painful and many of the applications (including the Gnome Shell and the Gnome Display Manager) throw the most uninformative error messages.

something_went_wrong

Authored by the Interwebs

Case in point, the above error screen. The Oh no! Something has gone wrong is a phrase typically used in commercial applications to shield end users from the headaches of reading crash logs. By willfully choosing Linux we demonstrate that we’re no mere end users so treating us as such is quite rude. To dwell on this a bit more, the above error screen appears even when the Gnome Display Manager login panel crashes. How is one supposed to log out without being logged in to begin with? To make matters worse, since many Linux distributions have the display manager set to restart on failure, this screen will keep re-appearing until proper troubleshooting is done in one of the TTY consoles (ctrl  + alt + F1 – F9 keys). This very much reeks of Windows and MacOS X problems where the user interface basically took over the OS. All we can do is just reboot and hope for the best. Other applications show similar An error occurred messages without any means of actual troubleshooting.

My take-home from this experience is Thanks, but no thanks. If I want to get some work done, I would rather rely on LXDE, XFCE, LxQt and maybe even KDE. Traditional desktop environments without bells and whistles.

Mission: Saving Linux?

Recently, I was really into the BSDs and fiddled around with OpenBSD on some of my PCs. I still keep it on one laptop and FreeBSD on my main workstation. The point being that the BSDs are a lot more consistent, reliable and if something works out-of-the-box, it will most likely stay that way for a long while. Changes are incremental and major frameworks are not being reworked for semi-valid reasons, like oh, this looks old. Also, the very clearly superior BSD documentation – cannot go wrong with that!

Nowadays, Linux seems to be riddled with Windows-like problems. There is a surprisingly strong emphasis on easy-to-use GUI tools and hype for certain technologies (*cough* *cough* Docker) that are far from production-ready. The main rationale seems to be make it easy to set up. Everywhere I look there is loads of fluff. As Matthew Fuller put it in his discourse at over-yonder.net, we should be improving the back-end and extending it into usable front-ends, not the other way round. I agree, it’s important to enable people to do great things with technology, but if the how is there yet the why is missing, we’re not getting far. In addition, there is a lot of wheel re-inventing going on. People forget (or simply don’t know) that many of the great frameworks and tools were implemented already and can still be used effectively. Then, there is systemd (a case study on bad software engineering) and making Linux things so Linux-centric that portability suffers greatly (see: Docker being in fact Linux + Docker on non-Linux platforms). So there, we need a hero. Otherwise, we’re doomed to drown in self-indulgence.

A rather interesting idea would be to take the Linux kernel (for hardware compatibility reasons) and build a BSD-like operating system on top of it. Forget systemd, NetworkManager and other tools that try hard to do something that has already been done successfully. Leave the kernel + GNU coreutils in a steadily improving base and separate third-party software into package repositories. Also, one needs to start fresh – a clean slate to avoid the pitfalls of existing Linux distributions. In fact, there is already a project that tries to implement some of the BSD concepts in Linux and per my very preliminary impressions looks quite successful. Enter Void Linux!

Void seems to fill the gap (pun intended) between the Linux and BSD worlds aptly. There is a simple (limited?) init implementation called runit that takes care of starting the system as our favorite PID1, and launching service daemons to get a certain degree of persistence. It’s a typical Unix-like piece of software – does its job and swiftly moves aside to let us do ours. Then, there is the XBPS package manager and ports builder all-in-one framework. Think Arch’s ABS on steroids. Instead of OpenSSL we get OpenBSD’s LibreSSL (huge plus in my book!) and the musl C library alongside (but not on one installation, mind you) the traditional glibc. Speaking of C, all of these tools seem to be quite robust and xbps is perhaps the snappiest package manager I have seen in a while. Although the developer team is small, it’s doing a decent job at maintaining Void Linux. It’s a clear sign that it’s possible to run Linux without unnecessary bells and whistles, yet with all of the standard desktop features one might expect. My generic ASUS S301LA ultrabook handled Void Linux very well and all of its hardware was both supported and configured correctly (Intel WiFi Link 5100, SiS touchpad, AzureWave webcam, Intel HD 4400 graphics, WD-Green SSD, UEFI). Below a screenfetch rundown of the setup:

void_screencap

Now, it is true that finding a solution to 14 problems generates a 15th problem. There are certain aspects of Linux system design that I don’t completely agree with and adding orderly features on top of a Linux distribution mess doesn’t make the final product more organized. However, it’s a very successful step towards restoring some sanity to Linux Land that we lack so much nowadays.

In Software We Trust

Inspired by the works of Matthew D. Fuller from over-yonder.net I decided to write a more philosophical piece of my own. While distro-hopping recently it came to my mind that whatever we do with our lives, we never do it alone and our well-being depends on other people. It requires us to trust them. Back in prehistoric times a Homo sapiens individual could probably get away with fishing, foraging and hunting for food, and finding shelter in caves. The modern world is entirely different, though. We need dentists to check our teeth, we need groceries to gather food, we need real estate agents to find housing, etc. Dealing with hardware and software is similar. Either we build a machine ourselves or trust that some company X can do a good enough job for us. The same goes for software!

Alright, so we have a computer (or two, or ten, or…) and we want to make it useful by putting an operating system on its drive(s). MacOS X and MS Windows are out of the question for obvious reasons. That leaves us with either Linux or a BSD-based system. Assuming we pick Linux, we can install it from source or in binary form. This is where trust comes into play. We don’t need to trust major GNU/Linux distributions in terms of software packaging and features. We can roll with Gentoo, Linux From Scratch, CRUX or any other source-based distribution and decide on our own what does and doesn’t go into our software. It’s kind of like growing vegetables in a garden. Granted, we ourselves are responsible for any immediate issues like compile errors, file conflicts or missing features. It’s a learning process and one definitely profits from it. However, it’s also time-consuming and requires extremely good understanding of both system design and the feature sets of individual programs. No easy task that. Therefore, it’s far more convenient to use binary distributions like openSUSE, Ubuntu, Fedora, Debian, etc. It requires us to trust that the maintainers and developers are doing a good job at keeping software up-to-date, paying attention to security fixes and not letting bugs through. I myself don’t feel competent enough to be a source-level administrator of my own computer and be able to fix every minor or major issue in C++ code. I prefer to trust people who I’m sure would do it better than me, at least for now.

Curing GUI Phobias

Since some time I’m a happy openSUSE camper, yet often frequenting the main Fedora IRC channel. Truth be told, It was tough to decide between those two distributions as both are extremely solid and bug-free. My third choice would fall to one of the Ubuntu spins (Xubuntu or Lubuntu most likely). Eventually,  I realized I’m less and less inclined to put in that extra time to set up Arch Linux or Gentoo per self-indulgence. I know I would be able to, but why should I? I’m familiar enough with Linux to roll any distribution. It seems my impressions go hand in hand with those of Roger from Dedoimedo (http://www.dedoimedo.com/computers/why-not-arch-linux.html). I’m sure he too would be able to install Arch Linux on any PC of his choosing, though again why should he?

Many modern Linux distributions are solid, finished products. You can install them on anything from a bootable USB or DVD and just get things done. That’s precisely the point. It took years, buckets of sweat and units of blood to reach that state. However, now we’re here! More so, we’ve beaten Windows, because it’s still as much of a pain to install as it used to be a decade ago. Therefore, instead of repeating the rite of passage (read: installing Gentoo or Linux From Scratch on a laptop), we should move forward. There is this wrongly placed elitism in some of us in the Linux and Unix communities (mea maxima culpa!) that if you don’t run a hardcore distribution on your shoddy PC, you’re not nerdy enough. So far from truth this be! Nerdy stuff can be done on virtually any of the mainstream distributions. You can set up servers running Ubuntu Server (duh!). You can build datacentre grade boxes with openSUSE Leap. File server on Raspberry Pi? Yup. And so on. No need to spend hours hacking the Linux kernel to squeeze out that extra 0.000000001% performance gain, thinking that alone makes us Computer Wizards. The important thing about mainstream distributions to bear in mind is that someone poured hours of their free time to assemble together the Linux kernel, utilities, a desktop environment, repositories, etc. All of this so that we wouldn’t have to do it ourselves. Isn’t that golden? Truly, we should build on that rather than shun it.

I understand this stands in stark contrast to my former preachings. I, like many others, have escaped from Windows because it was overburdened with black-box utilities and hidden system services. It was a pain to fix without bricking it entirely. However, it’s actually nice to have a pretty GUI and helper tools to simplify system maintenance. The main difference is that Linux-based operating systems are highly malleable, well-documented and can be adjusted to our liking. I realized that’s probably the main reasons I switched.

Skype for Linux Woes

First and foremost I would like to thank Microsoft and contributors for considering our measly 1+% of desktop coverage and beginning works on the Skype on Linux desktop app. Frankly, previous Skype 4.2 and Skype 4.3 releases felt like rotten meat scraps thrown at a dog (or penguin) and were equally dangerous to Microsoft as to Linux users due to lacking security updates. However, one should be positive as there is light in the form of Skype for Linux Beta. Overall, the app is quite polished and doesn’t have too many graphical glitches. Alas, there are some things to consider still:

  • Only .deb and .rpm packages are available. This strange practice is quite common and I still don’t understand why a tarball with the binary + libraries is not offered alongside. There are many Linux distributions that use other packaging formats. Are vendors afraid that some hacker might reverse engineer the binaries? On top of this, Debian .deb archives can be quite different from Ubuntu .deb archives. Same with Fedora and openSUSE.
  • The website states “Video call your contacts.”. What it doesn’t mention is that this option is not available just yet. We learn it the hard way when calling our Windows-using parents. No talking heads for now, unfortunately.
  • Close to none debugging capabilities. This one pains me the most. The app is clearly denoted as a beta version, therefore one might assume that each user is in fact a beta tester. Any and all feedback would clearly be valuable to Microsoft. Yet, the app doesn’t leak any information to the terminal by default at all. Also, no something went wrong, please send us this pre-formatted report feature is available. I mean, really.
  • Bad software design is bad software design. I accidentally kept typing in the wrong account name, forgetting the domain for users is @hotmail, not @microsoft. Obviously, the account didn’t exist, but instead of telling me this, the app would show a glitched error screen with a Sorry…an unexpected error occurred. This is so Windows 98, honestly. No traceback, no nothing. Also, the Sorry and a cryptic error reference ID don’t really help anyone. What\s up with this attitude?

They’re on the right track, but plenty of polishing is needed. Truth be told, no piece of software shines from the get-go. Uncut diamonds need cutting. That’s just the way the world works.