Published:

Jarle Aase

Things I made for myself or just for fun

bookmark 14 min read

My origin story

The first application I ever wrote was a word processor for the Commodore 16. I wrote it in BASIC, during my Easter vacation that year.

Back then, I worked in a preschool. The upcoming Easter vacation gave me about one week off. The pay for my job was hardly enough to cover the rent for a room on the top floor of a very old building in my hometown, and the cheapest food I could find. Still, I had managed to save a little money. On the first morning of my vacation, I walked around the center of my hometown without any destination. There, I saw a home computer in a shop window.

My father, an old union man, worked most of his life in the newspaper industry. A few years before my vacation, he had started studying at the university in his free time. He was obsessed with politics and deeply concerned about IT’s future influence on society. He wanted to understand it better, so he could fight it. He chose to study law and IT - a pretty unusual combination. The two of us had many conversations about his concerns, starting around the time I began to recognize words. By the time I was 10 or 12, I also feared that computers could destroy life as we knew it.

Now I looked closer at that thing in the shop window. It was a Commodore 16, an early home computer built as a thick keyboard. I wanted to get close to that devil, to understand what made it tick, and exactly how dangerous it was. I bought it.

Back in my little room, I unpacked it, connected it to my cheap 24-inch black and white tube TV, and started it up. By default, it booted into a BASIC interpreter. It did not look or behave like the devil. Actually, I liked it. I read the documentation and realized that it couldn’t really do much. It had this BASIC programming language available. That was it. In the shop, they had lots of games they wanted to sell me. I wasn’t interested. I had spent a lot of time in arcade halls as a child, and I had bought a gaming console when I was 12 or 13. I wasn’t into gaming anymore. But I was into writing.

I realized the computer would make a much better tool for writing than my mechanical typewriter. One error on a sheet of paper with a typewriter, and you basically had to rewrite the whole page. With a computer, on the other hand, the text would be on screen - in the computer’s memory. I should be able to change letters and words, make corrections, and actually edit my documents until I was pleased with them. Then, when my documents were completed, I could print them to paper with a printer. I had seen professional digital writing computers that did just that. They cost about the same as a new car. Later that same evening, I sat down in my little room to write a word processor in BASIC, on my Commodore 16 with 3.5 KB RAM and a 5 KB RAM expansion box.

I had no books about programming - at least not programming in BASIC. My father had lent me some general introduction books on IT. I don’t remember the details, but if they mentioned programming languages, it was probably COBOL or VAX/VMS assembly language. Not very relevant to my project. All I had was the Commodore 16 Owner’s Guide I got with the machine, and no money to buy anything better. BASIC was covered, kind of. I worked with what I had until I fell asleep sometime the next morning. When I woke up, I continued learning and coding. I hardly slept the whole week. The only thing I could think about was how to write that program. Consumed by a burning desire to figure it out, I went through some of the most frustrating and heartbreaking days of my young life. Needless to say, I did figure it out. And I knew that I had found my Big Passion in life.

A few years later, I wrote commercial programs in C for QNX and Unix. A full-featured word processor, CrWs, which a friend and I designed and wrote (~200k lines of code, written over 2 years), was used by commercial customers all over the world. The US Air Force was one of them. The application ran under QNX Windows and XENIX/Motif. It also ran on dumb terminals. It printed to HP LaserJet and PostScript printers with a wide selection of fonts. It even had import functions for WordPerfect and Microsoft Word documents. It was an insane project for two young hackers without any formal education in software development (or much else).

Over the decades, I’ve written far more than 1 million lines of code, mostly in C and C++. I’m still passionate about coding. I made an incremental improvement in one of my open source projects today. When I looked at my fitness app, which pulls data from my smartwatch, my stress level was lower while coding than it is when I meditate. My energy level increased 30% while I worked. That’s how my biology reacts to programming. And that’s why I’ve never moved on from writing code to any kind of management work. I love what I do, and I don’t want to do anything else.

I’ve written code for many operating systems - some almost forgotten and definitely obsolete today - such as CP/M, Sintran, and Digital VAX/VMS. I’ve written code in many programming languages. Some of my free programs have gained modest popularity, like the War FTP Daemon, which was very well known in the late 1990s. NASA used it for at least 10 years. One of the more trivial things I made in the same era - a sendmail library in C - is still part of the standard PHP library. PHP is used by millions of websites today.

Besides core technologies like operating systems and programming languages, I’m also deeply fascinated by more complex systems, like Kubernetes and distributed systems. While I worked for a startup that used Kubernetes for their stack, I wrote a Kubernetes deployer in C++ (like Helm, but much simpler to use) that allowed me to deploy our entire stack - or parts of it - on a real cluster or on Minikube, handling everything, including ingress with Let’s Encrypt certificates on private IPs. That was an awesome journey.

Some things I wrote just for fun

Almost all the software projects I’ve created were born out of a need. I wanted to share and exchange files, so I wrote an FTP server. I was working on a QNX token ring network and a TCP/IP network with UNIX machines, so I created a network bridge over an RS-232 serial cable between a node on each network. I published my own software, so I wrote a support site in PHP, with the projects, issues, mailing lists, etc. I had a private website where I published articles frequently, so I wrote a CMS with user profiles, image galleries, multi-language publishing for individual articles, RSS, etc. (It was mostly written in PHP, but it also had a module written in C++ to improve security and speed things up). And so on. I’ve never written any code just to have something to brag about or to put on my CV.

But I have written some stuff just for fun and for the love of the projects.

BASIC interpreter in C

Shortly after our startup had released the word processor, my partner - then 17, I think - went to Canada for a week to attend a QNX event. I was back at the office alone. We had no urgent work that needed attention. So, besides checking the fax machine now and then and keeping our resellers happy, I was bored.

I wanted to spend the time alone learning something new. I had the red dragon book on my bookshelf, acting like a magnet for my attention. I also found a manual about BASIC programming for the Osborne 1 personal computer. So I decided to learn Lex and Yacc by implementing a BASIC interpreter, using the Osborne 1 manual as the syntax reference. The Osborne actually came with two BASIC variants: CBASIC - a compiled BASIC from Digital Research, and MBASIC - Microsoft’s BASIC interpreter. I implemented Microsoft’s variant. This was before Microsoft evolved into a dark empire. It was a pretty fun project. I never used it for anything (except as a component in an experimental spreadsheet application for dumb terminals). But I have since used Bison (a Yacc variant) and Flex (a Lex variant) for useful things many times over the decades.

Graphical web page generator in C++

I started using C++ in 1996. One of the first applications I wrote was a website generator. After trying to maintain my own website using plain HTML, I soon realized that was a losing battle. As the number of pages increased, links back and forth between the pages needed to be updated. So I wrote an application for Windows where I presented a tree representing all my pages on the left, and the selected page on the right. I could fill in some basic things like the headline, the text on the page, images, and icons. When I was done, the app would generate a website based on templates that handled the actual formatting and appearance. Pretty basic stuff, but there weren’t many alternatives at that time.

About the same time, I wrote the War FTP Daemon, also a Windows app written in C++.

Usenet server

Back in the day, I really liked Usenet. This was a globally distributed discussion network, built using messages that were pretty similar to email. But instead of going to an individual, messages went to discussion groups. Individual Usenet servers (NNTP servers) were maintained by ISPs and often universities, and each admin could decide what group hierarchies were carried by their server. Each server had a number of peers, and all messages entering a server were offered to all of its peers. That created a really resilient global distribution network for the individual groups. Unlike the web, it was an information network that couldn’t be censored, and where messages couldn’t reliably be taken down once they were published. The protocol itself is pretty simple. The challenge in writing a Usenet server is the volume of data it must be prepared to handle. Today, it could easily be architected using sharding or scalable cloud data storage for the messages, and Kafka or Pulsar streams to buffer input and output communication with the peers. But a few decades ago, it was still an interesting challenge.

One Easter vacation, I sat down, read the related RFCs, and implemented a working NNTP server in less than a week. It was really fun. By then, Usenet was dying - partially because Google did kind of a hostile takeover (rebranded Usenet as Google Groups), and partially because of spam. (In short, greed killed Usenet). So I never packaged and launched my Usenet server software. It was just an exciting holiday project.

I did run my own NNTP server for a couple of years, using the INN software on a dedicated, powerful server stacked with lots of hard disks, and peering with a handful of other NNTP servers around the world. My plan was to swap it out with my own server at some point, but it never happened.

Some things I wrote because I needed them

NFS server

NFS, or Network File System, is a distributed file system developed by Sun Microsystems in 1984. There’s a server on a machine somewhere that provides the contents of its local disk over an RPC protocol, and a client on your machine connects to that server over UDP. The client then presents the server’s file system as its own, so you can use it like any other local file system.

I became familiar with Sun’s RPC interfaces when I needed a protocol between the War FTP Daemon and its user interface. Those were two separate programs, and they could run on different machines. I didn’t like Microsoft’s overengineered (and, as we know today, deeply flawed from a security perspective) RPC alternative, so I ported Sun’s open-source code generator tool and libraries to Windows just for the War FTP Daemon. I even got an official ID from Sun for WarFTP’s actual RPC management protocol.

When I started using Linux and FreeBSD alongside Windows for my software projects, I was distracted by two things. First, I made rapid changes on all three platforms, and even though I had source control (CVS) - this was long before Git was born, even before Subversion - I found it annoying to commit many times per hour just to check if something compiled on all three platforms. Second, the Microsoft compiler insisted on code being in CR/LF (Windows text file format), while my tools on the “real” operating systems didn’t like that. To solve both problems, I wrote myself an NFS server.

It kept the source code on the disk where the NFS server was running and automatically mapped CR to CR/LF in data going to my Windows machines. I could edit my code on any of the machines, and changes were saved immediately by the NFS server. Since I was the only user, there were no issues with conflicting concurrent changes or file locking. As far as I remember, the NFS server ran under any of my operating systems.

WarMon

At some point, I ended up being responsible for a room full of servers for a local IT company in my hometown. I don’t remember exactly when, but it must have been before or around the year 2000. The internet was still young, and most companies didn’t have their own “fast” connections. Most homes and offices used ISDN modems, which were neither particularly fast nor reliable. So many companies ran their servers in colocations.

This particular company had a fast internet connection and happened to sell servers and PCs to local businesses. So it was good business to first sell the servers, then collect rent for running and maintaining the machines. The maintenance part included keeping the machines up to date with security patches and in good health. Most, if not all, of the machines were running Linux or Windows.

I wrote software to continuously monitor the health of the machines. It consisted of an agent running on the machines, a server running on a Linux system, and a Windows app I ran on my PC. The agents ran on both Linux and Windows. They kept an eye on the system, local logs, specific programs, disk usage, RAID status, etc. They maintained an open TCP connection to the server and sent frequent updates about the machine’s health and state. The server updated its map of all machines so the UI app could show real-time status. It also had an alert manager that evaluated all state changes and sent emails and SMS messages about anything requiring attention or immediate intervention (this was long before push notifications existed). Pretty much what I do today with Prometheus, various agents, and Grafana.

Everything was written in C++. It was a fun project, and quite useful.

SnmpMon

I think one of the first HTTP servers I ever implemented from scratch (as in, directly using the C sockets API) was part of SnmpMon. SNMP is used for collecting device statistics, monitoring performance, detecting faults, and sometimes remote configuration on network devices like routers and professional switches. Some servers can also be configured to expose data via SNMP, and even individual applications sometimes support it.

It caught my interest when I was responsible for that room full of servers. We had some expensive switches and a router, so I had the perfect excuse to spend a few weeks hacking together a monitoring tool. This time around, I didn’t want to mess with a GUI application to view the data. Instead, I wrote an embedded HTTP server and presented the UI using HTML and standard forms.

I could scan for devices, and they would show up as the app found them. Or I could enter an IP address and port, and the app would connect directly to the device and display a new dynamic webpage with available metric points presented visually as a tree - similar to a file manager. When I clicked on a node, it would show whatever data it contained on the right side of the window.

A cool thing about this application was that I could run it on my desktop and then walk into a colleague’s office (we used real offices, not cubicles) and access the UI from her web browser. Nothing special today, but it raised eyebrows back then. The application was, of course, written in C++.

SNMP is pretty much forgotten today, but it’s still available. And, designed by smart people, it uses a fraction of the CPU and network bandwidth of today’s shiny tools. When I wrote a DNS server a few years ago, I considered using SNMP for metrics. However, I ended up using OpenMetrics because I was already using Prometheus to collect data from VMs and Docker containers.

WHID

I’ve always struggled with productivity. In my younger days, it was a complete mystery to me where the time went. I was working a lot on various projects, yet I felt progress was slow - and days, weeks, and months just vanished. In 1998, I spent a few months writing a small program called wtm, in C++/STL, to track my time usage. I learned the C++ template library and used the native Win32 API for the user interface.

In the spring of 2006, I read the book User Interface Design by Søren Lauesen, and a single illustration in that 600-page brick inspired me to think about a new time-tracking application. Wtm could do a lot, but it couldn’t give me a quick summary of my current status. I renamed the project to What Have I Done (WHID) and released the application as open source in December 2006. It supported MySQL and SQLite for data storage, used wxWidgets for the GUI, and I was quite happy with it - especially since I had long ago switched to Linux on my desktop and really hungered for a native Linux version.

In 2018, I asked myself: can I re-implement a working version of WHID using Qt, in just one week? I actually challenged myself. I had never written a Qt desktop application before, so it was also a nice opportunity to learn something new. The answer was yes! So instead of doing what I was supposed to do, I spent one week re-implementing WHID, having a great time - just like I did in 1998 and 2006. Few things give me more pleasure than writing great software that I truly need for my own use.

In 2025, I reimplemented and significantly improved the same ideas and functionality in my new productivity app: NextApp.

Keeping a project going through four implementations over 27 years says something about how important this is to me.

One thing I wrote out of pure love

DarkSpeak

One thing that has always been important to me is privacy. It was the core value handed down to me by my father. In today’s society, there are very few opportunities to have private conversations using any kind of technology. All telecom protocols and most messaging providers are required by law (or pressured by governments) to give authorities full access to listen in on any conversations they care about.

Even for peer-to-peer encrypted apps, they still require access to metadata, like who is communicating with whom, and when. There are many problems with this, ranging from the philosophical - “Why is the government terrified of its citizens having private conversations?” - to the technical; where hackers gain access to these tap points to eavesdrop and extract data. One known example of the latter is the so-called “Salt Typhoon” campaign, first detected in mid-2024, in which Chinese state-linked hackers apparently targeted the very network elements US and allied governments use to conduct lawful intercepts - the “backdoors” mandated for wiretapping - across multiple telecom operators.

There is also a constant push from Democracies In Name Only, like the UK, various EU countries, and the US, to install similar tap points in all online encrypted peer-to-peer communication. Similar efforts, often using the same “protecting the children” excuse, aim to mandate identifiable online identities across all kinds of social media. (We just have to look at Gaza, and the poverty in their own streets, to see how much those governments really care about children.)

In my opinion; privacy and free speech - including anonymous free speech - is an absolute requirement for a functioning democracy.

I’ve seen this coming for decades. This was, after all, one of my father’s deepest concerns and fears. In 2016, I started a project to create a secure peer-to-peer messaging app using the Tor network: DarkSpeak. The architecture had no central servers, no single point where any government could inject a tap.

I used Qt, and the idea was to make a secure app for Linux and less secure version for Windows and Android (we can't expect any real privacy on Android or Windows). At some point, the app was working - and pretty nicely. Then I changed the build configuration from Qt .pro files to standard CMake. That broke lots of things - interestingly, it broke how some binary buffers behaved in C++.

At that point - now in 2020 - I thought hard about the project. I was working intensely for a startup and had less time than usual for side projects. I was also fearful about being targeted by Europol (a police force that already, back then, had far too much power) or by some intelligence agency, simply for making an app that makes strong privacy even possible. We all know how easy it is for governments to make anyone’s life far from joyful.

I decided to postpone further work on this project - for now. If and when I ever feel strong enough - and willing to lose everything - I will finish it.

It’s a pity, because DarkSpeak is the one project I care most deeply about.

Other stuff?

Yes, I have made and contributed to many exiting projects. I will sit down and tell you about them as time permits...