In my last post, I noted that I was switching away from Wordpress to a roll-my-own-solution. I took the last handful of posts, and started the work of converting posts to the new blog format. I never realized until I started converting, that this blog has existed for well over 20 years at this point.

The world of open source is dramatically different today. Sometimes I get a bug up my rear to go take a look at projects I used to work on or people I used to work with. I’ve been in the corporate world so long that each time I come back to the land of open source, I’m amazed by the change that happens over what seems like few years. The initial focus of this blog was on my attempted development of a new Linux distribution. This turned into being a package maintainer for the upstream of Foresight Linux. It’s hard to believe that Foresight itself died roughly 8 years ago.

Maybe getting older introduces nostalgia for the “Good Old Days”, but I honestly miss the open source world that existed in the late 90s / early 2000s. Mostly, Software Development just felt… a lot more fun. I thought for a while that maybe I just made the mistake of turning a hobby into a career. But lately, I think it’s simply tech gentrification. The tech stack of today is infinitely less democratic. The major Linux developers are big corporations: RedHat, IBM, Canonical, Microsoft…

A lot of old-school nerds shouted at the air when SystemD became a “thing”. I never quite drank the hateraid. But, I have come to notice that the core Linux subsystems have gone further and further away from the general Unix hacker philosophy. I don’t think younger students have many open areas for development now. Low level kernel development operates like a large company. Higher level development is typified by the sad state of Wayland Window Managers versus X11 Window Managers.

I can hear someone responding about how “we’re no longer duplicating effort”. This makes the massive assumption that the incoming level of effort remains constant. My opinion? The story of “volunteers” building Linux is dead. The most vocal “community activists” are giving presentations at conferences on new software intended for AWS and Azure while using an Apple laptop.

Yikes. I need to chill before going full cynic.

In any case, I’m slowly working at updating this blog with the past 20 years of converted files. I’m starting at the beginning (and the end) and working my way forward. So, you’ll likely (until I’m done) notice a huge jump in tone and time. Enjoy the time capsule. While I started doing this with my own software, I discovered a new - and very solid - project that worked almost EXACTLY like what I developed. Sans that they actually wrote a markdown processor, allowing them to avoid sideloaded files… So, these entries are now populated using “Hugo”. Unfortunately, that also means no comments. Want to argue? Shoot me an email. I’m hoping to setup Mastadon or Matrix here soon.

Until next time. Peace.

Fighting blog software is tiring.

After some serious consideration, I’ve decided to roll my own software for this site. Why? Wordpress is a fairly massive security liability, and I’d like to avoid the ongoing maintenance effort (or cost of hosted service). Worse, I’ve found that each new version focusing more on being a full-fledged CMS and less on simple blogging. And - yet worse - I’d like to nuke MySQL / MariaDB as a “thing” on this server.

My original blog was a simple M4 macro and Makefile for a static site. This removed the ability to have comments, but at the time, I was utilizing a static hosting service anyway (no databases!). Management was really darn easy in this case, outside of the gnarly aspect of updates.

Eventually, I’d like to introduce a new/custom BBS style piece of software to run this site - complete with comments, mailbox, and user features. Right now though, I have scant time to actually maintain this thing, and I’d like to “simplify” my tech life management into something that’s easy to work with. The original blog will remain available for some time under the /blog directory (to maintain links) - while I work on conversion.

If you’re curious to see the (REALLY HACKY!) software stack used for this blog, I’m hosting it on github. Blog entries are simple markdown file with a side-load JSON file to specify all the meta data. A compile python script scans for files, builds an indexes, and poops out some static HTML.

Boom. Done. Simple is better.

Since Wyrm is utilizing a bootstrapped Scheme variant, building data structures and writing files is surprisingly difficult. Scheme provides the ability to express almost any construct, but without standard libraries every tiny detail most be determined.

The “actual” Wyrm system will eventually provide low level data structures and type support. Any construct utilized by “Mini Scheme” will require duplication between both the Wyrm Scheme implementation, and the “generic” Scheme based system. Writing the ELF decoder, the first obvious challenge to address is some form of structured data support. Normal scheme applications might use a SRFI-1 based “associative list”. Ideally, Wyrm will implement an associative container with “better performance”, but for now, utilizing a wrapped associative list works well. Given the newly defined “dictionary” type, the next hurdle is implementing basic support for serializing structures. For this, a new ‘encoding’ structure is created. With a defined dictionary type and serialization structure, implementing basic support for the primary ELF file header is simple.

So far, basic Test Driven Development (“TDD”) practice has allowed development of substantial infrastructure without gnarly scaffolding. The current ‘Wyrm’ program remains a simple “Hello World” display, but substantial support for ELF and “Wyrm” common scheme library support is present.

The huge challenge remains focus. Even basic decisions get easily bogged down if considering all the possible angles of a full toolchain ecosystem. Worse, there’s nearly infinite complexity possible if attempting to expand to a more modern feature set. But, without the massive set of refactoring and “intelligent” coding tools, any added functionality becomes massively distracting. A worthwhile detour might include integrating Visual Studio Code for improving quick reference documentation.

With the July 4th Holiday, I enjoyed a 3-day weekend but intentionally limited the time I spent hacking on Wyrm. There’s a lot to unpack in creating a full operating system and toolchain (even with a limited scope). Instead of jumping into full fledged implementation, I took the opportunity to brainstorm and structure the project.

Given we’ve got a hugeeeee amount of work ahead in bootstrapping a kernel and toolchain, the big question becomes “where to start”. For this project, I’ll be trying to maintain a “Test Driven Development” practice. A unit test framework also creates a simplified environment for early development.

The first project milestone will be a “Hello World” constructed kernel from our toolchain. Qemu supports loading a binary ELF image, and most portable toolchains will work with ELF binaries. For the first project milestone, the Wyrm toolchain will construct a valid ELF kernel image with a “Hello World” assembly kernel. With ELF, the Wyrm toolchain may create images for either or fledging OS or the Linux ecosystem. The end-goal is a fully self-hosting system – but until that point, Linux or Windows can provide a host environment.

If someone forced me to select a ‘favorite’ programming language, I’d likely fall into the Python camp. Python does not, unfortunately, make for a good “system” programming language. However, both Julia and Nim advertise some degree of compiled / system programming features. For our toolchain, I’m going to pull a page out of Julia’s playbook and utilize the simplicity of Scheme for compiler and runtime implementation. With a strong Scheme toolchain, I hope to experiment with a maybe-Python / maybe-Scala frontend. With a scheme-work-alike, we can utilize a “proper” scheme implementation to bootstrap the system. I’ve selected “Chicken Scheme”.

With the few commits this weekend, there’s a small test framework and the start of some low level scheme primitives for building ELF files.

For a long time, I’ve maintained various iterations of low level operating system logic or programming language interpreters. The earliest iterations focused on recreating QBasic and DOS. Newer iterations focused on various technology stack ideas (the last being microkernel and exokernel based approaches). The only time my software stack ever ventured out to be seen by others was… as sample code for a job interview.

I’ll be covering this project on the podcast - but, before adding the glitz to the idea, I find myself wanting to sit and write about the idea. Starting with the why and for and what.

I’d be lying if I didn’t admit to a strong desire to build “the next thing”. And - I’d be lying to myself if I argued Wyrm had any hope of being the next thing. Instead, the mission of Wyrm is simple: a playground for OS and programming language conceptual development. My hope is to build upon (or create) some framework similar to the hello world staples provided at the OSDev Wik. Instead of duplicating Unix and C, my intent for Wyrm is to explore the history of Amiga, Newton, and LISP machines. And, of course, duplicate Unix and C at some point.

I do not plan on supporting many hardware platforms - only the ARM, and likely only one or two available single board computers. I’m considering the Raspberry Pi 4, Asus TinkerBoard, and a QEmu Aarch64 machine for starters. This does presuppose that I manage to get the language itself into a workable state. As I don’t have a lot of time to dedicate toward the project, I suspect progress will be slow and be redirected to other ARM (or Risc-V) cores as time goes on.

I’m starting with a “blank slate” for this project. My goal will be to cover the fits and starts and pain associated with birthing an Operating System from scratch. There’s multiple toy OS projects out there - and multiple “real” projects - but developers tend to “wait” until some mythical “beta” period. Realistically, I don’t see myself having the time to hit such a milestone quickly. (Especially starting from the ground-up). That said, I’ve built many toy interpreters and kernels - so I suspect there’ll be something that appears at some point. From experience, a bootable “hardware” ARM kernel is a few weekends worth of effort. That said, my free weekends are few…

elfenix/wyrm: OS and Language Playround (github.com)