$USER@bit-of-a-byte ~ $ cat /var/log/pages/about.md


“And folks, let’s be honest. Sturgeon was an optimist. Way more than 90% of code is crap.” ~ Al Viro

Character Statistics

Name: Zeph
Level: 30
Gender: Female
Class: Dual Class - Healer/Technomage
Occupation: Hospital/Sterile Compounding CPhT/PharmD Student

Combat Statistics

STR: 08
DEX: 15
CON: 10
INT: 18
WIS: 06
CHA: 06
SAN: 08


Hi, my name is Zephyr and I’m a 30 year old Pharmacy student based out of Missouri. When I’m not reading up on the latest and greatest pharmaceuticals I like to take things apart. Anything. A car, a computer, dumping compiled code into object code to see how it works. Running network scans on my ISP to try and figure out why PMTUD on IPv6 is broken and I have to manually set an MTU of 1280 on my router… If you can think of something, I’ve probably done it.

Right now I am especially interested in embedded systems and networking, which is why it makes up so much of my content current large sets of data and efficient synchronization, however, this may change at a moments notice. I like embedded systems because they still require an extreme amount of efficiency. The previous sentence is still true, but I’ve moved on to working with large amounts of data. Data transactions need to be precise and unfaltering, or you are immediately penalized. That’s where I tend to spend most of my time now.

As for the style of computer user I am, I believe it can be summed up by a small list of view points:

  • My favourite processor is SPARC. This is followed by MIPS, AVR32, ARM, and last and certainly least, x86 and x64. The last x86 processor I actually liked was when Cyrix reverse engineered Intel’s Pentium via clean room engineering and produced a faster processor, which Intel then stole and made into the Pentium Pro.
  • I think microkernels are the golden standard of what should be implemented in an operating system design.
  • Modular kernels are the worst thing to ever happen to security. (I will be nice and not go into the fragmentation penalty.)
  • Dynamic linking is one of the worst things to ever happen to programming. (Library Symbol Versioning Hell)
  • SystemD is the worst thing to ever happen to Linux, and that’s saying something. (GNU is Not Usable)
    • While my viewpoint on this has not changed, it seems that I am in a rapidly diminishing minority. As such, my current linux systems use SystemD because that is what they’re shipped “stable” with. I have recently had to start looking into writing unit files.
    • Refer to the final bullet point below for my views on widely used software.
  • In a past life, I was a developer for a source based linux distribution where I spent literally all of my time attempting to make linux packages build for Clang/LLVM and yelling at upstream for using GNU specific extensions.
  • DragonFlyBSD is the most exciting operating system of today.
  • NetBSD should be the standard of Embedded System Development.
    • Recently, an article was written that stated the BSDs may be dying. While I still greatly prefer the BSD architecture, the fact is that fewer and fewer people are deploying it, and as the user-base dwindles, the amount of support will dwindle as well.
    • With this in mind, while NetBSD SHOULD BE the standard of Embedded system development, I am ready to concede that it might not be. Instead, you should look for a Realtime Operating System, or consider Open/FreeBSD.
    • This might be one of the most painful updates made yet to this page. I really do love NetBSD.
  • GPL is just as bad, if not worse, than standard copyright.
    • Time has only further hardened my view on copyleft licensing. Copyfree is the only license I will ever use.
  • GPLv3 is the single most terrifying thing to ever happen to GNU, and that is REALLY saying something.
  • “There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies.” ~ C.A.R. Hoare.
  • It is highly likely that the days of good code are over, because when given the choice between easy and terrible (Java, Javascript) versus hard but stable (Haskell,C,Go) the entire most of the computer science world has embraced the first.
    • I previously listed Python as a member of the first set of languages. With my recent dabbling in AI, I have been impressed with the performace python is capable of obtaining. Additionally, Cython solves one of my primary complaints which was the inability to compile the language. With that said, I still do not believe Python should be used to handle important tasks. Even the backup system I am currently favoring (BorgBackup) implements the most serious portion of its codebase in C. Things like Portage still baffle me, even though I worked on them. At that low of a level, you should be shipping compiled binaries, not interpreted languages.
    • Ruby was also a former member of the first group of languages. With this section under way, let me start by saying Ruby should absolutely not be used to write “programs”. Ruby on Rails is a horrifying concept to me, but web developers have always been scary. All that being said, Ruby can be an absolutely wonderful scripting language. If you need something stronger than shell and don’t want to write a full application, Ruby fits nicely into that niche as long as the script does not need to be performant. It is still horrifyingly slow.
    • Also, fuck the idea of writing full programs in Javascript.
  • I don’t believe that just because you have a 1TB Hard Drive that you can justify or allow a 16+ Gigabyte operating system.
  • I don’t believe just because you have CPU cycles you should waste them on abstraction compared to low level clean code.
  • I don’t believe that any program other than those handling data sets of over 512MB should EVER use 1GB or more of RAM.
  • SQL Databases are so horrible that the designer will get into heaven simply because the devil doesn’t have time to deal with that shit.
    • I’ve recently begun to quite like SQLite3. They’re still fucking horrific to work with, but SQLite3 makes things nice by having a single file.
    • While we’re on the topic of databases, KV Stores are really neat.
  • Git is the only sane version control software.

Last, but certainly not least:

  • Just because everyone uses a software, a software is easy, you are mandated to use a software, or the software/protocol is old does not mean you should live in a delusional world about how bad it is. (I’m looking at you, SSH.)

    “Zyradyl is a 72 year old male Bell Labs Employee trapped in the wrong body.” - Asaph