Welcome. This post is to help establish the tone I want to set going forwards and give some background as to the tech stack used to produce this website/blog.

I've tried to keep the site simple while providing some of the useful features you'd want when writing posts. The less friction there is, the more likely I'll write something up. The vast majority of the tooling used is Free/Libre and Open Source Software (FLOSS) and I invite you to check them out. In the future I will also write more detailed posts on some of these tools, and content such as "getting started" guides.

The overview

Here I'll list out some core aspects and tools that cumulate to produce this blog.

• Markdown - The language/syntax
• Zola - The static site generator
• Nix - The functional package manager
• cspell - A code-friendly spellchecker
• Cloudflare Pages - The hosting platform
  • Wrangler - The deployment tool

Writing in Markdown

At its core, a blog is about content. For me, the most natural way to write that content is in Markdown. Markdown is simple, plain text, and highly portable. It doesn't lock me into a proprietary system, and it integrates well with any text editor. Whether I'm working in a terminal-based editor like NeoVim or a GUI tool, Markdown just works.

Markdown is also future-proof. Since it's plain text, I can archive or migrate my content easily, without worrying about complex formats or breaking compatibility. Writing in Markdown allows me to focus on the content itself without distractions.

Static Site Generation with Zola

To turn the Markdown files into a functional website, I use Zola, a static site generator written in Rust. Zola is designed to be fast, simple, and reliable, and it embodies many of the qualities I value in software. It doesn't require a runtime, which means there's no need for server-side processing—everything is pre-built. This simplicity ensures that the resulting site is lightweight and fast to load.

Zola also strikes a good balance between flexibility and usability. Its theming system allows for extensive customization without unnecessary complexity. While I've kept the design minimal for now, I appreciate knowing that I can adapt it as the blog evolves. The speed of Zola is also worth mentioning: generating the entire site takes milliseconds, even with additional content.

Hugo is very similar and a tool I've used many times personally and professionally. It's very popular, and for good reason, but I decided to mix things up and learn some new things with Zola.

Development Dependencies with Nix

With the tools and technologies listed it's useful to have a way to grab them all easily and keep them updated. To handle this, I use Nix, a functional package manager that focuses on reproducibility and declarative configuration. With Nix I can define a development environment that includes all the necessary tools in a single file.

This approach eliminates setup headaches. Whether I'm working on my primary machine or setting up a new system, I can recreate the exact dev-env with a single command. Nix also ensures that dependencies are isolated and don't interfere with other projects, which is invaluable for maintaining a clean and predictable workflow.

The functional, declarative, and reproducible nature of Nix is what originally appealed to me as a developer. It didn't take long for me to expand from using it to manage my development environments, to packaging a few extra things here-and-there, to moving to NixOS, and becoming a nixpkgs maintainer. More to come on this in a future post.

Spellchecking with cspell

I am quite terrible at spelling. To speed up my workflow and avoid mistakes and typos, like almost everyone I use a spellchecker. In this case I use cspell as it integrates well with Markdown and most other code and it's fully local.

While it's a relatively small tool in the stack, cspell reflects an important principle: focusing on quality. Spellchecking ensures that the content is polished and professional, without unnecessary distractions. With most content I write, whether it's Go, TypeScript, PSQL, or prose, I ask myself "Do I have a linter, and if not, can I find one". Fundamentally spellcheckers are linters for prose. There are some more advanced "linters" for prose like Vale, Proselint, and LanguageTool to name a few I've played with in the past, but I'm not using anything beyond cspell currently.

Deployment to Cloudflare Pages

There's not much point writing content if no one can access it so next is deployment. With static sites there are a vast number of options but in this case I chose Cloudflare Pages. I'm pretty flexible on where to deploy the site but I chose Cloudflare Pages since its free and if Cloudflare is down, most other things will be down. Also the wrangler cli does make it pretty easy to make ad-hoc deployments from my machine.

I could host the site on my own infrastructure but for a blog there's not much benefit in taking on the cost of VMs (or at least electricity at home) and the upkeep and hardening of an internet facing machine. I'm kept plenty busy

Why This Stack?

Every tool in this stack was chosen with intention. Zola, Nix, cspell, and Cloudflare Pages are all examples of software that prioritize efficiency, reliability, and openness. These tools complement each other, creating a streamlined workflow that lets me focus on the content rather than the mechanics of publishing.

This stack also reflects my values as a developer. I prioritize tools that respect users' freedom and avoid proprietary lock-in. By using FLOSS tools wherever possible, I not only benefit from their flexibility and transparency but also contribute to a broader ecosystem that values openness and collaboration.

At the same time, I believe in keeping things simple. A static site doesn't require complex infrastructure, and this minimalism is a strength. It ensures that the blog is fast, secure, and easy to maintain, without unnecessary overhead and less to go wrong.

What's Next?

With the technical setup in place, the focus now shifts to content. I'm excited to use this space to share insights, experiments, and experiences from my work as a developer. If you're interested in cloud, cloud-native development, programming in Go, Rust, TypeScript, or exploring Free/Libre and Open Source Software, stay tuned—there's much more to come.

Thank you for reading, and welcome to the blog. If you'd like to follow updates, consider adding the atom feed to your RSS reader. It may also help you to know you can browse posts by tags and can find atom feeds for individual tags.