From c26c66038406c0fb05cc05060f5ecf5340b7d9fd Mon Sep 17 00:00:00 2001
From: Matthias <matthias@endler.dev>
Date: Wed, 23 Sep 2026 12:03:33 +0200
Subject: [PATCH] Fix blog headline capitalization and typos

---
 content/2009/running-legacy-code/index.md     |  4 +-
 .../index.md                                  |  6 +-
 content/2011/are-you-a-programmer/index.md    |  2 +-
 content/2017/boxes-and-trees/index.md         |  6 +-
 content/2017/digitial-clocks/index.md         |  4 +-
 content/2017/future-of-rust/index.md          |  4 +-
 content/2017/go-vs-rust/index.md              | 12 ++--
 content/2017/hacktoberfest/index.md           | 14 ++---
 content/2017/image-previews/index.md          |  2 +-
 content/2017/makefiles/index.md               | 12 ++--
 content/2017/obsolete/index.md                | 10 ++--
 .../2017/professional-programming/index.md    | 14 ++---
 content/2017/rust-for-rubyists/index.md       | 12 ++--
 content/2017/rust-url-shortener/index.md      | 18 +++---
 content/2017/why-i-love-programming/index.md  | 16 +++---
 content/2017/why-type-systems-matter/index.md | 10 ++--
 content/2017/yes/index.md                     |  6 +-
 content/2018/cargo-inspect/index.md           | 12 ++--
 content/2018/excel/index.md                   |  2 +-
 content/2018/fastcat/index.md                 |  8 +--
 content/2018/functional-mathematics/index.md  | 14 ++---
 content/2018/github/index.md                  | 10 ++--
 content/2018/go-io-testing/index.md           |  6 +-
 content/2018/keyboard/index.md                | 10 ++--
 content/2018/ls/index.md                      | 14 ++---
 content/2018/rust-2018/index.md               | 10 ++--
 content/2018/ten-years-of-vim/index.md        |  6 +-
 .../maybe-you-dont-need-kubernetes/index.md   |  6 +-
 content/2019/tinysearch/index.md              |  8 +--
 content/2020/cratesio/index.md                |  6 +-
 content/2020/folklore/index.md                | 18 +++---
 content/2020/go-is-not-simple/foo.md          |  6 +-
 content/2020/go-is-not-simple/index.md        | 12 ++--
 content/2020/perf/index.md                    | 12 ++--
 content/2020/review/index.md                  | 14 ++---
 content/2020/sponsors/index.md                |  6 +-
 content/2020/timelapse/index.md               |  2 +-
 content/2020/unix-microservices/index.md      |  6 +-
 content/2021/codeprints/index.md              |  8 +--
 content/2021/first-business/index.md          |  2 +-
 content/2021/history/index.md                 | 14 ++---
 content/2021/oss-money/index.md               |  2 +-
 content/2021/sleep/index.md                   | 14 ++---
 content/2021/uber-of-poland/index.md          |  2 +-
 content/2022/alloc/index.md                   | 56 +++++++++----------
 content/2022/look/index.md                    |  4 +-
 content/2022/zerocal/index.md                 | 16 +++---
 content/2023/cursed-rust/index.md             |  8 +--
 content/2023/move-fast-rust/index.md          |  4 +-
 content/2024/asking-better-questions/index.md | 18 +++---
 content/2024/follow-the-hackers/index.md      |  4 +-
 .../2024/move-slow-and-fix-things/index.md    |  2 +-
 content/2024/no-matter-what/index.md          |  6 +-
 content/2024/selling-to-developers/index.md   |  8 +--
 content/2024/the-dying-web/index.md           |  8 +--
 content/2025/best-programmers/index.md        |  4 +-
 .../building-up-and-sanding-down/index.md     |  2 +-
 content/2025/how-to-review-code/index.md      | 20 +++----
 content/2025/reinvent-the-wheel/index.md      |  2 +-
 content/2025/repeat-yourself/index.md         | 10 ++--
 .../2026/advice-to-young-developers/index.md  |  2 +-
 .../index.md                                  |  2 +-
 .../how-other-link-checkers-recurse/index.md  | 32 +++++------
 content/2026/lychee-recursion/index.md        |  4 +-
 content/2026/newsletter-setup/index.md        |  2 +-
 content/2026/personal-blog/index.md           |  2 +-
 content/2026/taste/index.md                   |  2 +-
 .../index.md                                  |  2 +-
 68 files changed, 301 insertions(+), 301 deletions(-)

diff --git a/content/2009/running-legacy-code/index.md b/content/2009/running-legacy-code/index.md
index c1074924..3816a38d 100644
--- a/content/2009/running-legacy-code/index.md
+++ b/content/2009/running-legacy-code/index.md
@@ -8,7 +8,7 @@ tags=["dev"]
 This short article deals with a severe problem in software development: bit rot.
 When switching to a new platform (for instance from Windows XP to Windows Vista/7), the programmers need to make sure that old bits of code run flawlessly. There are several ways to achieve this goal that will be discussed in the next paragraphs:
 
-## Porting the code
+## Porting the Code
 
 This is generally considered a hard path to follow. For non-trivial legacy code-blocks, chances are high that they contain side-effects and hacks to make them work in different environments. Porting code means replacing parts of the program that use functions and methods that don't exist anymore with new ones which make use of the modern libraries&nbsp; and routines of the new platform. The significant advantages are maintainable software and sometimes faster running programs. But it may be needed to hack the new platform libraries in order to preserve the whole functionality of an old application. When changing an algorithm inside legacy code, the ported version may become unstable. Thus there may be better ways of maintaining obsolete code today.
 
@@ -16,7 +16,7 @@ This is generally considered a hard path to follow. For non-trivial legacy code-
 
 Emulators work much the same like porting the code. You replace old function calls with new ones to make everything work again. <br />However you don't alter the old codebase itself (because you may not have the source code available) but you create a new compatibility layer that "translates" the communication between the underlying operating system and software (our new platform) and our old software. Emulation can also be very fast and run stable for many years but writing an emulator can be even harder than porting the code because an educational guess may be needed to figure out how the program works internally. Additionally, the emulator itself may become obsolete in the future and might eventually&nbsp; be replaced by a new one.
 
-## Virtual machines
+## Virtual Machines
 
 During the last years, a new approach was gaining popularity. The idea is simple: Don't touch anything. Take the whole platform and copy it in order to run old software. The old software runs on top of the old operating system within a virtual machine that runs on the new platform.
 
diff --git a/content/2010/howto-sort-a-vector-or-a-list-in-c-using-stl/index.md b/content/2010/howto-sort-a-vector-or-a-list-in-c-using-stl/index.md
index f1be98f7..6fbeb0b9 100644
--- a/content/2010/howto-sort-a-vector-or-a-list-in-c-using-stl/index.md
+++ b/content/2010/howto-sort-a-vector-or-a-list-in-c-using-stl/index.md
@@ -1,5 +1,5 @@
 +++
-title="Howto Sort a Vector or a List in C++ using STL"
+title="How to Sort a Vector or a List in C++ Using STL"
 date=2010-01-27
 [taxonomies]
 tags=["dev"]
@@ -104,7 +104,7 @@ int main() {
 }
 ```
 
-## Compilation and execution
+## Compilation and Execution
 
 Save the above code inside a file, e.g. `list_vector.cpp` and compile it like so:
 
@@ -118,7 +118,7 @@ To run it, execute the resulting binary.
 ./a.out
 ```
 
-## Program output
+## Program Output
 
 ```
 Vector: 12 5 1
diff --git a/content/2011/are-you-a-programmer/index.md b/content/2011/are-you-a-programmer/index.md
index f6ef10e7..c6004ff3 100644
--- a/content/2011/are-you-a-programmer/index.md
+++ b/content/2011/are-you-a-programmer/index.md
@@ -1,5 +1,5 @@
 +++
-title="Are you a Programmer?"
+title="Are You a Programmer?"
 date=2011-10-20
 [taxonomies]
 tags=["culture", "dev"]
diff --git a/content/2017/boxes-and-trees/index.md b/content/2017/boxes-and-trees/index.md
index d2c7889f..e5121411 100644
--- a/content/2017/boxes-and-trees/index.md
+++ b/content/2017/boxes-and-trees/index.md
@@ -122,13 +122,13 @@ Therefore we would need to add lifetime parameters here. This can make it tediou
   }
   ```
 
-## Putting the tree into a box
+## Putting the Tree into a Box
 
 All three options are totally valid. Which one you should choose, depends on your use-case.
 A rule of thumb is to keep it simple.
 In my case, I chose to use a `Box`, because I did not need any special guarantees.
 
-## Making subtrees optional
+## Making Subtrees Optional
 
 The next problem I faced was that I could not instantiate a tree structure.
 The left and right subtree have the type `Box<Tree>`, but at some
@@ -241,7 +241,7 @@ root(15)
   );
 ```
 
-## Why did it just work in Python?
+## Why Did It Just Work in Python?
 
 Now you might be wondering why our tree implementation worked so flawlessly in Python.
 The reason is that Python *dynamically* allocates memory for the tree object at *runtime*.
diff --git a/content/2017/digitial-clocks/index.md b/content/2017/digitial-clocks/index.md
index 3178d46f..c4696a38 100644
--- a/content/2017/digitial-clocks/index.md
+++ b/content/2017/digitial-clocks/index.md
@@ -16,7 +16,7 @@ As a result I didn't set the correct time, instead, I set a cooking timer... and
 
 {{ <figure page={page} src="kitchen.svg" /> }}
 
-## Let's add a clock to the microwave!
+## Let's Add a Clock to the Microwave!
 
 On occasions like these, I wonder why there's a digital clock on every single household device these days.
 They're integrated into microwaves, fridges, ovens, dishwashers, dryers, mixers &mdash; and that's just the kitchen!
@@ -44,7 +44,7 @@ That's why I constantly need to look after those clocks.
 Let me tell you a secret:
 When I'm not warming stuff in the oven, I don't want it to tell me the local time. I want the stove to be _off_.
 
-## Why I have trouble setting the clock on our oven
+## Why I Have Trouble Setting the Clock on Our Oven
 
 Our oven has three buttons related to time: plus, minus and a clock symbol.
 To set the time, you push the clock symbol. An arrow appears and the display changes to 00:00. You press time again and another arrow appears.
diff --git a/content/2017/future-of-rust/index.md b/content/2017/future-of-rust/index.md
index d67ed4b4..ce1dca17 100644
--- a/content/2017/future-of-rust/index.md
+++ b/content/2017/future-of-rust/index.md
@@ -40,7 +40,7 @@ It is not unthinkable that Rust is going to be some healthy competition for C++
 The benchmarks of [leaf](https://github.com/autumnai/leaf), a machine learning library written in Rust, are already nothing short of
 impressive.
 
-## Blockbuster games
+## Blockbuster Games
 
 [Games](https://www.reddit.com/r/rust_gamedev/comments/4qlftu/look_our_game_writen_entirely_in_rust/d4tz4r3/) are another area where Rust might shine.
 It's financially attractive for Game Studios to support multiple platforms without much
@@ -57,7 +57,7 @@ That said, the first AAA Rust game might still be far in the future. [Here's Bli
 Maybe &mdash; eventually &mdash; we will also see formal verification of the Rust core. Projects like [RustBelt](https://plv.mpi-sws.org/rustbelt/) would then open new opportunities in safety-focused industries like the Space industry. Wouldn't it be nice to safely land a Spacecraft on Mars that is controlled by Rust? (Or by one of its spiritual successors.)
 I wonder if [SpaceX](https://www.spacex.com/) is experimenting with Rust already...
 
-## Integrating with other languages
+## Integrating with Other Languages
 
 There are many other areas I haven't even mentioned yet. For example, financial and medical software or Scientific Computing, just to name a few.
 In all cases, Rust might be a good fit. Right now the biggest barrier to entry
diff --git a/content/2017/go-vs-rust/index.md b/content/2017/go-vs-rust/index.md
index 7cff7f2c..a71435a6 100644
--- a/content/2017/go-vs-rust/index.md
+++ b/content/2017/go-vs-rust/index.md
@@ -36,7 +36,7 @@ Shuttle 🚀
 Both languages seem to be competing for the same user base and they both seem to be
 _systems programming_ languages, so there must be a clear winner, right?
 
-## Go: practical, pragmatic, plain
+## Go: Practical, Pragmatic, Plain
 
 {{ <figure page={page} src="go.jpg" caption="The Golang learning curve over time, a straight line." /> }}
 
@@ -47,7 +47,7 @@ But with Go, you _get things done_ &mdash; fast.
 Go is one of the most productive languages I've ever worked with.
 The mantra is: solve real problems today.
 
-## Rust's strong guarantees come at a cost
+## Rust's Strong Guarantees Come at a Cost
 
 {{ <figure page={page} src="rust.jpg" caption="The Rust learning curve over time, a bumpy ride." /> }}
 
@@ -70,7 +70,7 @@ That's because these guarantees come with a cost: ramp-up time.
 You'll need to unlearn bad habits and learn new concepts.
 Chances are, you will [fight with the borrow checker](https://m-decoster.github.io/2017/01/16/fighting-borrowchk/) a lot when you start out.
 
-## Case-study: Primality by trial division
+## Case-Study: Primality by Trial Division
 
 Let's say, you want to check if a number is [prime](https://en.wikipedia.org/wiki/Prime_number).
 The easiest way is to check if we can divide the number by any smaller natural number (without a remainder). If not, we found a prime number! This approach is called [trial division](https://en.wikipedia.org/wiki/Trial_division).
@@ -136,14 +136,14 @@ It might seem a little alien at first, but it will become second-nature after a
 
 This was just a quick example, of course. I suggest, you browse some code on [Rosetta Code](https://rosettacode.org/wiki/Rosetta_Code) to get a better feeling for both languages.
 
-## Case study: Finding duplicate words in text files
+## Case Study: Finding Duplicate Words in Text Files
 
 If you're more like a visual type, here is a video where I write a simple
 concurrent program in Go and Rust to compare both languages:
 
 {{ <video url="https://www.youtube.com/embed/B5xYBrxVSiE" preview="maxresdefault.jpg" /> }}
 
-## Some things I prefer in Go
+## Some Things I Prefer in Go
 
 - Fast compile times
 - Pragmatic problem-solving approach
@@ -153,7 +153,7 @@ concurrent program in Go and Rust to compare both languages:
 - Simple error handling
 - The mascot 😉
 
-## Some things I prefer in Rust
+## Some Things I Prefer in Rust
 
 - Safety: No null pointers, no data races,...
 - Fine-grained system control
diff --git a/content/2017/hacktoberfest/index.md b/content/2017/hacktoberfest/index.md
index 2f301d4f..f4d7bdc6 100644
--- a/content/2017/hacktoberfest/index.md
+++ b/content/2017/hacktoberfest/index.md
@@ -1,5 +1,5 @@
 +++
-title="Learn Some Rust During Hacktoberfest"
+title="Learn Some Rust during Hacktoberfest"
 date=2017-10-15
 [taxonomies]
 tags=["culture", "dev", "oss", "rust"]
@@ -21,7 +21,7 @@ This guide is trying to change that!
 Let me show you, how _everybody_ can contribute code to [Rust](https://www.rust-lang.org/), a safe systems programming language.
 I was inspired to write this by a [tweet from llogiq](https://twitter.com/llogiq/status/915288482314178560).
 
-## 1. Find a great Rust project to work on
+## 1. Find a Great Rust Project to Work On
 
 We all want our work to be appreciated.  
 Therefore I suggest to start contributing to medium-sized projects, because they gained some momentum but are still driven by a small number of maintainers, so help is always welcome. By contrast, tiny projects are mostly useful to the original author only, while large projects can be intimidating at first and have stricter guidelines.
@@ -35,7 +35,7 @@ language:Rust stars:5..100 pushed:>2017-01-01
 
 [Here](https://github.com/search?q=language%3ARust+stars%3A5..100+pushed%3A%3E2017-01-01)'s a list of projects, which match this filter.
 
-## 2. Install the Rust toolchain
+## 2. Install the Rust Toolchain
 
 To start contributing, we need a working Rust compiler and the cargo package manager.
 Fortunately, the installation should be straightforward.
@@ -56,7 +56,7 @@ rustup install nightly
 
 Questions so far? Find more detailed installation instructions [here](https://asquera.de/blog/2017-03-03/setting-up-a-rust-devenv/).
 
-## 3. Fork the project and clone it to your computer
+## 3. Fork the Project and Clone It to Your Computer
 
 First, click on the little _fork_ button on the top right of the Github project page. Then clone your fork to your computer.
 
@@ -66,7 +66,7 @@ git clone git@github.com:yourusername/project.git
 
 For more detailed instructions, go [here](https://guides.github.com/activities/forking/).
 
-## 4. Does it build?
+## 4. Does It Build?
 
 Before we start modifying the codebase, we should make sure that it is in a workable state.
 The following commands should work right away from inside the project folder.
@@ -78,7 +78,7 @@ cargo test
 
 If not, you might want to consult the `README` for further instructions. (But feel free to choose another project.)
 
-## 5. The magic sauce
+## 5. The Magic Sauce
 
 Here's the trick: we use a [linter](<https://en.wikipedia.org/wiki/Lint_(software)>) called [clippy](https://github.com/rust-lang/rust-clippy) to show us improvement areas in any Rust codebase.
 
@@ -138,7 +138,7 @@ Please add a meaningful description and then submit the pull request.
 
 Congratulations! You've contributed to the Rust ecosystem. Thank you! 🎉
 
-## Trophy case
+## Trophy Case
 
 - [m4b/goblin](https://github.com/m4b/goblin/pull/55)
 - [fitzgen/cpp_demangle](https://github.com/gimli-rs/cpp_demangle/pull/100)
diff --git a/content/2017/image-previews/index.md b/content/2017/image-previews/index.md
index 85d3d4d6..3931bf04 100644
--- a/content/2017/image-previews/index.md
+++ b/content/2017/image-previews/index.md
@@ -31,7 +31,7 @@ I could fix that, by hardcoding the image width and height, but that would be te
 And there would be no preview.
 So I was wondering, what others were doing. 🤔
 
-## Tiny image thumbnails
+## Tiny Image Thumbnails
 
 I vaguely remembered, that [Facebook uses tiny preview thumbnails in their mobile app](https://code.fb.com/uncategorized/the-technology-behind-preview-photos/).
 They extract the quantization table from the JPEG header to render the preview. This information
diff --git a/content/2017/makefiles/index.md b/content/2017/makefiles/index.md
index 9e972a90..625ef8b2 100644
--- a/content/2017/makefiles/index.md
+++ b/content/2017/makefiles/index.md
@@ -1,5 +1,5 @@
 +++
-title="Afraid of Makefiles? Don't be!"
+title="Afraid of Makefiles? Don't Be!"
 date=2017-08-15
 updated=2022-03-01
 [taxonomies]
@@ -38,7 +38,7 @@ Along the way, they keep making the same basic mistakes:
 
 These are issues Makefiles were invented to solve.
 
-## Makefiles are scary!
+## Makefiles Are Scary!
 
 If you think that `make` is scary, you probably think of complicated build machinery for [big](https://community.kde.org/Guidelines_and_HOWTOs/Build_from_source) [software](https://chromium.googlesource.com/chromium/src/+/master/docs/linux/build_instructions.md) projects.
 It doesn't need to be that way. Let's hear from the author of `make`, [Stuart Feldman](https://en.wikipedia.org/wiki/Stuart_Feldman) himself:
@@ -47,9 +47,9 @@ It doesn't need to be that way. Let's hear from the author of `make`, [Stuart Fe
 >
 > &mdash; [The Art of Unix Programming (2003)](https://nakamotoinstitute.org/static/docs/taoup.pdf)
 
-Make was built in _one weekend_ to solve a reoccuring problem in a simple way.
+Make was built in _one weekend_ to solve a reoccurring problem in a simple way.
 
-## Makefiles are simple!
+## Makefiles Are Simple!
 
 Before I leave the house, I need to get dressed.
 I use the same simple routine every time:
@@ -100,7 +100,7 @@ Putting on jacket.
 All done. Let's go outside!
 ```
 
-## What just happened?
+## What Just Happened?
 
 Noticed how the steps are in the correct order?
 By plainly writing down the dependencies between the steps, `make` helps us to execute them correctly.
@@ -130,7 +130,7 @@ target: [dependencies]
 
 Congratulations! You've learned 90% of what you need to know about `make`.
 
-## Next steps
+## Next Steps
 
 Real `Makefiles` can do much more! They will [only build the files that have changed](https://stackoverflow.com/a/3798609/270334) instead of doing a full rebuild.
 And they will do [as much as possible in parallel](https://stackoverflow.com/a/3841803/270334).
diff --git a/content/2017/obsolete/index.md b/content/2017/obsolete/index.md
index 2302e8f1..64c28d7b 100644
--- a/content/2017/obsolete/index.md
+++ b/content/2017/obsolete/index.md
@@ -42,7 +42,7 @@ There was one problem though: The list of pull requests got longer and longer, a
 
 {{ <figure page={page} src="pull_requests.jpg" caption="The list of Github Pull requests for awesome-static-analysis" /> }}
 
-## Adding contributors
+## Adding Contributors
 
 I always try to make team members out of regular contributors. My friend and colleague [Andy Grunwald](https://github.com/andygrunwald) as well as [Ouroboros Chrysopoeia](https://github.com/impredicative) are both valuable collaborators. They help me weed out new PRs whenever they find the time.
 
@@ -57,7 +57,7 @@ What needs to be checked for each new tool can be summarized like this:
 
 I guess it's obvious what we should do with that checklist: automate it!
 
-## A linter for linting linters
+## A Linter for Linting Linters
 
 So why not write an analysis tool, which checks our list of analysis tools!
 What sounds pretty meta, is actually pretty straightforward.
@@ -108,7 +108,7 @@ This allowed me to focus on the actual analysis code,
 which makes for a pretty boring read. It mechanically checks for the things mentioned above and could be written in any language.
 If you want to have a look (or even contribute!), [check out the repo](https://github.com/mre/awesome-static-analysis-ci).
 
-## Talking to Github
+## Talking to GitHub
 
 After the analysis code was done, I had a bot, running locally, waiting for incoming pull requests.
 
@@ -247,7 +247,7 @@ Now, whenever a new pull request is coming in, you see that little bot getting a
 
 ![A successful pull request, which was checked by the bot](/2017/obsolete/pull_request_success.jpg)
 
-## Outcome and future plans
+## Outcome and Future Plans
 
 I am very pleased with my choice of tools: afterparty saved me from a lot of manual work, while zeit made deployment really easy.  
 It feels like [Amazon Lambda](https://aws.amazon.com/lambda/features/) on steroids.
@@ -266,7 +266,7 @@ If you like, you can compare the [old](https://github.com/mre/awesome-static-ana
 
 Most everything about that project has changed since then.
 I now use Github Actions to run the CI checks, and the `README.md` is completely auto-generated from the YAML files for each tool.
-We support specia metadata fields like a list of additional resources (tutorials, videos, etc) or the list of paid plans a tool offers.
+We support special metadata fields like a list of additional resources (tutorials, videos, etc) or the list of paid plans a tool offers.
 We have a [fancy website](https://analysis-tools.dev/) now, where we list all 700+ tools and allow people to vote.
 The website is built with Next.js and uses Algolia for search.
 We also have a bunch of sponsors now, who help us pay for hosting and other expenses.
diff --git a/content/2017/professional-programming/index.md b/content/2017/professional-programming/index.md
index 277881e1..153e772a 100644
--- a/content/2017/professional-programming/index.md
+++ b/content/2017/professional-programming/index.md
@@ -18,7 +18,7 @@ This article aims to save you from a few years of uncertainty.
 
 Before you dig into this, be sure to read the first part of this series titled ["Why I love Programming"](@/2017/why-i-love-programming/index.md).
 
-## What's the difference between "professional" and "hobby" programming?
+## What's the Difference between "professional" and "hobby" Programming?
 
 In one word: _accountability_.  
 You are expected to be responsible.
@@ -44,7 +44,7 @@ Eventually, you'll understand that those neckbeards were not slower than you, bu
 more careful. You learn how to test your code, how to document it. You even begin to
 appreciate UML diagrams.
 
-## Becoming obsolete
+## Becoming Obsolete
 
 "The world is moving too fast. What you learned today is obsolete tomorrow. Why bother?".
 I've heard that saying countless times throughout my career.
@@ -63,7 +63,7 @@ One advice I can give you is not to take it too seriously.
 Drop the project, keep the wisdom.
 Embrace change.
 
-## Writing software in a non-perfect world
+## Writing Software in a Non-Perfect World
 
 A professional programmer has to deal with deficiencies all the time. The game is called "balancing constraints". Deadlines, budgets, and code quality are just a few competing constraints we have to consider.
 Elegant designs fade away in the face of reality.
@@ -77,12 +77,12 @@ For me, I was always leaning more towards elegance.
 That's just a nicer way to say I was a perfectionist.
 I needed to learn the pragmatic part through hard work.
 
-## Mentoring less experienced Programmers
+## Mentoring Less Experienced Programmers
 
 > The better you become at programming, the less you code.
 
 Instead, you will spend more time thinking about Software Architecture,
-high-level designs and splitting up the work into smaller junks for other developers to consume.
+high-level designs and splitting up the work into smaller chunks for other developers to consume.
 You will start mentoring Junior Developers. Recruiting will require a lot of your
 attention. You will spend your time in Meetings, discussing project goals with
 business people.
@@ -107,7 +107,7 @@ Talk to others, listen to their problems. Read books about Software Project
 Management, even though you don't want to be a manager yourself. It will help
 you understand the role of your boss.
 
-## A word about money
+## A Word about Money
 
 There are many good reasons to work in IT, but money is not one of them.
 
@@ -124,7 +124,7 @@ attempts.
 Another way is to stop being a programmer and become a manager instead.
 I've already shared my opinion on that in the last section.
 
-## Final words
+## Final Words
 
 While you should learn to read (and maybe write) code, working as a professional programmer is not for everyone.
 You might ask: "Is it worth it?".
diff --git a/content/2017/rust-for-rubyists/index.md b/content/2017/rust-for-rubyists/index.md
index cc3a3949..7d74a52f 100644
--- a/content/2017/rust-for-rubyists/index.md
+++ b/content/2017/rust-for-rubyists/index.md
@@ -131,7 +131,7 @@ for lang in ["Ruby", "Rust", "Python", "Cobol"].iter() {
 
 </a>
 
-## Select and filter
+## Select and Filter
 
 Let's say you want to extract only even numbers from a collection in Ruby.
 
@@ -280,7 +280,7 @@ The `filter_map` is similar to the `select` method in Ruby:
 [1, 2, 3, 4, 5].select { |element| element.even? }
 ```
 
-## Random numbers
+## Random Numbers
 
 Here's how to get a random number from an array in Ruby:
 
@@ -351,7 +351,7 @@ With that, we arrive at a solution that rivals Ruby's elegance.
 
 </a>
 
-## Implicit returns and expressions
+## Implicit Returns and Expressions
 
 Ruby methods automatically return the result of the last statement.
 
@@ -510,7 +510,7 @@ To quote _[The Book](https://doc.rust-lang.org/book/second-edition/ch18-03-patte
 
 > This prints `no` since the if condition applies to the whole pattern `4 | 5 | 6`, not only to the last value 6.
 
-## String interpolation
+## String Interpolation
 
 Ruby has [extensive string interpolation support](https://ruby-doc.org/docs/ruby-doc-bundle/ProgrammingRuby/book/ref_m_kernel.html#Kernel.sprintf).
 
@@ -546,7 +546,7 @@ println!("{language} is also a beautiful programming language", language="Rust")
 
 Rust's `println!()` syntax is even more extensive than Ruby's. [Check the docs](https://doc.rust-lang.org/std/fmt/) if you're curious about what else you can do.
 
-## That’s it!
+## That’s It!
 
 Ruby comes with syntactic sugar for many common usage patterns, which allows for very elegant code.
 Low-level programming and raw performance are no primary goals of the language.
@@ -560,4 +560,4 @@ Did I whet your appetite for idiomatic Rust? Have a look at [this Github project
 
 <sup id="fn1">1. Thanks to <a href="https://twitter.com/Argorak">Florian Gilcher</a> for the hint.<a href="#ref1" title="Jump back to footnote 1 in the text.">↩</a></sup>  
 <sup id="fn2">2. Thanks to <a href="https://www.reddit.com/user/masklinn">masklin</a> for pointing out multiple inaccuracies.<a href="#ref2" title="Jump back to footnote 2 in the text.">↩</a></sup>  
-<sup id="fn3">3. In the first version, I sait that `ok()` would convert a `Result` into a `boolean`, which was wrong. Thanks to <a href="https://news.ycombinator.com/item?id=16003080">isaacg</a> for the correction.<a href="#ref3" title="Jump back to footnote 3 in the text.">↩</a></sup>
+<sup id="fn3">3. In the first version, I said that `ok()` would convert a `Result` into a `boolean`, which was wrong. Thanks to <a href="https://news.ycombinator.com/item?id=16003080">isaacg</a> for the correction.<a href="#ref3" title="Jump back to footnote 3 in the text.">↩</a></sup>
diff --git a/content/2017/rust-url-shortener/index.md b/content/2017/rust-url-shortener/index.md
index 9e440003..ab194f2d 100644
--- a/content/2017/rust-url-shortener/index.md
+++ b/content/2017/rust-url-shortener/index.md
@@ -1,5 +1,5 @@
 +++
-title="Launching a URL Shortener in Rust using Rocket"
+title="Launching a URL Shortener in Rust Using Rocket"
 date=2017-04-09
 updated=2020-08-26
 [taxonomies]
@@ -58,7 +58,7 @@ report back?
 rustup update && rustup override set nightly
 ```
 
-## A first prototype
+## A First Prototype
 
 Now we can start coding our little service.
 First, let's write a simple "hello world" skeleton to get started.
@@ -134,14 +134,14 @@ Sweet! Let's call our service.
 
 So far so good.
 
-## Data storage and lookup
+## Data Storage and Lookup
 
 We need to keep the shortened URLs over many requests... but how?
 In a production scenario, we could use some NoSQL data store like [Redis](https://redis.io/) for that.
 Since the goal is to play with Rocket and learn some Rust, we will simply use an
 in-memory store.
 
-Rocket has a that feature called [managed state](https://rocket.rs/v0.4/guide/state/).
+Rocket has a feature called [managed state](https://rocket.rs/v0.4/guide/state/).
 In our case, we want to manage a _repository_ of URLs.
 
 First, let's create a file named `src/repository.rs`:
@@ -184,7 +184,7 @@ By convention, we implement a `new()` method to create a `Repository` struct wit
 
 Note that we convert the string slices (`&str`) to `String` using the `to_string()` method. This way we don't need to deal with [lifetimes](https://doc.rust-lang.org/book/lifetimes.html). As a beginner, don't think too hard about them.
 
-## Additional remarks (can safely be skipped)
+## Additional Remarks (Can Safely Be Skipped)
 
 A seasoned (Rust) developer™ might do a few things differently here. Did you notice the tight coupling between the repository and the shortener? In a production system, `Repository` and `Shortener` might simply be concrete implementations of traits (which are a bit like interfaces in other languages, but more powerful). For example, `Repository` could implement a `Cache` trait:
 
@@ -197,7 +197,7 @@ trait Cache {
 }
 ```
 
-This way we get clear sepration of concerns, and we can easily switch to a different implementation (e.g. a `RedisCache`). Also, we could have a `MockRepository` to simplify testing. Same for `Shortener`.
+This way we get clear separation of concerns, and we can easily switch to a different implementation (e.g. a `RedisCache`). Also, we could have a `MockRepository` to simplify testing. Same for `Shortener`.
 
 On top of that, you might want to use the `Into` trait to support both, `&str` and `String` as parameters of `store`:
 
@@ -212,7 +212,7 @@ pub fn store<T: Into<String>>(&mut self, url: T) -> String {
 If you're curious about this, read [this article from Herman J. Radtke III](https://hermanradtke.com/2015/05/06/creating-a-rust-function-that-accepts-string-or-str.html).
 For now, let's keep it simple.
 
-## Actually shortening URLs
+## Actually Shortening URLs
 
 Let's implement the URL shortener itself.
 You might be surprised how much was written about URL shortening [all over the web](https://blog.codinghorror.com/url-shortening-hashes-in-practice/).
@@ -226,7 +226,7 @@ To use `harsh`, we add it to the dependency section of our `Cargo.toml`:
 harsh = "0.1.2"
 ```
 
-Next, we add the crate to the top of to our `main.rs`:
+Next, we add the crate to the top of our `main.rs`:
 
 ```
 extern crate harsh;
@@ -265,7 +265,7 @@ With `next_id` we retrieve a new `String` id for our URLs.
 
 As you can see, we don't pass the URL to `next_id`. That means we actually _don't shorten anything_. We merely create a short, unique ID. That's because most hashing algorithms produce fairly [long URLs](https://blog.codinghorror.com/url-shortening-hashes-in-practice/) and having short URLs is kind of the whole idea.
 
-## Wiring it up
+## Wiring It Up
 
 So we are done with our shortener and the repository.
 We need to adjust our `src/main.rs` again to make use of the two.
diff --git a/content/2017/why-i-love-programming/index.md b/content/2017/why-i-love-programming/index.md
index 7b408afb..909d7ca7 100644
--- a/content/2017/why-i-love-programming/index.md
+++ b/content/2017/why-i-love-programming/index.md
@@ -24,13 +24,13 @@ The [second part][1] will deal with the notion of [being a professional programm
 
 If you're not sure yet whether you want to learn how to program, this article is for you.
 
-## Automating stuff gives you superhero strengths
+## Automating Stuff Gives You Superhero Strengths
 
 Being able to program is infinitely rewarding. You can help your sister sort a
 thousand pictures in a few seconds. You write a little backup
 script for your grandma. The possibilities are endless.
 
-## Coding is fun!
+## Coding Is Fun!
 
 Coding something is more fun than using it. It's even better than playing games.
 Why? Learn how to program a computer and get the best games for free &mdash; your own.
@@ -38,7 +38,7 @@ You're in total control. It's your idea, your logic, even your laws of physics.
 It's like building a house but without paying anything for the
 building materials. You can build a mansion for free.
 
-## Sharing is fun, too!
+## Sharing Is Fun, Too!
 
 To get new inspiration for your next project, read the programs of others.
 This will give you an idea of how they think and how they solve problems.
@@ -48,7 +48,7 @@ Watching somebody else use your work is one
 of the most satisfying things you will ever experience.
 It's very fulfilling to see your tool serve a purpose it wasn't built for.
 
-## Elegant, creative solutions
+## Elegant, Creative Solutions
 
 It's very appealing to work so hard on your vision that everything unnecessary peels off.
 All these little ideas and fundamental insights suddenly fall into place.
@@ -60,12 +60,12 @@ piece of metal how to solve it.
 Even the way your program is structured can be a piece of art.
 It can be concise, witty and fast all at the same time.
 
-## Talk to a machine
+## Talk to a Machine
 
 It's fascinating that something is understood by machines and humans using the same language.
 I'm baffled when I realize that these circuits can actually "understand" and interpret words - in a way.
 
-## Standing on the shoulders of giants
+## Standing on the Shoulders of Giants
 
 Talking to other programmers and watching them work is a fascinating inspiration.
 The very system you are using to read this text relies on their work.
@@ -74,12 +74,12 @@ But if you get a chance, watch them giving talks at conferences and meet them at
 Becoming part of a community is gratifying.
 To exchange ideas and to collaborate on projects helps you push your boundaries and learn something new every day.
 
-## Have fun, forget the rest
+## Have Fun, Forget the Rest
 
 The machine is agnostic to your skin color. It doesn't matter if you're a twelve-year-old girl or a lecturer at University.
 If you keep making the same mistake for ten hours straight, your computer won't scream at you. It won't punish you. It will happily await your commands. Also, the hurdles of entry are pretty low. An old computer is enough; even pen and paper and a book will suffice to work on cool programming ideas.
 
-## Get started!
+## Get Started!
 
 You choose your own projects; nobody else.
 Don't let anybody tell you that you're not smart enough for this stuff. Ever.  
diff --git a/content/2017/why-type-systems-matter/index.md b/content/2017/why-type-systems-matter/index.md
index 7b71bf76..f23acf08 100644
--- a/content/2017/why-type-systems-matter/index.md
+++ b/content/2017/why-type-systems-matter/index.md
@@ -17,7 +17,7 @@ It began to feel very natural to me; like a totally new way to express myself.
 
 <!-- more -->
 
-## Types are here to help
+## Types Are Here to Help
 
 With types, you communicate your guarantees and expectations. Both, to the machine and other developers. Types express intent.
 
@@ -34,7 +34,7 @@ It gets a little more tricky if the type gets _inferred_ from some other locatio
 sentence = x
 ```
 
-Is `sentence` still a string? Uhm... we don't know. It depends on the type of `x`. Maybe `x` is a number, and so `sentence` is also a number? Maybe `x`used to be a string but during refactoring it is now a byte array? Fun times had by all. 🎉
+Is `sentence` still a string? Uhm... we don't know. It depends on the type of `x`. Maybe `x` is a number, and so `sentence` is also a number? Maybe `x` used to be a string but during refactoring it is now a byte array? Fun times had by all. 🎉
 
 What about this one?
 
@@ -54,7 +54,7 @@ total = file1 + file2
 print(total) # prints '50003000'
 ```
 
-## How can we fix that?
+## How Can We Fix That?
 
 We can safely assume that a file size is always a number.
 To be more precise, it must be a positive, natural number.
@@ -89,7 +89,7 @@ Dare I say it: it becomes an extension of your brain.
 After some time you start to rely on the type checker. "If it compiles, it runs"
 is a powerful mantra.
 
-## Types improve readability and provide context
+## Types Improve Readability and Provide Context
 
 Consider the following Python snippet:
 
@@ -131,7 +131,7 @@ In a larger codebase, `FileStatus.OPEN` is much easier to search for than `0`.
 **Note:** The native enum type was [introduced very late in the history of Python](https://www.python.org/dev/peps/pep-0435/). It serves as a nice
 example of how enhancing the type system can help improve readability.
 
-## When you combine different types, magic happens.
+## When You Combine Different Types, Magic Happens.
 
 All pieces suddenly fall into place when you choose your types wisely. Out of nowhere, the compiler will start
 checking your design decisions and if all your types work well together. It will point out flaws in your mental model.
diff --git a/content/2017/yes/index.md b/content/2017/yes/index.md
index 6989e98b..f4ba32a7 100644
--- a/content/2017/yes/index.md
+++ b/content/2017/yes/index.md
@@ -1,5 +1,5 @@
 +++
-title="A Little Story About the `yes` Unix Command"
+title="A Little Story about the `yes` Unix Command"
 date=2017-10-10
 updated=2021-04-29
 [taxonomies]
@@ -222,11 +222,11 @@ Now that's a whole different ballgame!
 
 - We prepare a filled string buffer, which will be reused for each loop.
 - [Stdout is protected by a lock](https://doc.rust-lang.org/std/io/struct.Stdout.html#method.lock). So, instead of constantly acquiring and releasing it, we keep it all the time.
-- We use a the platform-native [`std::ffi::OsString`](https://doc.rust-lang.org/std/ffi/struct.OsString.html) and [`std::borrow::Cow`](https://doc.rust-lang.org/std/borrow/enum.Cow.html) to avoid unnecessary allocations.
+- We use the platform-native [`std::ffi::OsString`](https://doc.rust-lang.org/std/ffi/struct.OsString.html) and [`std::borrow::Cow`](https://doc.rust-lang.org/std/borrow/enum.Cow.html) to avoid unnecessary allocations.
 
 The only thing that I could contribute was [removing an unnecessary `mut`](https://github.com/cgati/yes/pull/3/files). 😅
 
-## Lessons learned
+## Lessons Learned
 
 The trivial program `yes` turns out not to be so trivial after all.
 It uses output buffering and memory alignment to improve performance.
diff --git a/content/2018/cargo-inspect/index.md b/content/2018/cargo-inspect/index.md
index 2a178d91..d818a3ea 100644
--- a/content/2018/cargo-inspect/index.md
+++ b/content/2018/cargo-inspect/index.md
@@ -1,5 +1,5 @@
 +++
-title="What Is Rust Doing Behind the Curtains?"
+title="What Is Rust Doing behind the Curtains?"
 date=2018-12-02
 [taxonomies]
 tags=["dev", "rust"]
@@ -49,7 +49,7 @@ Motivated by this quick win, I wrapped it up in a cargo subcommand and called it
 
 Let's try cargo-inspect on some real code!
 
-## Example - Desugaring a range expression
+## Example - Desugaring a Range Expression
 
 The following examples can also be found in the project's [`examples`](https://github.com/mre/cargo-inspect/tree/master/examples) folder.
 
@@ -83,7 +83,7 @@ To the compiler backend, these are absolutely the same. So this holds:
 assert_eq!((1..3), std::ops::Range { start: 1, end: 3 });
 ```
 
-## Example - File handling
+## Example - File Handling
 
 _Input:_
 
@@ -128,7 +128,7 @@ fn main() -> Result<(), Error> {
 }
 ```
 
-We can see that the carrier operator `?` gets desugared into a `match` on the `Result` of `File::open`. In case of an error, We apply `std::convert::From::from` to convert between error types. Otherwise, we simply return the `Ok` value.
+We can see that the carrier operator `?` gets desugared into a `match` on the `Result` of `File::open`. In case of an error, we apply `std::convert::From::from` to convert between error types. Otherwise, we simply return the `Ok` value.
 
 ## Talk
 
@@ -137,14 +137,14 @@ Here is the recording:
 
 {{ <video url="https://www.youtube.com/embed/ePiWBGh35q0" preview="/talks/2019-fosdem.jpg" /> }}
 
-## Future work
+## Future Work
 
 I'm not planning to rewrite the compiler here. `rustc` is doing a far greater job than I could. All this functionality already existed before; I'm merely trying to make the compiler more approachable for learners like me.
 
 Right now, the tool is quite fragile. It throws ugly error messages when things go wrong.
 It mostly shines, when you run it on small, isolated example snippets.
 
-## Get involved!
+## Get Involved!
 
 Over on Github, I opened up a few issues for others to get involved.
 Namely, I wish there were options to:
diff --git a/content/2018/excel/index.md b/content/2018/excel/index.md
index 0a5136f0..e40ad0f8 100644
--- a/content/2018/excel/index.md
+++ b/content/2018/excel/index.md
@@ -86,7 +86,7 @@ they could also manage via Excel. It was just a glorious Excel form for a
 spreadsheet that they maintained manually. I spent two weeks of my summer
 vacation to finish that tool because they said they would pay me for that, which, of course, they didn't :).
 
-## Lessons learned
+## Lessons Learned
 
 - Never underestimate the power of Excel macros.
 - If you have a boring task at hand, make it more challenging by adding constraints.
diff --git a/content/2018/fastcat/index.md b/content/2018/fastcat/index.md
index 46291c0c..7c741980 100644
--- a/content/2018/fastcat/index.md
+++ b/content/2018/fastcat/index.md
@@ -83,7 +83,7 @@ cat myfile | pv -r > /dev/null
 
 Uh oh, [GNU cat](https://git.savannah.gnu.org/gitweb/?p=coreutils.git;a=blob;f=src/cat.c;h=3c319511c767f65d2e420b3bff8fa6197ddbb37b;hb=HEAD) is **ten times faster** than our little Ruby cat. 💎🐈🐌
 
-## Making our Ruby cat a little faster
+## Making Our Ruby cat a Little Faster
 
 Our naive Ruby code can be tweaked a bit.
 Turns out line buffering hurts performance in the end<sup><a href="#fn1" id="ref1">1</a></sup>:
@@ -244,7 +244,7 @@ fcat myfile | pv -r > /dev/null
 
 Holy guacamole. That's **over three times as fast as system cat**.
 
-## Operating System support
+## Operating System Support
 
 - **Linux** and **Android** are fully supported.
 - **[OpenBSD](https://stackoverflow.com/questions/12230316/do-other-operating-systems-implement-the-linux-system-call-splice?lq=1)**
@@ -265,7 +265,7 @@ Nevertheless, in a production-grade
 implementation, the splice support could be activated on systems that support
 it, while using a generic implementation as a fallback.
 
-## Nice, but why on earth would I want that?
+## Nice, but Why on Earth Would I Want That?
 
 I have no idea. Probably you don't, because your bottleneck is somewhere else.
 That said, many people use `cat` for piping data into another process like
@@ -287,7 +287,7 @@ In this case, if you notice that `cat` is the bottleneck try `fcat` (but first,
 With some more work, `fcat` could also be used to directly route packets from one
 network card to another, [similar to netcat](https://nc110.sourceforge.io/).
 
-## Lessons learned
+## Lessons Learned
 
 - The closer we get to bare metal, the more our hard-won abstractions fall
   apart, and we are back to low-level systems programming.
diff --git a/content/2018/functional-mathematics/index.md b/content/2018/functional-mathematics/index.md
index fc165876..3963e0a4 100644
--- a/content/2018/functional-mathematics/index.md
+++ b/content/2018/functional-mathematics/index.md
@@ -10,7 +10,7 @@ Programming languages help us describe general solutions for problems; the resul
 
 **tl;dr:** *I think that functional programming is better suited for mathematical computations than the more common imperative approach.*
 
-## Using built-in abstractions for Mathematics
+## Using Built-In Abstractions for Mathematics
 
 The ideas behind a language (the underlying programming paradigms) are distinctive for the community that builds around it. The developers create a unique ecosystem of ready-to-use libraries and frameworks around the language core. As a consequence, some languages are stronger in areas such as business applications (one could think of Cobol), others work great for systems programming (like C or Rust).
 
@@ -18,9 +18,9 @@ When it comes to solving mathematical and numerical problems with computers, For
 
 One reason for its popularity in this area is that it offers some built-in domain-specific keywords to express mathematical concepts, while keeping an eye on performance. For instance, it has a dedicated datatype for complex numbers – `COMPLEX` – and a keyword named `DIMENSION` which is quite similar to the mathematical term and can be used to create arrays and vectors.
 
-## Imperative vs functional style
+## Imperative vs Functional Style
 
-Built-in keywords can help expand the expressiveness of a language into a specific problem space, but this approach is severly limited. It’s not feasible to extend the language core *ad infinitum*; it would just be harder to maintain and take longer to learn. Therefore, most languages provide other ways of abstraction – like *functions*, *subroutines*, *classes* and *objects* – to split a routine into smaller, more manageable parts. These mechanisms might help to control the complexity of a program, but especially when dealing with mathematical problems, one has to be careful not to obfuscate the solution with boilerplate code.
+Built-in keywords can help expand the expressiveness of a language into a specific problem space, but this approach is severely limited. It’s not feasible to extend the language core *ad infinitum*; it would just be harder to maintain and take longer to learn. Therefore, most languages provide other ways of abstraction – like *functions*, *subroutines*, *classes* and *objects* – to split a routine into smaller, more manageable parts. These mechanisms might help to control the complexity of a program, but especially when dealing with mathematical problems, one has to be careful not to obfuscate the solution with boilerplate code.
 
 ### Specimen I - Factorial
 
@@ -61,16 +61,16 @@ fact n = product [1..n]
 
 This is an almost direct translation from the problem definition into code. It needs no explicit types, no temporary variables and no access modifiers (such as public).
 
-### Specimen II - Dot product
+### Specimen II - Dot Product
 
 One could argue that the above Haskell program owes its brevity to the fact, that the language provides just the right abstractions (namely the `product` keyword and the `[1..n]` range syntax) for that specific task.
-Therfore let’s examine a simple function which is neither available in Haskell nor in Java: The dot product of two vectors. The mathematical definition is as follows:
+Therefore let’s examine a simple function which is neither available in Haskell nor in Java: The dot product of two vectors. The mathematical definition is as follows:
 
 ![The mathematical definition of a vector dot product: a·b= aibi =a1b1+a2b2+···+anbn =abT]( ./example_vector_dot.svg) 
 
 For vectors with three dimensions, it can be written as
 
-![Vector dot product for three dimentsions: a·b = a1 * b1 + a2 * b2 + a3* b3]( ./example_vector_3d.svg)
+![Vector dot product for three dimensions: a·b = a1 * b1 + a2 * b2 + a3* b3]( ./example_vector_3d.svg)
 
 First, a Haskell implementation:
 
@@ -119,7 +119,7 @@ public static class Vector<T extends Number> {
 
 For a proper textual representation of Vectors, the toString() Method would also need to be overwritten. In Haskell, one can simply derive from the `Show` typeclass as shown in the code.
 
-## Creating new abstractions
+## Creating New Abstractions
 
 If functions and types are not sufficient to write straightforward programs, Haskell also offers simple constructs to create new operators and keywords which extend the language core itself. This makes domain-specific-languages feasible and enables the developer to work more directly on the actual problem instead of working around peculiarities of the programming language itself (such as memory management or array iteration). Haskell embraces this concept; Java has no such functionality.
 
diff --git a/content/2018/github/index.md b/content/2018/github/index.md
index 066a8655..98a9b7ff 100644
--- a/content/2018/github/index.md
+++ b/content/2018/github/index.md
@@ -21,7 +21,7 @@ Github got acquired by Microsoft.
 While I think the acquisition was well-deserved, I still wish it didn't happen.
 Let me explain.
 
-## My early days
+## My Early Days
 
 I joined Github on 3rd of January 2010.
 Since I was a bit late to the game, my usual handle ([mre](https://github.com/mre/)) was already taken.
@@ -35,7 +35,7 @@ That was the moment I fell in love with Github.
 I felt encouraged to collaborate on projects, that everybody could contribute something valuable.
 Only later I found out that Chris was one of the founders and the CEO of the company.
 
-## Living on Github
+## Living on GitHub
 
 Before Github, there was [SourceForge](https://sourceforge.net/), and I only went there to download binaries.
 Github showed me, that there was an entire community of like-minded people
@@ -47,7 +47,7 @@ I can still vividly remember getting my [first star](https://github.com/mre/Crea
 
 After so many years, a pull-request still feels like the most personal gift anyone could give to me.
 
-## Github - the culture
+## GitHub - The Culture
 
 After a while, I started to admire some Github employees deeply:
 
@@ -62,7 +62,7 @@ The harassment accusations and letting Zach Holman go are only part of the story
 It has become a company like any other, maintaining a mature product.
 It doesn't _excite_ me anymore.
 
-## An alternative reality
+## An Alternative Reality
 
 There's still a bitter taste in my mouth when I think that Github has fallen prey to one of the tech giants. I loved Github while it was a small, friendly community of passionate developers.
 Could this have been sustainable?
@@ -79,7 +79,7 @@ a front page where you could filter and search for events, a better way to handl
 These features would be targeted at the top 10% of Github users, a group of 3 million people.
 Would this be enough to pay the bills? Probably. Would it be enough to grow? Probably not.
 
-## So what?
+## So What?
 
 I don't think the acquisition will kill the culture. Microsoft is a strong partner and [Nat Friedman](https://nat.github.io/hello/) is one of us.
 On the other side, I'm not as enthusiastic as I used to be.
diff --git a/content/2018/go-io-testing/index.md b/content/2018/go-io-testing/index.md
index 24656071..c3f9ca42 100644
--- a/content/2018/go-io-testing/index.md
+++ b/content/2018/go-io-testing/index.md
@@ -22,7 +22,7 @@ The idea was to avoid file handling in unit tests without mocking or using tempo
 I was surprised that I couldn't find a simple explanation on sites like StackOverflow,
 which is why I wrote down some notes myself so that others can refer to it in the future.
 
-## Our example code
+## Our Example Code
 
 The initial version looked like this:
 
@@ -58,7 +58,7 @@ func analyze(file string) error {
 
 As you can see, we take a filename as input, and we open that file inside the `analyze` function to do something with its contents.
 
-## Writing our first test for the code
+## Writing Our First Test for the Code
 
 A typical test harness for that code might look like this:
 
@@ -98,7 +98,7 @@ In my opinion, mocking should be the last resort when it comes to testing. Befor
 Maybe implementing against an interface or using Dependency Injection helps decouple components?
 More often than not, a clear separation of concerns is all you need.
 
-## Refactoring to make testing easier
+## Refactoring to Make Testing Easier
 
 In my case above, we can easily avoid using mocks and temporary files by decoupling file I/O from the analysis.
 We do so by refactoring our `analyze` function to call `doSomething`, which takes an [`io.Reader`](https://golang.org/pkg/io/#Reader).
diff --git a/content/2018/keyboard/index.md b/content/2018/keyboard/index.md
index 60110e72..f0405839 100644
--- a/content/2018/keyboard/index.md
+++ b/content/2018/keyboard/index.md
@@ -17,7 +17,7 @@ I was looking for a similar article before jumping the gun, but I couldn't find
 
 {{ <figure page={page} src='keychron.jpg' caption='My current keyboard (as of April 2021), the low-profile, tenkeyless Keychron K1 is close to my favorite input device. Yes, I got the RGB version. &mdash; [Amazon referral link](https://amzn.to/3tRatjU).' /> }}
 
-## Why Switch To the US Layout?
+## Why Switch to the US Layout?
 
 I was reasonably efficient when writing prose, but felt like
 a [lemur on a piano](https://www.etsy.com/listing/896826954/funny-piano-art-print-leptodactylous-aye) when programming:
@@ -51,7 +51,7 @@ finally make the switch.
 
 {{ <figure page={page} src='durgod_taurus.jpg' caption='My first mechanical keyboard &mdash; [Durgod Taurus K320](https://www.amazon.de/gp/product/B07QK16RDQ/ref=as_li_tl?ie=UTF8&tag=matthiasendle-21&camp=1638&creative=6742&linkCode=as2&creativeASIN=B07QK16RDQ&linkId=fb0a782ecbc713f8266b90b941375a5f) (referral link). They also have a fancy [white-pink](https://www.amazon.de/gp/product/B081LZV2QM?ie=UTF8&tag=matthiasendle-21&camp=1638&linkCode=xm2&creativeASIN=B081LZV2QM) ISO version now.' /> }}
 
-## How Long Did It Take To Get Accustomed To The New Layout?
+## How Long Did It Take to Get Accustomed to the New Layout?
 
 Working as a Software Engineer, my biggest fear was, that the switch would slow
 down my daily work. This turned out not to be true. I was reasonably productive
@@ -78,7 +78,7 @@ reason why Vim is using `/` for search or why the pipe symbol is `|`: both are
 easy to reach! [It all makes sense!](/2018/ten-years-of-vim)
 (For a fun time, try that on a German keyboard!)
 
-I understand why Mircosoft chose `\` as a directory separator: it's easily
+I understand why Microsoft chose `\` as a directory separator: it's easily
 accessible from a US keyboard. On the German layout, it's&hellip; just&hellip; awful
 (`Alt Gr`+`ß` on Windows, `Shift` + `Option` + `7` on Mac).
 
@@ -109,7 +109,7 @@ me. It allows me to use a single Keyboard layout but insert German umlauts at wi
 [Karabiner](https://www.stefanimhoff.de/) rule which does the same. Might come
 in handy in case you already use this tool.
 
-## Is Switching Between Keyboards Painful?
+## Is Switching between Keyboards Painful?
 
 {{ <figure page={page} src="KB_United_States.svg" caption="US keyboard layout" credits="[Wikipedia](https://commons.wikimedia.org/wiki/File:KB_United_States.svg)" /> }}
 
@@ -118,7 +118,7 @@ the internal German and the external English keyboard would confuse me. This
 turned out not to be a problem. I rarely look at the print anyway.
 (Update: can't remember when I last looked at the print.)
 
-## How Often Do You Switch Back To A German Layout Now?
+## How Often Do You Switch Back to a German Layout Now?
 
 Never. My Girlfriend has a German keyboard and every time I have to use it, I switch to the US layout. It makes her very happy when I do this and forget to switch back to German when I'm done.
 
diff --git a/content/2018/ls/index.md b/content/2018/ls/index.md
index 39e01419..8483501b 100644
--- a/content/2018/ls/index.md
+++ b/content/2018/ls/index.md
@@ -18,7 +18,7 @@ As we will find out, `ls` is actually quite a powerful tool under the hood.
 I'm not going to come up with a full rewrite, but instead only cover the very basic output that you would expect from calling `ls -l` on your command line.
 What is this output? I'm glad you asked.
 
-## Expected output
+## Expected Output
 
 ```
 > ls -l
@@ -44,7 +44,7 @@ For more in-depth information, I can recommend reading the manpage of `ls` from
 Whew, that's a lot of information for such a tiny tool.
 But then again, it can't be so hard to port that to Rust, right? Let's get started!
 
-## A very basic `ls` in Rust
+## A Very Basic `ls` in Rust
 
 Here is the most bare-bones version of `ls`, which just prints all files in the current directory:
 
@@ -95,7 +95,7 @@ _Pro Tip_: You can install the binary with `cargo install` and call it like any
 
 But we have higher goals, so let's continue.
 
-## Adding a parameter to specify the directory
+## Adding a Parameter to Specify the Directory
 
 Usually, if we type `ls mydir`, we expect to get the file listing of no other directory than `mydir`. We should add the same functionality to our version.
 
@@ -142,7 +142,7 @@ There are tons of configuration options, so it's worth checking out the [project
 
 Also note, that we changed the type of the path variable from `Path` to `PathBuf`. The difference is, that [`PathBuf` owns the inner path string](https://doc.rust-lang.org/src/std/path.rs.html#1107-1109), while `Path` [simply provides a reference to it](https://doc.rust-lang.org/src/std/path.rs.html#1629-1631). The relationship is similar to `String` and `&str`.
 
-## Reading the modification time
+## Reading the Modification Time
 
 Now let's deal with the metadata.
 First, we try to retrieve the modification time from the file.
@@ -222,7 +222,7 @@ It means "right align this field with a space padding of 5" - just like our bigg
 
 Similarly, we retrieved the size in bytes with `metadata.len()`.
 
-## Unix file permissions are a zoo
+## Unix File Permissions Are a Zoo
 
 Reading the file permissions is a bit more tricky.
 While the `rwx` notation is very common in Unix derivatives such as \*BSD or GNU/Linux, many other operating systems ship their own permission management.
@@ -236,7 +236,7 @@ Wikipedia lists a few extensions to the file permissions that you might encounte
 
 That just goes to show, that there are a lot of important details to be considered when implementing this in real life.
 
-## Implementing very basic file mode
+## Implementing Very Basic File Mode
 
 For now, we just stick to the basics and assume we are on a platform that supports the `rwx` file mode.
 
@@ -313,7 +313,7 @@ fn triplet(mode: u16, read: u16, write: u16, execute: u16) -> String {
 }
 ```
 
-## Wrapping up
+## Wrapping Up
 
 The final output looks like this. Close enough.
 
diff --git a/content/2018/rust-2018/index.md b/content/2018/rust-2018/index.md
index 9f756bab..ed37a58a 100644
--- a/content/2018/rust-2018/index.md
+++ b/content/2018/rust-2018/index.md
@@ -15,7 +15,7 @@ I'm a bit late to the party, but here are my 2 cents about the priorities for Ru
 
 <!-- more -->
 
-## Who _is_ this guy?
+## Who _Is_ This Guy?
 
 There's a depressingly high chance that we've never met before &mdash; which is a real shame.
 For some context: I come from dynamically typed languages like Python and PHP.
@@ -24,7 +24,7 @@ Rust was the first language that allowed me to write _real_ low-level code witho
 To me, Rust is not a [fireflower](https://brson.github.io/fireflowers/), it's my own personal [Megazord](https://en.wikipedia.org/wiki/Power_Rangers)<sup><a href="#fn1" id="ref1">1</a></sup>.
 I want Rust to win, but for that, we need to tick a few points off the list.
 
-## Compiler documentation for easier contribution
+## Compiler Documentation for Easier Contribution
 
 ![Rust programmers hacking during the Impl days at RustBeltRust](./rustbeltrust.jpeg)
 
@@ -39,7 +39,7 @@ Hence my first wish is, that contributing to the language will become easier.
 That could be achieved by providing extensive mentorship, more entry-level tickets, and [better compiler documentation](https://internals.rust-lang.org/t/so-you-want-to-hack-on-the-rust-compiler-a-plan-for-a-book/6497).
 All of that was already [suggested by Niko](https://smallcultfollowing.com/babysteps/blog/2018/01/05/lessons-from-the-impl-period/).
 
-## More resources for intermediate programmers
+## More Resources for Intermediate Programmers
 
 On a related note, I'd like to see more talks/guidelines/books targeting intermediate Rust programmers.
 This includes discussions on how to structure [big projects](https://github.com/servo/servo) in Rust and Rust-specific [design patterns](https://github.com/rust-unofficial/patterns).
@@ -47,7 +47,7 @@ I want to read more about professional Rust usage and see case-studies from vari
 For example, there was a startup called snips.ai, which built an on-device voice-assistant using Rust.
 They integrated with C and C++ libraries and [I want to hear more about their journey](https://medium.com/snips-ai/snips-big-wish-for-rust2018-libraries-or-portability-pick-two-814d104586d9).
 
-## Improve the RFC process
+## Improve the RFC Process
 
 I try to follow the RFC process very closely, but my time is limited.
 My wish is, that I can open any RFC and immediately get its status:
@@ -62,7 +62,7 @@ Github is great for code, but conversations about new features regularly get out
 This is not a problem, that is limited to Rust, either. Just look at other big projects like Docker, Kubernetes, or Node.
 Maybe we need a new tool for that.
 
-## The usual suspects
+## The Usual Suspects
 
 If I could ask for two stable features in 2018, it would be [`?` in main](https://github.com/rust-lang/rust/issues/43301)
 and [non-lexical lifetimes](https://github.com/rust-lang/rust/issues/44928).
diff --git a/content/2018/ten-years-of-vim/index.md b/content/2018/ten-years-of-vim/index.md
index 8c43902a..cf3ec5bd 100644
--- a/content/2018/ten-years-of-vim/index.md
+++ b/content/2018/ten-years-of-vim/index.md
@@ -50,7 +50,7 @@ This painful process is what Vim tries to make at least bearable. It helps you k
 It does that, by providing you sharp, effective tools to modify text.
 The core of Vim is a language for editing text.
 
-## Vim, The Language
+## Vim, the Language
 
 The Vim commands are not cryptic, you already know them.
 
@@ -71,7 +71,7 @@ That's why, by default, you are in [normal mode](https://en.wikibooks.org/wiki/L
 
 Once you know this, Vim makes a lot more sense, and that's when you start to be productive.
 
-## How My Workflow Changed Over The Years
+## How My Workflow Changed over the Years
 
 When I was a beginner, I was very interested in how people with more Vim experience would use the editor.
 Now that I'm a long-time user, here's my answer: there's no secret sauce.
@@ -115,7 +115,7 @@ Here are a few things I wish I could do better:
 - **Multiple registers for copy and paste**: Right now I only use one register (like a pastebin) for copying text, but Vim supports multiple registers. That's cool if you want to move around more than one thing at the same time. [Let's use more of those!](https://vim.fandom.com/wiki/Copy%2c_cut_and_paste)
 - **Tabs**: I know [how tabs work](https://vim.fandom.com/wiki/Using_tab_pages), but all the typing feels clunky. That's why I never extensively used them. Instead, I mostly use multiple terminal tabs or an IDE with Vim bindings for bigger projects.
 
-## Would I learn Vim again?
+## Would I Learn Vim Again?
 
 That's a tough question to answer.
 
diff --git a/content/2019/maybe-you-dont-need-kubernetes/index.md b/content/2019/maybe-you-dont-need-kubernetes/index.md
index 85c609e3..c67e98b3 100644
--- a/content/2019/maybe-you-dont-need-kubernetes/index.md
+++ b/content/2019/maybe-you-dont-need-kubernetes/index.md
@@ -68,7 +68,7 @@ required:
 - Have a common place to share configurations and secrets.
 - Provide an endpoint for metrics and logging.
 
-## Why Kubernetes Was Not A Good Fit For Us
+## Why Kubernetes Was Not a Good Fit for Us
 
 When creating a prototype with Kubernetes, we noticed that we started adding
 ever-more complex layers of logic to operate our services. Logic on which we
@@ -91,7 +91,7 @@ goes on and on. Not all tools are necessary to get started with Kubernetes, but
 it’s hard to know which ones are, so you have to be at least aware of them.
 Because of that, the learning curve is quite steep.
 
-## When To Use Kubernetes
+## When to Use Kubernetes
 
 At trivago specifically, many teams use Kubernetes and are quite happy with it.
 These instances are managed by Google or Amazon however, which have the capacity to do so.
@@ -136,7 +136,7 @@ vendor lock-in because the functionality it provides can easily be integrated
 into any other system that manages services. It just runs as a plain old single
 binary on every machine in your cluster; that's it!
 
-## The Nomad Ecosystem Of Loosely Coupled Components
+## The Nomad Ecosystem of Loosely Coupled Components
 
 The real power of Nomad lies within its ecosystem. It integrates very well with
 other - completely optional - products like [Consul] (a key-value store) or
diff --git a/content/2019/tinysearch/index.md b/content/2019/tinysearch/index.md
index f4765726..d8ff6e1f 100644
--- a/content/2019/tinysearch/index.md
+++ b/content/2019/tinysearch/index.md
@@ -1,5 +1,5 @@
 +++
-title="A Tiny, Static, Full-Text Search Engine using Rust and WebAssembly"
+title="A Tiny, Static, Full-Text Search Engine Using Rust and WebAssembly"
 date=2019-10-17
 updated=2022-02-15
 [taxonomies]
@@ -68,7 +68,7 @@ creates a tiny, self-contained search index using this magical data structure
 called a
 ✨*Bloom Filter* ✨.
 
-## Wait, what's a Bloom Filter?
+## Wait, What's a Bloom Filter?
 
 A [Bloom filter](https://en.wikipedia.org/wiki/Bloom_filter) is a space-efficient way to
 check if an element is in a set.
@@ -152,7 +152,7 @@ clue how to package it for the web... until [wasm-pack came along in
 February
 2018](https://github.com/rustwasm/wasm-pack/commit/125431f97eecb6f3ca5122f8b345ba5b7eee94c7).
 
-## Whoops! I Shipped Some Rust Code To Your Browser.
+## Whoops! I Shipped Some Rust Code to Your Browser.
 
 Now I had all the pieces of the puzzle:
 
@@ -405,7 +405,7 @@ If you get something working for your static site generator, [please let me know
   website, check out [sonic](https://journal.valeriansaliou.name/announcing-sonic-a-super-light-alternative-to-elasticsearch/).
   Also check out [stork](https://github.com/jameslittle230/stork) as an alternative.
 
-## Try it!
+## Try It!
 
 The code for [tinysearch is on Github](https://github.com/mre/tinysearch).
 
diff --git a/content/2020/cratesio/index.md b/content/2020/cratesio/index.md
index 9d73b8f1..3583c1ef 100644
--- a/content/2020/cratesio/index.md
+++ b/content/2020/cratesio/index.md
@@ -1,5 +1,5 @@
 +++
-title="Name-squatting on crates.io - Do we have a problem?"
+title="Name-Squatting on crates.io - Do We Have a Problem?"
 date=2020-08-20
 draft=true
 [taxonomies]
@@ -31,7 +31,7 @@ and newcomers have to deal with that. And then it gets deprecated. And then you
 Using PHP's composer felt like a breath of fresh air in comparison.
 Namespaces made these problems go away.
 
-## What is name squatting?
+## What Is Name Squatting?
 
 Name squatting is like Germans reserving all the loungers near the pool.
 It's become a meme: https://www.youtube.com/watch?v=nzHihXOiNqk
@@ -56,7 +56,7 @@ people can still publish stuff under your "namespace"
 
 https://github.com/google/evcxr
 
-## How many names are squatted?
+## How Many Names Are Squatted?
 
 Squatted names by length
 
diff --git a/content/2020/folklore/index.md b/content/2020/folklore/index.md
index 32fc2ec2..781cfb2b 100644
--- a/content/2020/folklore/index.md
+++ b/content/2020/folklore/index.md
@@ -167,7 +167,7 @@ line-feed:
 
 {{ <video url="https://www.youtube.com/embed/EWfElq1vgLA" start="842" preview="typewriter.jpg" /> }}
 
-## Command key symbol (⌘)
+## Command Key Symbol (⌘)
 
 _Today's meaning: A meta-key available on Apple computers to provide additional
 keyboard combinations._
@@ -195,7 +195,7 @@ down, notably Borgholm Castle.
 {{ <figure page={page} src="severdighet.png" caption="Norwegian Severdighet road sign" credits="[Wikimedia
 Commons](https://commons.wikimedia.org/wiki/File:Severdighet.svg)" /> }}
 
-{{ <figure page={page} src="borgholm.jpg" caption="Aearial view of Borgholm Castle, which could have been the model for the symbol " credits="[Wikimedia
+{{ <figure page={page} src="borgholm.jpg" caption="Aerial view of Borgholm Castle, which could have been the model for the symbol " credits="[Wikimedia
 Commons](https://commons.wikimedia.org/wiki/File:Borgholms_slottsruin_fr%C3%A5n_luften.jpg)" /> }}
 
 References:
@@ -458,7 +458,7 @@ being on the outside, protecting the kernel.
 
 [Reference](https://unix.stackexchange.com/questions/14934/why-was-the-word-shell-used-to-descibe-a-command-line-interface)
 
-## Slab allocator
+## Slab Allocator
 
 _Today's meaning: An efficient memory allocation technique, which reuses
 previous allocations._
@@ -471,7 +471,7 @@ Bonwick](https://www.usenix.org/publications/library/proceedings/bos94/full_pape
 > With slab allocation, a cache for a certain type or size of data object has a
 > number of pre-allocated "slabs" of memory; within each slab there are memory
 > chunks of fixed size suitable for the objects.
-> ([Wikpedia](https://en.wikipedia.org/wiki/Slab_allocation#Basis))
+> ([Wikipedia](https://en.wikipedia.org/wiki/Slab_allocation#Basis))
 
 The name _slab_ comes from a teenage friend of Bonwick. He [tells the
 story](https://blogs.oracle.com/bonwick/now-it-can-be-told) on the Oracle blog:
@@ -547,12 +547,12 @@ radio buttons (right). Only a single option can be selected at any point in
 time. As a kid, I would push two buttons at once so they would interlock. Good
 times." credits="Images by [Matt Coady](https://twitter.com/themattcoady)" /> }}
 
-## Uppercase and lowercase
+## Uppercase and Lowercase
 
 _Today's meaning: Distinction between capital letters and small letters on a
 keyboard._
 
-Back when typesetting was a manual process where single letters made of led were
+Back when typesetting was a manual process where single letters made of lead were
 "type set" to form words and sentences, upper- and lowercase letters were kept
 in separate containers &mdash; or cases &mdash; to make this rather tedious process a little faster.
 
@@ -560,7 +560,7 @@ in separate containers &mdash; or cases &mdash; to make this rather tedious proc
 survivals' by Updike, Daniel Berkeley, 1860-1941. [Freely available on
 archive.org](https://archive.org/details/printingtypesthe01updi/)." /> }}
 
-## Honorable mentions
+## Honorable Mentions
 
 ### 404
 
@@ -576,7 +576,7 @@ This, however, seems to be a myth and the status code was chosen rather
 arbitrarily based on the then well-established FTP status codes.
 [Reference](https://knowyourmeme.com/memes/404)
 
-## Programming languages and Abbreviations
+## Programming Languages and Abbreviations
 
 The etymology of programming language names and common abbreviations would
 probably warrant its own article, but I've decided to note down some of my
@@ -607,7 +607,7 @@ Commons](https://commons.wikimedia.org/wiki/File:Treblecsharp5.svg)" /> }}
 
 Officially, PNG stands for _Portable Network Graphics_. It was born out of
 frustration over a CompuServe announcement in 1994 that programs supporting GIF
-would have to pay licensing fees from now on. A working group lead by hacker
+would have to pay licensing fees from now on. A working group led by hacker
 [Thomas Boutell](https://boutell.dev/) created the `.webp` file format, a
 patent-free replacement for GIF. Therefore I prefer the format's unofficial
 name: _PNG's Not GIF_. Here's a [great
diff --git a/content/2020/go-is-not-simple/foo.md b/content/2020/go-is-not-simple/foo.md
index 62bd0e31..d8f95bdb 100644
--- a/content/2020/go-is-not-simple/foo.md
+++ b/content/2020/go-is-not-simple/foo.md
@@ -1,5 +1,5 @@
 +++
-title="Go is Simple"
+title="Go Is Simple"
 date=2020-05-29
 draft=true
 +++
@@ -241,7 +241,7 @@ In 99% of the cases, you don't **need** enums so it's better to omit that keywor
 
 Here's something real that I have to do from time to time:
 
-## Finding the unique elements in a slice
+## Finding the Unique Elements in a Slice
 
 ```go
 import "fmt"
@@ -326,7 +326,7 @@ print(google_search_nightmares)
 Oh shut up Python! You share your name with an animal; that won't make searching any easier.
 Oh, it's about the `intersection()` method? Yeah we can totally add that, too in Go.
 We just have to write a few more lines of code.
-And while we're add it we can add `union()` and `member()` and `difference()`, too!
+And while we're at it we can add `union()` and `member()` and `difference()`, too!
 Golang is the only mainstream language that teaches you how to implement basic datastructures yourself.
 
 Wait a sec. Nobody does that in real life. That's what libraries are for!
diff --git a/content/2020/go-is-not-simple/index.md b/content/2020/go-is-not-simple/index.md
index 01ffe725..730e0367 100644
--- a/content/2020/go-is-not-simple/index.md
+++ b/content/2020/go-is-not-simple/index.md
@@ -1,5 +1,5 @@
 +++
-title="Go is not Simple"
+title="Go Is Not Simple"
 date=2020-05-29
 draft=true
 [taxonomies]
@@ -237,7 +237,7 @@ Go is the modern C
 
 Leads to bugs and people using Go for projects it was never designed for like Docker.
 
-The Go standard libary
+The Go standard library
 
 "batteries included"
 a terrible builtin json library,
@@ -258,7 +258,7 @@ Go is often misunderstood
 - inside the Google team
 - microservices
 
-If thoes assumptions hold, Go is the way to go.
+If those assumptions hold, Go is the way to go.
 Things start becoming interesting when one or more assumptions are incorrect.
 Writing 100kloc projects in Go will make you miss generics
 
@@ -276,7 +276,7 @@ I'm just from a different school of thought.
 
 imposing a disproportionate cost on users.o
 
-inconsistenjt
+inconsistent
 
     repo := &github.Repository{
     	Name:       github.String("migrate-test"),
@@ -300,7 +300,7 @@ on the other side, errors are hidden when they were used "once"
 response, err := bla()
 response, err := bar() // no new variables
 
-Sometimes yo don't have a better name for a variable...
+Sometimes you don't have a better name for a variable...
 Have to change to `=`
 Especially annoying during debugging
 Why can't I use `:=` in general?
@@ -365,7 +365,7 @@ Concurrency
 
 Typeclasses carry value with them
 
-The lazyness is also part of the build system
+The laziness is also part of the build system
 `go build` and `go run` behave differently...
 
 ```go
diff --git a/content/2020/perf/index.md b/content/2020/perf/index.md
index cfab26e4..c82f6eb5 100644
--- a/content/2020/perf/index.md
+++ b/content/2020/perf/index.md
@@ -8,7 +8,7 @@ tags=["dev"]
 excerpt="""Did I mention that this website is fast?
 Oh yeah, I did, multiple times.
 It's never fast enough, so today I go one step further by adding
-support for the new AVIF image format to the blog. The results were suprising.
+support for the new AVIF image format to the blog. The results were surprising.
 """
 +++
 
@@ -35,7 +35,7 @@ Then again, it's 2020: **everyone** is optimizing their favicons, right? [...rig
 
 Well, it turns out most other sites don't think about their user's data plans as much as I do. Actually, that's an understatement: they don't care at all. But to me, **lean is beautiful**!
 
-## Wait, What About Images?
+## Wait, What about Images?
 
 I prefer SVG for diagrams and illustrations.
 Only if it's a photo, I'll use JPEG or [WebP](https://developers.google.com/speed/webp/).
@@ -89,7 +89,7 @@ If that reads "nope," then you have a few options:
 - **On Chrome**: Make sure to update to the latest version.
 - **On Safari**: I'm not sure what you're doing with your life. Try a real browser instead. 😏
 
-## Workaround I: Fallback For Older Browsers
+## Workaround I: Fallback for Older Browsers
 
 HTML is great in that your browser ignores unknown new syntax.
 So I can use the `<picture>` element to serve the right format to you. (Look ma, no JavaScript!)
@@ -106,7 +106,7 @@ So I can use the `<picture>` element to serve the right format to you. (Look ma,
 thing](https://github.com/mre/endler.dev/blob/master/templates/components/figure.html)
 is a bit more convoluted, but you get the idea.
 
-## Workaround II: Wrong Content-Type On Github Pages
+## Workaround II: Wrong Content-Type on GitHub Pages
 
 There was one ugly problem with Github and AVIF, though: Their server returned a
 `Content-Type: application/octet-stream` header.
@@ -135,7 +135,7 @@ You can read more about modifying response objects [here](https://developers.clo
 
 Another side-effect of Workers Sites is that a production deployment takes [one minute](https://github.com/mre/endler.dev/actions) now.
 
-## Performance Results After Moving To Cloudflare
+## Performance Results after Moving to Cloudflare
 
 {{ <figure page={page} src="cdn_before.jpg" caption="Website response time before" credits="[KeyCDN](https://tools.keycdn.com/performance?url=https://endler.dev)" /> }}
 {{ <figure page={page} src="cdn_after.jpg" caption="Website response time after" credits="[KeyCDN](https://tools.keycdn.com/performance?url=https://endler.dev)" /> }}
@@ -147,7 +147,7 @@ I don't have to hide from a comparison with well-known sites either:
 
 {{ <figure page={page} src="speedcurve.png" caption="Comparison with some other blogs I read" credits="[Speedcurve](https://speedcurve.com)" /> }}
 
-## Further reading
+## Further Reading
 
 - [How to Use AVIF: The New Next-Gen Image Compression Format](https://reachlightspeed.com/blog/using-the-new-high-performance-avif-image-format-on-the-web-today/) &mdash; Nice introduction that highlights some common pitfalls when integrating AVIF. It inspired me to add AVIF support.
 - [AVIF has landed](https://jakearchibald.com/2020/avif-has-landed/) by Jake Archibald &mdash; Compares image sizes and qualities of different formats: SVG, JPEG, PNG, WebP, and AVIF.
diff --git a/content/2020/review/index.md b/content/2020/review/index.md
index 4897c36e..847abe16 100644
--- a/content/2020/review/index.md
+++ b/content/2020/review/index.md
@@ -1,5 +1,5 @@
 +++
-title="What Happened To Programming In The 2010s?"
+title="What Happened to Programming in the 2010s?"
 date=2020-07-02
 updated=2021-10-11
 draft=false
@@ -25,7 +25,7 @@ don't sue me.
 My goal is to reflect on the <u>past</u> so that you can better predict the <u>future</u>.
 {% </info> %}
 
-## Where To Start?
+## Where to Start?
 
 From a mile-high perspective, programming is still the same as a decade ago:
 
@@ -54,7 +54,7 @@ Pi](https://en.wikipedia.org/wiki/Raspberry_Pi) (which only got released in
 
 {{ <figure page={page} src="xkcd_2324.jpg" credits="<a href='https://xkcd.com/2324/'>xkcd #2324</a>" /> }}
 
-## An Explosion Of New Programming Languages
+## An Explosion of New Programming Languages
 
 The last decade saw the creation of a vast number of new and exciting programming
 languages.
@@ -117,7 +117,7 @@ Most languages adopted a quicker release cycle. Here's a list for some popular l
 | Swift                   | 6 months              |
 | Visual Basic .NET       | ~ 24 months           |
 
-## The Slow Death Of Null
+## The Slow Death of Null
 
 Close to the end of the last decade, in a talk from 25<sup>th</sup>of August 2009,
 Tony Hoare described the `null` pointer as his [Billion Dollar
@@ -142,7 +142,7 @@ C++, Go, Kotlin, Swift, and Rust are popular examples with type inference suppor
 can only speak for myself, but I think writing Java has become a lot more
 ergonomic in the last few years.
 
-## Exponential Growth Of Libraries and Frameworks
+## Exponential Growth of Libraries and Frameworks
 
 As of today, npm hosts [1,330,634 packages](https://www.npmjs.com/). That's over a million
 packages that somebody else is maintaining for you. Add another [160,488 Ruby
@@ -177,7 +177,7 @@ It has held up surprisingly well in the last decade:
 There's a catch, though.
 Looking at single-core performance, the curve is flattening:
 
-{{ <figure page={page} src="moore_single.jpg" credits="<a href='https://www.youtube.com/watch?v=Azt8Nc-mtKM&'>Standford University: The Future of Computing (video)</a>" /> }}
+{{ <figure page={page} src="moore_single.jpg" credits="<a href='https://www.youtube.com/watch?v=Azt8Nc-mtKM&'>Stanford University: The Future of Computing (video)</a>" /> }}
 
 The new transistors prophesied by Moore don’t make our CPUs faster but instead
 add other kinds of processing capabilities like more parallelism or hardware
@@ -198,7 +198,7 @@ parallel computations, which caused a renaissance of Machine Learning for practi
 
 _Compute_ is ubiquitous, so in most cases, energy efficiency plays a more prominent role now than raw performance (at least for consumer devices).
 
-## Unlikely Twists Of Fate
+## Unlikely Twists of Fate
 
 - Microsoft is a cool kid now. It acquired Github, announced the [Windows subsystem for Linux](https://en.wikipedia.org/wiki/Windows_Subsystem_for_Linux) (which should really be called Linux Subsystem for Windows), open sourced
   [MS-DOS](https://github.com/Microsoft/MS-DOS) and [.NET](http://news.microsoft.com/2014/11/12/microsoft-takes-net-open-source-and-cross-platform-adds-new-development-capabilities-with-visual-studio-2015-net-2015-and-visual-studio-online/).
diff --git a/content/2020/sponsors/index.md b/content/2020/sponsors/index.md
index e52b0378..0404b3ec 100644
--- a/content/2020/sponsors/index.md
+++ b/content/2020/sponsors/index.md
@@ -1,5 +1,5 @@
 +++
-title = "Launching a Side Project Backed by Github Sponsors"
+title = "Launching a Side Project Backed by GitHub Sponsors"
 date = 2020-08-21
 [taxonomies]
 tags=["oss", "business"]
@@ -183,7 +183,7 @@ functionality was broken (of course). Turns out, we hit the free quota limit on
 exchange with Algolia's customer support, and they moved us over to the
 open-source plan (which we didn't know existed). We were back on track!
 
-> Site note: Algolia customer support is top-notch. Responsive, tech-savvy,
+> Side note: Algolia customer support is top-notch. Responsive, tech-savvy,
 > and helpful. Using Algolia turned out to be a great fit for our product.
 > Response times are consistently in the low milliseconds and the integration
 > with Gatsby was quick and easy.
@@ -219,7 +219,7 @@ analysis and he approved. (Thanks boss!)
 
 High fives all around!
 
-## Now what?
+## Now What?
 
 Of course, we'll add new features; of course, we have more plans for the future,
 yada yada yada. Instead, let's reflect on that milestone: a healthy little
diff --git a/content/2020/timelapse/index.md b/content/2020/timelapse/index.md
index 247c8330..f7672483 100644
--- a/content/2020/timelapse/index.md
+++ b/content/2020/timelapse/index.md
@@ -17,7 +17,7 @@ this project's journey. It just took _ten years_ to get here.
 
 {{ <video url="https://www.youtube.com/embed/_QEmxAZqQhE" preview="timelapse.jpg" /> }}
 
-## 2011 - How it all began
+## 2011 - How It All Began
 
 To be honest, I don't remember why I initially wrote the tool. I must have had a
 personal need for a screen recorder, I guess...
diff --git a/content/2020/unix-microservices/index.md b/content/2020/unix-microservices/index.md
index 0d2976a6..5062d85a 100644
--- a/content/2020/unix-microservices/index.md
+++ b/content/2020/unix-microservices/index.md
@@ -1,5 +1,5 @@
 +++
-title="No, microservices are not embracing the Unix philosophy"
+title="No, Microservices Are Not Embracing the Unix Philosophy"
 date=2019-04-01
 draft=true
 +++
@@ -18,7 +18,7 @@ Glue code between the services: request handling, logging
 You're not building small, composable tools, you're building a distributed system!
 
 
-I'm pretty sure when Thompson, Ritchie, and McIllroy established the Unix Philosphoy, they didn't have microservices in mind.
+I'm pretty sure when Thompson, Ritchie, and McIlroy established the Unix Philosophy, they didn't have microservices in mind.
 From running many microservices in production, they can be very fragile.
 
 Avoid State
@@ -28,7 +28,7 @@ It's true, microservices are easy to write. The hard part is operations.
 This is where they differ from Unix tools.
 
 Unix tools: `cat`, `ls`, `rm`.
-Microservices: Account managemer, cache, geoip service, kiosk service.
+Microservices: Account manager, cache, geoip service, kiosk service.
 A lot more moving parts. A lot more things that can go wrong.
 Other systems instead lump these into a single "account management" service with an internal structure and command language of its own.
 
diff --git a/content/2021/codeprints/index.md b/content/2021/codeprints/index.md
index ac2366b4..4616c32d 100644
--- a/content/2021/codeprints/index.md
+++ b/content/2021/codeprints/index.md
@@ -1,5 +1,5 @@
 +++
-title="Starting A Print-On-Demand Business As A Software Engineer"
+title="Starting a Print-on-Demand Business as a Software Engineer"
 date=2021-01-22
 [taxonomies]
 tags=["business"]
@@ -15,7 +15,7 @@ It's my first "physical" product, so I decided to share my learnings.
 of our first customers and we are very thankful for this tweet promoting our
 service, which gave us a huge traffic boost." link="https://twitter.com/KrauseFx/status/1348546742644580353" /> }}
 
-## Launching Is Hard, So Launch Early
+## Launching Is Hard, so Launch Early
 
 Even though I knew that launching early was vital, I still didn't want to
 "commit" to the final design shortly before the planned go-live. There was always that last bug to fix or that little extra feature to implement.
@@ -111,7 +111,7 @@ You'll have to say "no" more often than you can say "yes".
 entirely built remotely. More people should give [whereby](https://whereby.com/)
 a try." /> }}
 
-## Getting Traction As A Small Business
+## Getting Traction as a Small Business
 
 It has never been easier to launch a shop. Services like Shopify, Stripe, and a
 host of suppliers make starting out a breeze. On the other hand, there is a lot
@@ -133,7 +133,7 @@ hang out there that much.
 **Lesson learned:** Always know where your customers are and understand their needs.
 {% </info> %}
 
-## Finding A Niche Is Only Half The Job
+## Finding a Niche Is Only Half the Job
 
 [Common market wisdom](https://www.reddit.com/r/startups/comments/53fynp/niche_market_and_peter_thiels_monopoly_theory/) is to find niche and grow from within. With codeprints we definitely found our niche: the audience is very
 narrow but interested in our geeky products. There are 56 million developers on
diff --git a/content/2021/first-business/index.md b/content/2021/first-business/index.md
index 2d2fe316..69aceeed 100644
--- a/content/2021/first-business/index.md
+++ b/content/2021/first-business/index.md
@@ -1,5 +1,5 @@
 +++
-title = "Spreadsheets Make For Great Business Ideas"
+title = "Spreadsheets Make for Great Business Ideas"
 date = 2021-03-10
 updated = 2025-04-24
 [taxonomies]
diff --git a/content/2021/history/index.md b/content/2021/history/index.md
index b4248daf..e8fe188b 100644
--- a/content/2021/history/index.md
+++ b/content/2021/history/index.md
@@ -1,5 +1,5 @@
 +++
-title="How Does The Unix `history` Command Work?"
+title="How Does the Unix `history` Command Work?"
 date=2021-05-31
 draft=false
 [taxonomies]
@@ -17,14 +17,14 @@ in Rust and throw it away again in the end as we uncover the truth.
 {{ <figure page={page} src="hero.jpg" credits="Cozy attic created by [vectorpouch](https://www.freepik.com/vectors/poster) and tux created by [catalyststuff](https://www.freepik.com/vectors/baby) &mdash; freepik.com" /> }}
 
 As the day is winding down, I have a good hour just to myself.
-Perfect time to listen to some [Billie Joel](https://www.youtube.com/watch?v=cJtL8vWNZ4o) (it's either Billie Joel or Billie Eilish for me these days) and learn how the Unix `history` command works.
+Perfect time to listen to some [Billy Joel](https://www.youtube.com/watch?v=cJtL8vWNZ4o) (it's either Billy Joel or Billie Eilish for me these days) and learn how the Unix `history` command works.
 Life is good.
 
 Learning what makes Unix tick is a bit of a hobby of mine.  
 I covered [yes](/2017/yes/), [ls](/2018/ls/), and [cat](/2018/fastcat/) before.
 Don't judge.
 
-## How does history even work?
+## How Does history Even Work?
 
 Every command is tracked, so I see the last few commands on my machine when I run `history`.
 
@@ -37,7 +37,7 @@ Every command is tracked, so I see the last few commands on my machine when I ru
 8685  vim index.md
 ```
 
-## Yeah, but how does it _do_ that?
+## Yeah, but How Does It _Do_ That?
 
 The manpage on my mac is not really helpful &mdash; I also couldn't find much in the first place.
 
@@ -312,7 +312,7 @@ We open a new shell and run a few commands followed by `history`:
 
 ✨ **Yay.** ✨ [The source code for `past` is on Github.](https://github.com/mre/past)
 
-## How it _really_ _really_ works
+## How It _Really_ _Really_ Works
 
 Our experiment was a great success, but I since learned that reality is a bit different.
 
@@ -362,14 +362,14 @@ to prevent the history from getting too big. ([See here](https://github.com/zsh-
 That's smart! Without the ring-buffer, a malicious user could just thrash the history with random commands
 until a buffer overflow is triggered. I never thought of that.
 
-## History time (see what I did there?)
+## History Time (See What I Did There?)
 
 The original `history` command was added to the Unix C shell (csh) in 1978.
 Here's a link to [the paper](https://web.archive.org/web/20220605000427/http://www.kitebird.com/csh-tcsh-book/csh-intro.pdf) by [Bill Joy](https://en.wikipedia.org/wiki/Bill_Joy) (hey, another Bill!).
 He took inspiration from the `REDO` command in Interlisp.
 You can find its specification in the original Interlisp manual in [section 8.7](https://larrymasinter.net/86-interlisp-manual-opt.pdf).
 
-## Lessons learned
+## Lessons Learned
 
 - Rebuild what you don't understand.
 - The history file is human-readable and pretty straightforward.
diff --git a/content/2021/oss-money/index.md b/content/2021/oss-money/index.md
index b9b50d6d..ee54a038 100644
--- a/content/2021/oss-money/index.md
+++ b/content/2021/oss-money/index.md
@@ -1,5 +1,5 @@
 +++
-title="So You Want To Earn Money With Open Source"
+title="So You Want to Earn Money with Open Source"
 date=2021-01-04
 [taxonomies]
 tags=["business"]
diff --git a/content/2021/sleep/index.md b/content/2021/sleep/index.md
index 2c7198c7..6b165110 100644
--- a/content/2021/sleep/index.md
+++ b/content/2021/sleep/index.md
@@ -26,11 +26,11 @@ I mean, everyone has a solid grasp on how it works, right?
 
 Exactly one second passes.
 
-## Did exactly one second pass!?
+## Did Exactly One Second Pass!?
 
 Probably? I don't care.
 
-## Why should I care?
+## Why Should I Care?
 
 If you write a shell script then you probably shouldn't care!
 Unless your program depends on precise timing.
@@ -73,7 +73,7 @@ Uh oh.
 If you say that this is ridiculous because no one should be depending on such accurate timings in a shell script, **you're correct**!
 Let's just say it's fun to test the limits okay?
 
-## How long does sleep 1 take?
+## How Long Does sleep 1 Take?
 
 ```sh
 time sleep 1
@@ -82,7 +82,7 @@ sleep 1  0.00s user 0.00s system 0% cpu 1.007 total
 
 Hold on! So both the user time _and_ the system time is 0, but the total time is 1.007 seconds!?
 
-[Here's refresher on the the output](https://stackoverflow.com/a/556411/270334):
+[Here's refresher on the output](https://stackoverflow.com/a/556411/270334):
 
 - User is the amount of CPU time spent in user-mode code (outside the kernel)
 - System is the amount of CPU time spent in the kernel
@@ -101,8 +101,8 @@ ps ax -p 39829 | grep sleep                       ✘
 39829 s011  S      0:00.00 sleep 1000
 ```
 
-## How does it work?
+## How Does It Work?
 
-## How does it really work?
+## How Does It Really Work?
 
-## How does it really really work?
+## How Does It Really Really Work?
diff --git a/content/2021/uber-of-poland/index.md b/content/2021/uber-of-poland/index.md
index 64bd939f..cb5c8fbc 100644
--- a/content/2021/uber-of-poland/index.md
+++ b/content/2021/uber-of-poland/index.md
@@ -50,7 +50,7 @@ customers. While they start as exact copies of their well-known counterparts,
 some of them end up offering better service thanks to their understanding of the
 local market.
 
-## People always find a way
+## People Always Find a Way
 
 With creativity, you can provide great service even without a big budget. The
 important part is to know which corners you can cut while staying true to your
diff --git a/content/2022/alloc/index.md b/content/2022/alloc/index.md
index 4799dca2..cab8577a 100644
--- a/content/2022/alloc/index.md
+++ b/content/2022/alloc/index.md
@@ -28,7 +28,7 @@ educational to learn more, however!
 So this is for everyone who wants to know more about <u>allocations</u> in
 <u>Rust</u>.
 
-## Table Of Contents
+## Table of Contents
 
 ## Why Should I Care?
 
@@ -41,7 +41,7 @@ isn't that something that the compiler and runtime takes care of?
 Indeed it is very convenient to use a language that takes care of memory
 management, until you hit a wall:
 And it can be frustrating if to wrangle with the language's limitations in the
-face of a performance bottleneck, a memory leak, or a hardward limitation.
+face of a performance bottleneck, a memory leak, or a hardware limitation.
 You silently might nod in agreement if you've ever been in such a situation.
 
 Rust, in contrast, never hides any low-level details from you.
@@ -57,7 +57,7 @@ around every corner.
 In summary, Rust is a great language to learn more about memory management,
 because it's safe but does not hide any details from you.
 
-## What's An Allocation?
+## What's an Allocation?
 
 The origin of _allocation_ is not widely known, despite being commonly used.
 The word comes from _Vulgar Latin_ [_allocare_](https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html), from _ad-_ ("to") + _locus_ ("place").
@@ -338,7 +338,7 @@ Further Reading:
 Rustonomicon - The Perils Of Ownership Based Resource Management (OBRM)
 https://doc.rust-lang.org/nomicon/obrm.html
 
-## Deciding Where To Allocate: The `Sized` Trait
+## Deciding Where to Allocate: The `Sized` Trait
 
 In Rust, anything can be put on the heap. However, if a type implements
 [`Sized`](https://doc.rust-lang.org/std/marker/trait.Sized.html), it can also be
@@ -386,7 +386,7 @@ rg -e 'String::new' \
 On top of that, crates that you use could also allocate, so you have to inspect
 that code as well.
 
-## How Do Allocations Work In Rust?
+## How Do Allocations Work in Rust?
 
 As seen above, there are data structures that implicitly allocate memory on the
 heap.
@@ -591,7 +591,7 @@ What if you need to allocate memory but you want to limit the number of
 allocations?
 In this case you can reuse existing allocations.
 
-#### Trick 1: Allocate The Right Amount Of Memory Up Front
+#### Trick 1: Allocate the Right Amount of Memory Up Front
 
 The first trick is to use methods like `with_capacity`
 if you already know how much memory you'll need.
@@ -614,7 +614,7 @@ fn main() {
 
 `with_capacity` also exists for `Vec`, `HashMap`, `BufWriter`, `PathBuf`, etc.
 
-#### Trick 2: Cache Values To Avoid Allocations
+#### Trick 2: Cache Values to Avoid Allocations
 
 If you find that you repeatedly allocate the same value, you can cache it to
 avoid allocating it multiple times.
@@ -674,7 +674,7 @@ If you need to cache a lot of values, you can use a
 [`lru_cache`](https://docs.rs/lru-cache) to limit the number of values that are
 cached.
 
-#### Trick 3: Use A Memory Pool To Reuse Allocations
+#### Trick 3: Use a Memory Pool to Reuse Allocations
 
 If you need to allocate a lot of objects of the same type, you can use a memory
 pool to reuse the allocations.
@@ -763,7 +763,7 @@ fn main() {
 }
 ```
 
-## The Journey Of A Rust Allocation
+## The Journey of a Rust Allocation
 
 TODO
 
@@ -913,7 +913,7 @@ Furthermore, not all Rust programs are bottlenecked on allocations.
 ## When Can Allocations Be Bad?
 
 - embedded (writing a gameboy game) - high-perf code - gaming - hard realtime
-  code (predicatable performance) like low-latency audio allocations can slow down
+  code (predictable performance) like low-latency audio allocations can slow down
   the system or downright fail at runtime That is, panic on failure
   https://news.ycombinator.com/item?id=15484323
 
@@ -923,9 +923,9 @@ allocations while in-flight because malloc can fail
 So unless you're in a hot loop, you probably won't notice the difference But
 maybe you're just curious
 
-If you use dynamic memory alloc, you're dependend on the state of the system:
-memory fragementation (if you need one block of memory), garbage collection,...
-Not using allocs can make your code more predicatable. The important thing you
+If you use dynamic memory alloc, you're dependent on the state of the system:
+memory fragmentation (if you need one block of memory), garbage collection,...
+Not using allocs can make your code more predictable. The important thing you
 gain is determinism. Malloc can become slow under memory pressure. Calling
 malloc can fail, leading to an out of memory condition. Avoiding allocation
 reduces the set of scenarios where you can encounter performance degradation.
@@ -937,7 +937,7 @@ inherently unsafe and can lead to catastrophic errors if you don't pay very
 close attention. This makes performance optimizations way more fun! See also
 https://brson.github.io/rust-anthology/1/where-rust-really-shines.html
 
-## How To Measure Allocations?
+## How to Measure Allocations?
 
 Before you jump right in and try to avoid all allocations, is crucial to not get trapped by
 premature optimization.
@@ -993,12 +993,12 @@ Instructions on tcmalloc https://github.com/jmcomets/tcmalloc-rs
 
 mimalloc by Microsoft https://github.com/purpleprotocol/mimalloc_rust
 
-## How To Reduce Allocations
+## How to Reduce Allocations
 
-If you reached this point, you're either curios, or you have a real allocation problem.
+If you reached this point, you're either curious, or you have a real allocation problem.
 The easiest way to avoid allocations is to get rid of your code. It sounds obvious, but removing code-paths by cleaning up your codebase is the easiest way to save up on allocations.
 
-## Built-in methods in the standard library
+## Built-in Methods in the Standard Library
 
 common datastructures (a.k.a [collections](https://docs.rust-embedded.org/book/collections/)): String, Vec, HashMap, PathBuf vs &str, slice, Path
 
@@ -1167,7 +1167,7 @@ https://github.com/sebastiencs/shared-arena
 
 helpful with frequent, small allocations with short lifespans
 
-## How To Deny Allocations Altogether
+## How to Deny Allocations Altogether
 
 - cargo plugins to fail on allocs
 
@@ -1189,14 +1189,14 @@ helpful with frequent, small allocations with short lifespans
 
 String interning https://github.com/servo/string-cache
 
-## Real world articles / further reading
+## Real World Articles / Further Reading
 
 - [A Journey in Optimizing
 - `toml_edit`](https://epage.github.io/blog/2021/09/optimizing-toml-edit/)
 - [Making slow Rust code
 - fast](https://patrickfreed.github.io/rust/2021/10/15/making-slow-rust-code-fast.html)
 
-## Can I limit the amount of memory used by my program?
+## Can I Limit the Amount of Memory Used by My Program?
 
 - https://github.com/alecmocatta/cap
 - https://github.com/nnethercote/dhat-rs
@@ -1218,12 +1218,12 @@ https://github.com/cmyr/cargo-instruments
 Heap memory usage estimation (`data_size(&example)` prints an estimate of the number of bytes used by `example` on the heap):
 https://github.com/CasperLabs/datasize-rs
 
-### Logging allocations
+### Logging Allocations
 
 https://github.com/Geal/tracing_allocator
 https://github.com/tobz/tracking-allocator
 
-### Something fun
+### Something Fun
 
 A Rust allocator which makes sound when active, like a Geiger counter.
 https://github.com/cuviper/alloc_geiger
@@ -1232,7 +1232,7 @@ https://github.com/cuviper/alloc_geiger
 
 When a value goes out of scope
 
-## What is the Rust standard allocator
+## What Is the Rust Standard Allocator
 
 As of Rust 2018 it's the system allocator by default.
 On Linux it is
@@ -1241,7 +1241,7 @@ and on macos
 
 Before that it used to be jemalloc, but that...
 
-## Which one is the fastest alternative to the default allocator?
+## Which One Is the Fastest Alternative to the Default Allocator?
 
 It depends on your use-case
 
@@ -1269,7 +1269,7 @@ https://github.com/rust-lang/rust/issues/48043
 You can try to reserve space for a vector now:
 https://doc.rust-lang.org/std/vec/struct.Vec.html#method.try_reserve
 (added it Rust 1.57)
-This will retrun a `Result<(), TryReserveError>`, which you can handle.
+This will return a `Result<(), TryReserveError>`, which you can handle.
 
 There is
 https://docs.rs/fallible_collections/latest/fallible_collections/
@@ -1290,15 +1290,15 @@ fn main() {
 
 In nightly there is a new [set_alloc_error_hook](https://doc.rust-lang.org/std/alloc/fn.set_alloc_error_hook.html) function that you can use to specify a function to call when an allocation fails.
 
-## Where Is The Code For Allocators In Rust?
+## Where Is the Code for Allocators in Rust?
 
 https://github.com/rust-lang/rust/tree/master/library/alloc
 
-## What Is A Memory Leak And Can It Happen In Rust?
+## What Is a Memory Leak and Can It Happen in Rust?
 
 A memory leak is when a program allocates memory but never frees it.
 
-## Can I "see" memory allocations in Rust?
+## Can I "see" Memory Allocations in Rust?
 
 You can look at the MIR (medium intermediate representation)
 https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=27235b1815171c24c6da8d1e7dc04e8f
diff --git a/content/2022/look/index.md b/content/2022/look/index.md
index 4fcf9237..15e3cbae 100644
--- a/content/2022/look/index.md
+++ b/content/2022/look/index.md
@@ -1,5 +1,5 @@
 +++
-title="The `look` Unix command"
+title="The `look` Unix Command"
 date=2022-08-10
 draft=true
 [taxonomies]
@@ -163,7 +163,7 @@ if ((front = mmap(NULL, (size_t)sb.st_size, PROT_READ, MAP_SHARED, fd, (off_t)0)
 An `mmap` is a read-only memory map backed by a file &mdash; - a "view" into memory if you like.
 
 
-## We can do that, too! 💪
+## We Can Do That, Too! 💪
 
 ...but please without bending pointers along the way.
 Enter [Mmap](https://docs.rs/memmap/latest/memmap/struct.Mmap.html)
diff --git a/content/2022/zerocal/index.md b/content/2022/zerocal/index.md
index 4eeae267..540b5893 100644
--- a/content/2022/zerocal/index.md
+++ b/content/2022/zerocal/index.md
@@ -45,7 +45,7 @@ Just let me send out an invite and whoever wants can show up.
 - You get the idea:
   I just want to send out an invite and get no response from you.
 
-## The nerdy, introvert engineer's solution
+## The Nerdy, Introvert Engineer's Solution
 
 💡 What we definitely need is yet another calendar app which allows us to create events and send out an invite with a link to that event!
 You probably didn't see that coming now, did you?
@@ -58,7 +58,7 @@ That's how I pitched the idea to my buddies last time.
 The answer was: "I don’t know, sounds like a solution in search of a problem."
 But you know what they say: Never ask a starfish for directions.
 
-## Show, don’t tell
+## Show, Don’t Tell
 
 That night I went home and built a website that would create a calendar entry
 from `GET` parameters.
@@ -93,7 +93,7 @@ You can then save that to a file and open it with your calendar app.
 In a sense, it's a "serverless calendar app", haha.
 There is no state on the server, it just generates a calendar event on the fly and returns it.
 
-## How I built it
+## How I Built It
 
 You probably noticed that the URL contains "shuttleapp.rs".
 That's because I'm using [shuttle.rs](https://github.com/shuttle-hq/shuttle) to host the website.
@@ -159,7 +159,7 @@ Hello World!
 Deploying the first version took less than 5 minutes. Neat!
 We're all set for our custom calendar app.
 
-## Writing the app
+## Writing the App
 
 To create the calendar event, I used the [icalendar](https://github.com/hoodie/icalendar-rs) crate (shout out to [hoodie](https://github.com/hoodie) for creating this nice library!). [iCalendar](https://en.wikipedia.org/wiki/ICalendar) is a standard for creating calendar events that is supported by most calendar apps.
 
@@ -181,7 +181,7 @@ let event = Event::new()
 
 Simple enough.
 
-## How to return a file!?
+## How to Return a File!?
 
 Now that we have a calendar event, we need to return it to the user.
 But how do we return it as a file?
@@ -235,7 +235,7 @@ impl IntoResponse for CalendarResponse {
 We just create a new `Response` object and set the `Content-Type` header to the correct MIME type for iCalendar files: `text/calendar`.
 Then we return the response.
 
-## Add date parsing
+## Add Date Parsing
 
 This part is a bit hacky, so feel free to glance over it.
 We need to parse the date and duration from the query string.
@@ -303,7 +303,7 @@ Opening it in the browser creates a new event in the calendar:
 
 And for all the odd people who don't use a terminal to create a calendar event, let's also add a form to the website.
 
-## Add a form
+## Add a Form
 
 ```html
 <form>
@@ -377,7 +377,7 @@ The calendar app is now available at [zerocal.shuttleapp.rs](https://zerocal.shu
 Now I can finally send my friends a link to a calendar event for our next pub crawl.
 They'll surely appreciate it.<sup>yeah<sup>yeah</sup></sup>
 
-## From zero to calendar in 100 lines of Rust
+## From Zero to Calendar in 100 Lines of Rust
 
 Boy it feels good to be writing some plain HTML again.  
 Building little apps never gets old.
diff --git a/content/2023/cursed-rust/index.md b/content/2023/cursed-rust/index.md
index 78444a57..69b2c9e2 100644
--- a/content/2023/cursed-rust/index.md
+++ b/content/2023/cursed-rust/index.md
@@ -1,5 +1,5 @@
 +++
-title="Cursed Rust: Printing Things The Wrong Way"
+title="Cursed Rust: Printing Things the Wrong Way"
 date=2023-11-01
 updated=2023-11-12
 draft=false
@@ -42,7 +42,7 @@ There is virtue in learning from unconventional answers to conventional question
 To some extent, this fosters new ways of thinking and problem-solving, which is
 an essential part of innovation. 
 
-## Applying The Same Principle To Learning Rust
+## Applying the Same Principle to Learning Rust
 
 One of the first examples in any book on learning Rust is the "Hello, world!"
 program.
@@ -89,7 +89,7 @@ lock `stdout` once and then use `write!`. This avoids the overhead
 of locking `stdout` for each call to `println!`. See [this article on how to write a very
 fast version of `yes`](/2017/yes/) with this trick.
 
-## Solution 2: Iterating Over Characters
+## Solution 2: Iterating over Characters
 
 ```rust
 "Hello, world!".chars().for_each(|c| print!("{}", c));
@@ -241,7 +241,7 @@ which prints the newline character in the end.
 Credit goes to [Wisha Wanichwecharungruang](https://wisha.page/posts/fun-rust-operators/) for this
 solution.
 
-## Solution 9: Unadulterated Control With Assembly
+## Solution 9: Unadulterated Control with Assembly
 
 All of these high-level abstractions stand in the way of printing things
 efficiently. We have to take back control of your CPU. Assembly is the way. No more wasted cycles.
diff --git a/content/2023/move-fast-rust/index.md b/content/2023/move-fast-rust/index.md
index 623bfe33..6728fdc4 100644
--- a/content/2023/move-fast-rust/index.md
+++ b/content/2023/move-fast-rust/index.md
@@ -59,7 +59,7 @@ business logic. However, it's not without challenges:
 Serverless has its merits for certain use cases, but for larger applications,
 you might still need some servers.
 
-## Platform-As-A-Service (PaaS)
+## Platform-as-a-Service (PaaS)
 
 Platforms like Heroku and Netlify introduced a third option – managed services
 that handle all infrastructure for you. No more infrastructure concerns; you
@@ -143,7 +143,7 @@ I would also like to mention that someone else built a similar project inspired
 by Zerocal: [kiwi](https://github.com/maheshsundaram/kiwi) by  [Mahesh Sundaram](https://github.com/maheshsundaram/), written in Deno. This is a really cool outcome. 
 
 
-### A Reader Mode For My E-Reader
+### A Reader Mode for My E-Reader
 
 My appreciation for [Firefox's reader view](https://support.mozilla.org/en-US/kb/firefox-reader-view-clutter-free-web-pages) sparked the creation of a [Reader Mode
 Proxy](/2022/readable/) for a minimalist, JavaScript-free web reading experience, particularly
diff --git a/content/2024/asking-better-questions/index.md b/content/2024/asking-better-questions/index.md
index 7ffe53d7..9772ba35 100644
--- a/content/2024/asking-better-questions/index.md
+++ b/content/2024/asking-better-questions/index.md
@@ -20,7 +20,7 @@ That got me thinking: What makes a good question?
 The other day, I reflected on that. Here's what I came up with.
 
 
-## 1. Good Questions Are Open-ended
+## 1. Good Questions Are Open-Ended
 
 Recently, we did a survey about our podcast, and someone mentioned that some questions I asked the guests were "either-or" type of questions.
 
@@ -38,7 +38,7 @@ A: "Tarantula!"
 We have to ask ourselves what we want out of the answer,
 which leads me to my second observation:
 
-## 2. Never Ask A Question If You Don't Care About The Answer
+## 2. Never Ask a Question If You Don't Care about the Answer
 
 Or to rephrase it, "Only ask things you care about."
 If you don't care about the other person's answer, why even ask?
@@ -71,7 +71,7 @@ Who knows? You might learn a thing or two about your preconceptions.
 
 Which leads to...
 
-## 3. Good Questions Reveal Something About The Person Who Answers; Bad Questions About The Person Who Asks
+## 3. Good Questions Reveal Something about the Person Who Answers; Bad Questions about the Person Who Asks
 
 It's very easy to slip into a role where you're framing people, and that lets your bias speak more about **you** than 
 the person you're talking to.
@@ -94,7 +94,7 @@ So I would even say that a good question is one that reveals something *unique*
 Q: "As an expert in X, who has been in the field for 20 years, what is one thing that people always get wrong about X?"  
 A: "People always think that X is about Y, but it's really about Z."  
 
-## 4. Good Questions Are Stacked On Top Of Each Other
+## 4. Good Questions Are Stacked on Top of Each Other
 
 Do you know the [*Five Whys*](https://en.wikipedia.org/wiki/Five_whys) technique?
 It's simple: Ask "why" five times to get to the root of the issue.
@@ -167,7 +167,7 @@ The simpler the question, the deeper the answer.
 Answering with "I don't know" is totally fine. 
 The important part is to stay curious and to be genuinely interested in the answer.
 
-## 6. Let The Winners Run And Cut Your Losses Short
+## 6. Let the Winners Run and Cut Your Losses Short
 
 Sometimes, no matter what you try, there's just nothing in a conversation.
 You might have ended up in that weird space where people are simply out of their depth
@@ -193,7 +193,7 @@ Just cut your losses, move on to the next topic.
 
 Similarly, if you notice that you both are really into a topic, just run with it.
 
-## 7. Give People Space To Think
+## 7. Give People Space to Think
 
 Pauses are powerful.
 
@@ -215,7 +215,7 @@ Often, they will stop and follow up with a much more personal answer.
 
 Use pauses to your advantage.
 
-## 8. Obvious Questions Can Be The Best Questions
+## 8. Obvious Questions Can Be the Best Questions
 
 If you look close enough, which question to ask becomes obvious.
 
@@ -264,7 +264,7 @@ The trick is to accept the answer for what it is.
 Don't be mad or angry at people who honestly answer your question.
 Be mad or angry for not asking sooner.
 
-## If You Don't Understand The Answer, Ask Again
+## If You Don't Understand the Answer, Ask Again
 
 In the past, I would often gloss over an answer and pretend I understood it.
 Turns out that it was a bad strategy:
@@ -326,7 +326,7 @@ Learn more about the person you're talking to.
 If you come prepared, you'll have an easier time asking good questions.
 Context makes good questions obvious.
 
-## The Best Follow-up To An Answer Is A Question
+## The Best Follow-Up to an Answer Is a Question
 
 Okay, you got an answer.
 Now what?
diff --git a/content/2024/follow-the-hackers/index.md b/content/2024/follow-the-hackers/index.md
index 0e464fd7..9798d664 100644
--- a/content/2024/follow-the-hackers/index.md
+++ b/content/2024/follow-the-hackers/index.md
@@ -29,7 +29,7 @@ These folks are a small subset of the population, but they have some traits that
 - They hold strong opinions on what works and what doesn't, backed by solid evidence
 - They don't care about investors, quarterly earnings reports, or politics - they purely focus on the technology's value
 
-## Catalysts For Success And Red Flags
+## Catalysts for Success and Red Flags
 
 Of course, not every hyped technology makes it big.
 Remember NFTs or Web3?
@@ -80,7 +80,7 @@ That's why I tell founders to stay slightly conservative when adopting new tech.
 The industry needs time to catch up, and big companies need specialized tools to integrate new tech into their existing systems.
 On the other side, investing early in promising technologies is a calculated risk because the writing is on the wall.
 
-## What Can You Learn From This?
+## What Can You Learn from This?
 
 Hackers are already living in the future.
 You can use that to your advantage.
diff --git a/content/2024/move-slow-and-fix-things/index.md b/content/2024/move-slow-and-fix-things/index.md
index e6904db0..0cdd0cef 100644
--- a/content/2024/move-slow-and-fix-things/index.md
+++ b/content/2024/move-slow-and-fix-things/index.md
@@ -56,7 +56,7 @@ It's just that the execution should be deliberate.
 Don't wreak havoc along the way.
 Because the time to fix what you might break rarely comes.
 
-## VCs are Not Your Friends
+## VCs Are Not Your Friends
 
 In ["Why to Not Not Start a Startup"](https://paulgraham.com/notnot.html), Paul Graham writes:
 
diff --git a/content/2024/no-matter-what/index.md b/content/2024/no-matter-what/index.md
index fa6ca8d7..8909b76b 100644
--- a/content/2024/no-matter-what/index.md
+++ b/content/2024/no-matter-what/index.md
@@ -18,7 +18,7 @@ There's a nice thing that happens when you have such a golden rule: it has rippl
 
 As a kid, it sounded like one of those "stupid" rules only grown-ups would come up with. And in fact, my parents knew that it was stupid. They did it anyway. As a kid, that made their life look extremely dull and boring. I remember pitying my dad once for being such a slave to society. Yet, they persisted because without it, things would fall apart. Skipping dinner is about way more than skipping dinner.
 
-## These Rules Are Simple, But Not Easy
+## These Rules Are Simple, but Not Easy
 
 It's a simple rule with little room for interpretation. However, it's not easy: there are times when you have to drop something else to make dinner at 6 work. That's when the rule counts the most! That's what makes or breaks it.
 
@@ -36,7 +36,7 @@ I actually suck at running. My pace isn't fast. The distance isn't far, but it's
 
 Some people won't understand when you tell them that you have to do a thing "no matter what." Instead of telling them I have to go for a run, I say I'm busy that evening. Nobody ever asks any questions.
 
-## Isn't this just a habit?
+## Isn't This Just a Habit?
 
 With "no matter what" there can be serious consequences. If you have to take care of a loved one, you can't skip a day. Or if you're an Air Traffic Controller, failure is not an option.
 
@@ -62,7 +62,7 @@ In the past, I never had any plants.
 Now our apartment is full of them.
 I love the companionship and the continuity.
 
-## What's your "NMW"?
+## What's Your "NMW"?
 
 If you already have a "no matter what" rule, you have my deepest respect.
 
diff --git a/content/2024/selling-to-developers/index.md b/content/2024/selling-to-developers/index.md
index e8e2b0a3..d952a54f 100644
--- a/content/2024/selling-to-developers/index.md
+++ b/content/2024/selling-to-developers/index.md
@@ -1,5 +1,5 @@
 +++
-title="How To Sell To Developers"
+title="How to Sell to Developers"
 date=2024-05-27
 draft=false
 [taxonomies]
@@ -26,7 +26,7 @@ Here's my advice:
 2. Seriously, don't build a product for developers.
 3. Since you'll likely ignore the first two pieces of advice, at least learn how to market to developers effectively.
 
-## What You Need to Know About Marketing to Developers
+## What You Need to Know about Marketing to Developers
 
 Here's the bitter truth. To sell to developers...
 
@@ -80,7 +80,7 @@ Think of it this way: when was the last time these companies had the chance to r
 
 And still...
 
-### Only 20% Of Companies Immediately Get It
+### Only 20% of Companies Immediately Get It
 
 From the companies I've talked to, only around 20% get it immediately. There are perhaps 30% that need a little handholding. The other 50% see it as an ad placement and want to know the click-through rate.
 
@@ -92,7 +92,7 @@ Your main constraint is the attention of developers!
 
 These folks constantly get bombarded with millions of products and don't have time to evaluate them all. They stopped actively looking for new tools a long time ago. They rely on a handful of trusted sources they follow. 
 
-## Building Trust Is The Only Way
+## Building Trust Is the Only Way
 Getting into their circle of trust is hard, and for that reason, you need to be patient and invest a lot of time into relationship building. If you can afford it, hire a developer advocate. A good one is heavily invested in open source and knows how to write for developers.
 At the very least, you need to be present in the places where developers hang out. So reach out to open source maintainers in your niche and see if you can collaborate or sponsor their projects. Don't waste cash on Google ads or other traditional marketing channels. Go where the developers are.
 
diff --git a/content/2024/the-dying-web/index.md b/content/2024/the-dying-web/index.md
index c7d3ce69..2f5086b5 100644
--- a/content/2024/the-dying-web/index.md
+++ b/content/2024/the-dying-web/index.md
@@ -90,7 +90,7 @@ Maybe it's because of Firefox's WebRTC support? Or, [maybe it's because of Chrom
 >
 > If you answered 2, then chances are you know your WebRTC stuff well, but you're probably on a Chromium browser.
 
-## How could Google get free rein?
+## How Could Google Get Free Rein?
 
 Because everyone and their car stopped testing their stuff anywhere else.
 If everyone tweaks their site for Chrome, well, of course the site will work just fine on Chrome!
@@ -99,7 +99,7 @@ More users join the bandwagon because stuff "just works" and the vicious cycle c
 I can't blame them. 
 It's easier to ride a horse in the direction it is going.
 
-## But at what cost?
+## But at What Cost?
 
 \*Elrond voice\*: We've been down this road before. (Okay, I was there.)
 We called it the *Browser Wars*: Netscape vs Internet Explorer. Netscape lost and Microsoft ruled over the web with an iron fist. It wasn't fun.
@@ -114,7 +114,7 @@ All we got in return was quirks mode.
 
 Google is smarter! They break the web, too, but they make you stand inside the fire.
 
-## Why should I care about a browser? They are all the same anyways.
+## Why Should I Care about a Browser? They Are All the Same Anyways.
 
 ...says the developer who gets [tracked by Google](https://www.forbes.com/sites/zakdoffman/2024/06/16/google-chrome-tracking-on-windows-android-iphone-for-200-more-days/) 
 every waking moment.
@@ -131,7 +131,7 @@ Lately, the uBlock Origin team just threw in the towel and [stopped supporting C
 But did anyone decide to jump ship?
 I get the feeling that by now people turn a blind eye to Google's evil practices.
 
-## But shouldn't Brave, Edge, Opera, or Vivaldi be sufficient?
+## But Shouldn't Brave, Edge, Opera, or Vivaldi Be Sufficient?
 
 Unfortunately not. They all use the [same browser engine](https://www.chromium.org/blink/) under the hood.
 Browser makers make mistakes, so this engine is not perfect.
diff --git a/content/2025/best-programmers/index.md b/content/2025/best-programmers/index.md
index 85262b99..e78858ca 100644
--- a/content/2025/best-programmers/index.md
+++ b/content/2025/best-programmers/index.md
@@ -44,7 +44,7 @@ For example, if you are a backend engineer and you make heavy use of Kafka,
 I expect you to know a lot about Kafka -- not just things you read on Reddit.
 At least that's what I expect if you want to be one of the best engineers.
 
-## Read The Error Message
+## Read the Error Message
 
 As in **Really Read the Error Message and Try to Understand What's Written**.
 Turns out, if you just sit and meditate about the error message, it starts to speak to you.
@@ -69,7 +69,7 @@ breaking down problems.
 If you do it right, it will feel like cheating:
 you just solve simple problems until you're done.
 
-## Don't Be Afraid To Get Your Hands Dirty 
+## Don't Be Afraid to Get Your Hands Dirty
 
 The best devs I know read a lot of code and they are not afraid to touch it.
 They never say "that's not for me" or "I can't help you here."
diff --git a/content/2025/building-up-and-sanding-down/index.md b/content/2025/building-up-and-sanding-down/index.md
index cdd0f5ba..fceec7ed 100644
--- a/content/2025/building-up-and-sanding-down/index.md
+++ b/content/2025/building-up-and-sanding-down/index.md
@@ -1,5 +1,5 @@
 +++
-title="Building Up And Sanding Down"
+title="Building Up and Sanding Down"
 date=2025-10-31
 draft=false
 [taxonomies]
diff --git a/content/2025/how-to-review-code/index.md b/content/2025/how-to-review-code/index.md
index 34b7b2f4..89f4a0a0 100644
--- a/content/2025/how-to-review-code/index.md
+++ b/content/2025/how-to-review-code/index.md
@@ -1,5 +1,5 @@
 +++
-title="How To Review Code"
+title="How to Review Code"
 date=2025-08-06
 draft=false
 [taxonomies]
@@ -17,7 +17,7 @@ It's what I get paid to do, alongside systems design.
 Over time, I learned a thing or two about how to review code effectively.
 I focus on different things now than when I started.
 
-## Think About The Big Picture
+## Think about the Big Picture
 
 Bad reviews are narrow in scope.
 They focus on syntax, style, and minor issues instead of maintainability and extensibility. 
@@ -124,7 +124,7 @@ fn update_player_stats(player: Player, bonus_points: i32, level_up: bool) -> Pla
 Good names become even more critical in larger codebases where values are declared far away from where they're used 
 and where many developers have to have a shared understanding of the problem domain.
 
-## Don't Be Afraid To Say "No"
+## Don't Be Afraid to Say "No"
 
 I have to decline changes all the time and it's never easy.
 After all someone put in a lot of effort and they want to see their work accepted.
@@ -168,7 +168,7 @@ This way, you can learn from each other's communication style.
 Building trust and getting to know each other works well this way.
 You should repeat that process later if you notice a communication breakdown or misunderstanding.
 
-## Use Multiple Iterations Of Reviews 
+## Use Multiple Iterations of Reviews
 
 "Can you take a quick look at this PR? I want to merge it today."
 There often is an expectation that code reviews are a one-time thing.
@@ -191,7 +191,7 @@ These are invaluable "aha moments" that help you grow as a developer.
 Experts spent their valuable time reviewing *my* code, and I learned a lot from it.
 I think everybody should experience that once in their career.
 
-## Don't Be A Jerk
+## Don't Be a Jerk
 
 From time to time, you'll disagree with the author.
 Being respectful and constructive is important.
@@ -216,7 +216,7 @@ Only add comments that you yourself would be happy to receive.
 From time to time, I like to add positive comments like "I like this" or "this is a great idea."
 Keeping the author motivated and showing that you appreciate their work goes a long way.
 
-## If Possible, Try To Run The Code
+## If Possible, Try to Run the Code
 
 It's easy to miss subtle details when you look at code for too long. 
 Having a local copy of the code that I can play with helps me a lot.
@@ -229,7 +229,7 @@ User-facing changes like UI changes or error messages are often easier to spot w
 After that, I revert the changes and, if needed, write down my findings in a comment.
 Better understanding can come from this approach.
 
-## Be Upfront About Your Availability 
+## Be Upfront about Your Availability
 
 Code reviews are often a bottleneck in the development process, because they can't be fully automated:
 there's a human in the loop who has to look at the code and provide feedback.
@@ -259,7 +259,7 @@ Focus on logic, design, maintainability, and correctness. Avoid subjective prefe
 
 Ask yourself: Does this affect functionality or would it confuse future developers? If not, let it go.
 
-## Focus On The Why, Not The How
+## Focus on the Why, Not the How
 
 When reviewing code, focus on the reasoning behind the changes.
 This has a much better chance of success than pointing out flaws without any reasoning. 
@@ -278,7 +278,7 @@ Which one would you prefer to receive?
 I realize that this requires more time and effort, but it's worth it!
 Most of the time, the author will appreciate it and avoid making the same mistake in the future. There is a compound effect from helpful reviews over time.
 
-## Don't Be Afraid To Ask Stupid Questions
+## Don't Be Afraid to Ask Stupid Questions
 
 Asking is better than assuming.
 If you don't understand something, ask the author to explain it.
@@ -292,7 +292,7 @@ Perhaps there's missing documentation?
 
 [Asking great questions is a superpower.](/2024/asking-better-questions/)
 
-## Ask For Feedback On Your Reviewing Style
+## Ask for Feedback on Your Reviewing Style
 
 From time to time, ask the author for feedback on your feedback: 
 
diff --git a/content/2025/reinvent-the-wheel/index.md b/content/2025/reinvent-the-wheel/index.md
index f1de0b1d..8497422a 100644
--- a/content/2025/reinvent-the-wheel/index.md
+++ b/content/2025/reinvent-the-wheel/index.md
@@ -41,7 +41,7 @@ protocols, cryptography, and web servers come to mind.
 More people should know how these things work. 
 And therefore I think people should not be afraid to recreate them. 
 
-## Everything Is A Rabbit Hole 
+## Everything Is a Rabbit Hole
 
 Too often, fundamental things are taken for granted. 
 For example strings or paths are super complicated concepts in programming.
diff --git a/content/2025/repeat-yourself/index.md b/content/2025/repeat-yourself/index.md
index 2197a043..882e05eb 100644
--- a/content/2025/repeat-yourself/index.md
+++ b/content/2025/repeat-yourself/index.md
@@ -25,7 +25,7 @@ Another reason why we avoid repetition is that it makes us feel clever.
 Both reasons are misguided.
 There are many benefits of repeating yourself that might get us closer to our goals in the long run.
 
-## Keeping Up The Momentum
+## Keeping Up the Momentum
 
 When you're writing code, you want to keep the momentum going to get into a flow state.
 If you constantly pause to design the perfect abstraction, it's easy to lose momentum.
@@ -47,7 +47,7 @@ Don't try to do both at the same time.[^1]
 This way, I get the best of both worlds: a quick feedback loop which doesn't block my creativity, and a final product which is more polished and well-structured.
 Of course, I did not invent this approach. I recommend reading "Shitty first drafts" from Anne Lamott's book [Bird by Bird: Instructions on Writing and Life](https://canongate.co.uk/books/3055-bird-by-bird-instructions-on-writing-and-life/) if you want to learn more about this technique. 
 
-## Finding The Right Abstraction Is Hard
+## Finding the Right Abstraction Is Hard
 
 When you start to write code, you don't know the right abstraction just yet.
 But if you copy code, the right abstraction reveals itself; it's too tedious to copy the same code over and over again, at which point you start to look for ways to abstract it away.
@@ -62,7 +62,7 @@ Some typical symptoms include:
 - The abstraction is only used in one or two places
 - Tight coupling to implementation details
 
-## It's Hard To Get Rid Of Wrong Abstractions 
+## It's Hard to Get Rid of Wrong Abstractions
 
 We easily settle for the first abstraction that comes to mind, but most often, it's not the right one.
 And removing the *wrong* abstraction is hard work, because now the data flow depends on it.
@@ -102,7 +102,7 @@ An expert programmer might be able to keep a few levels of abstraction in their
 When you copy code, you can keep all the logic in one place.
 You can just read the whole thing and understand what it does.
 
-## Resist The Urge Of Premature Abstraction 
+## Resist the Urge of Premature Abstraction
 
 Sometimes, code *looks* similar but serves different purposes.
 
@@ -196,7 +196,7 @@ Often you'll find a better abstraction that fits the problem better.
   <p>—Sandi Metz, <cite><a href="https://sandimetz.com/blog/2016/1/20/the-wrong-abstraction">The Wrong Abstraction</a></cite></p>
 </div>
 
-## tl;dr
+## TL;DR
 
 It's fine to look for the right abstraction, but don't obsess over it.
 Don't be afraid to copy code when it helps you keep momentum and find the right abstraction.
diff --git a/content/2026/advice-to-young-developers/index.md b/content/2026/advice-to-young-developers/index.md
index b609b71c..775e0159 100644
--- a/content/2026/advice-to-young-developers/index.md
+++ b/content/2026/advice-to-young-developers/index.md
@@ -30,7 +30,7 @@ If everyone has access to the same tools, what sets you apart is your ability to
 Pick a problem, learn the domain, and create a fast feedback loop to iterate on solutions.
 If you can solve problems faster than anyone else, you will be in high demand.
 
-## Have More Than One Skill
+## Have More than One Skill
 
 If all you know is how to code, you will be easily replaceable.
 Try to apply your knowledge in a domain that interests you.
diff --git a/content/2026/github-was-never-about-the-source-code/index.md b/content/2026/github-was-never-about-the-source-code/index.md
index 0a6550e4..db1fefef 100644
--- a/content/2026/github-was-never-about-the-source-code/index.md
+++ b/content/2026/github-was-never-about-the-source-code/index.md
@@ -1,5 +1,5 @@
 +++
-title="GitHub Was Never About the Source Code"
+title="GitHub Was Never about the Source Code"
 date=2026-08-17
 draft=false
 +++
diff --git a/content/2026/how-other-link-checkers-recurse/index.md b/content/2026/how-other-link-checkers-recurse/index.md
index b867c45a..60417ab5 100644
--- a/content/2026/how-other-link-checkers-recurse/index.md
+++ b/content/2026/how-other-link-checkers-recurse/index.md
@@ -17,7 +17,7 @@ I went and read the source of the recursive checkers we list in [lychee's README
 
 If you haven't read the [first post](@/2026/lychee-recursion/index.md), the summary is that lychee was architected as a one-shot, unidirectional pipeline (`inputs → extract → check → output`). Recursion needs a *cycle* (responses create new inputs), and cycles in an async, channel-based pipeline are where the [dragons live](@/2026/lychee-recursion/index.md). 🐲 Five years and four attempts later, the pieces we'll need to do it properly only *just* landed.
 
-## DAGs vs. cycles 
+## DAGs vs. Cycles
 
 Every recursive checker I looked at is built from the same three parts:
  
@@ -65,7 +65,7 @@ Note that the visited check happens in the **enqueue** step, atomically with the
 
 Each tool uses a variation on it.
 
-## muffet (Go): a WaitGroup and a Set
+## muffet (Go): A WaitGroup and a Set
 
 [muffet](https://github.com/raviqqe/muffet) is closest in spirit to lychee: a fast, single-binary, concurrent website checker. 
 The dedup + scheduling decision lives in one method (`page_checker.go`):
@@ -93,7 +93,7 @@ go func(u string) {
 }(u)
 ```
 
-### How muffet knows it's done
+### How muffet Knows It's Done
 
 muffet's answer to termination is a little `daemonManager` built around a `sync.WaitGroup` (`daemon_manager.go`):
 
@@ -120,7 +120,7 @@ Every scheduled page increments the group; every completed page decrements it; `
 
 This is the *same counter* I tried (and failed with) in [Attempt 1](@/2026/lychee-recursion/index.md) and [Attempt 4](@/2026/lychee-recursion/index.md). The difference is the invariant: `waitGroup.Add(1)` is only ever called from inside an already-running daemon that holds the count above zero (or from the bootstrap). There is no window where the counter briefly reads zero while work is still pending. Go's `WaitGroup` enforces this invariant so naturally that it doesn't feel like distributed termination detection at all, but that's exactly what it is. It's the moral equivalent of the `WaitGroup` primitive [Kait contributed to lychee in 2026](https://github.com/lycheeverse/lychee/pull/2046).
 
-### Where the tradeoffs are
+### Where the Tradeoffs Are
 
 - Concurrency isn't bounded by the daemon manager. `Run()` does `go f()` for every task, spawning unbounded goroutines. The actual limiting happens downstream in a `semaphore` (a buffered-channel counting semaphore) and a per-host throttler pool. muffet *separates* "the frontier" from "the rate limiter," which is exactly the separation lychee lacked when it tried to use one bounded channel as both in the past.
 - Cheap goroutines do a lot of heavy lifting. Spawning a goroutine per link is "fine" in Go. The equivalent in Rust (`tokio::spawn` per link, each needing `Send + 'static` state) is what pushed me toward `Arc<RwLock<…>>` and the ownership pain I [wrote about](@/2026/lychee-recursion/index.md#attempt-3-semaphores-february-2022).
@@ -135,7 +135,7 @@ This is the *same counter* I tried (and failed with) in [Attempt 1](@/2026/lyche
 
 {% </info> %}
 
-## LinkChecker (Python): a joinable unbounded queue 
+## LinkChecker (Python): A Joinable Unbounded Queue
 
 [LinkChecker](https://github.com/linkchecker/linkchecker) has existed since the year 2000. It's a synchronous, thread-pool crawler.
 
@@ -158,7 +158,7 @@ LinkChecker's answer is brutalist in nature: the frontier is **unbounded**.
 Backpressure is enforced elsewhere (a fixed thread count and per-host throttling), never by blocking a producer that is also a consumer.
 
 
-### Termination by counter, done right
+### Termination by Counter, Done Right
 
 `join()` blocks until `unfinished_tasks` hits zero (`urlqueue.py`):
 
@@ -179,7 +179,7 @@ def join(self, timeout=None):
 
 Again: a counter. But the increment in `_put` and the decrement in `task_done` are both inside the queue's `Condition` lock, and a worker calls `task_done` only after fully processing an item *including enqueuing its children*. So children are counted before the parent is marked done, with no premature zero. It's `WaitGroup` semantics implemented with a mutex and a condition variable.
 
-### Deduplication, before the request
+### Deduplication, before the Request
 
 LinkChecker writes the URL into its result cache at **enqueue** time (`urlqueue.py`):
 
@@ -198,7 +198,7 @@ def _put(self, url_data):
 
 That `add_result(key, None)` sentinel is a "fix" that's missing in lychee's attempts. By the time any worker thread checks the URL, the cache already says "mine," so concurrent discovery from another page is a no-op.
 
-### Per-host politeness and termination guards
+### Per-Host Politeness and Termination Guards
 
 The `Aggregate` (`director/aggregator.py`) throttles per host:
 
@@ -215,7 +215,7 @@ def wait_for_host(self, host):
 
 and `abort()` calls `urlqueue.join(timeout=…)` so a stuck crawl can't hang forever.
 
-### Where the tradeoffs are
+### Where the Tradeoffs Are
 
 - Blocking threads instead of async. Each of the (default 10–100) `Checker` threads does blocking I/O via `requests`. Simple and battle-tested, but the concurrency ceiling is the thread count, and each thread carries a full stack. lychee's Tokio model reaches thousands of concurrent in-flight requests on a handful of OS threads; LinkChecker can't, and doesn't try.
 - The unbounded frontier trades a deadlock for unbounded memory. The explicit "no max size" decision means RAM growth on huge sites. There's a `max_allowed_urls` cap and a periodic `cleanup()` to mitigate it.
@@ -245,7 +245,7 @@ await queue.onIdle();
 
 `onIdle()` is the library's termination detection: it resolves when the queue is empty *and* no task is in flight. Same idea as muffet's `WaitGroup` and LinkChecker's `join()`, just expressed as a promise and backed by a single-threaded runtime, so no Mutex is needed to protect the visited set.
 
-### The back-edge and the race-free dedup
+### The Back-Edge and the Race-Free Dedup
 
 When crawling, `crawl()` GETs the page, extracts links, and for each new URL re-enters the queue (`src/index.ts`):
 
@@ -289,7 +289,7 @@ response = await makeRequest(
 
 This is precisely [lychee's remaining open problem](@/2026/lychee-recursion/index.md#what-proper-recursion-could-look-like): you can only recurse into pages you fetched with a body. linkinator just always GETs when crawling; lychee plans to reuse the body it already has in cache from the check it just performed.
 
-### Where the tradeoffs are
+### Where the Tradeoffs Are
 
 - Single-threaded is both a blessing and a ceiling. No data races, trivially correct dedup, but HTML parsing is CPU work that blocks the one event loop. For thousands of pages, you're bound by a single core. lychee's multi-threaded runtime parses and checks in parallel.
 - It suffers from in-memory result inflation. The source explicitly comments on "massive result inflation for heavily interlinked sites": the `results` array, `cache`, and `relationshipCache` all grow with the crawl. Fine for a docs site, heavy for a giant one.
@@ -304,7 +304,7 @@ This is precisely [lychee's remaining open problem](@/2026/lychee-recursion/inde
 
 {% </info> %}
 
-## broken-link-checker (JavaScript): event-driven, using two queues
+## broken-link-checker (JavaScript): Event-Driven, Using Two Queues
 
 [broken-link-checker](https://github.com/stevenvachon/broken-link-checker) (BLC) takes the event-driven model furthest. It's built on [`limited-request-queue`](https://github.com/stevenvachon/limited-request-queue), a queue with `maxSockets` (concurrency) and `rateLimit`, and it nests **two** of them: a site-level queue feeding a page-level `HtmlUrlChecker`.
 
@@ -339,7 +339,7 @@ Recursion is governed by a filter that decides whether a discovered link becomes
 }
 ```
 
-### Termination by event cascade
+### Termination by Event Cascade
 
 BLC has no counter and no `onIdle()`. It rides the queue's drain events. When the page-level queue empties it fires `END_EVENT`, which makes `SiteChecker` emit `SITE_EVENT` and call the site queue's `done` callback; when the *site* queue drains, it fires `REQUEST_QUEUE_END_EVENT`. That's the public `END_EVENT`:
 
@@ -354,7 +354,7 @@ That's their termination detection, expressed as "the request queue reported emp
 
 And in classic Node.js fashion, the `done` callback is what actually tells the site queue to free up a slot for another site. So the termination of one site is what allows another to start, and the termination of the whole crawl is what allows the process to exit. It's a cascade of events that propagates from the page queue to the site queue to the process.
 
-### Where the tradeoffs are
+### Where the Tradeoffs Are
 
 - It's the best web citizen of the bunch. robots.txt is honored (`getRobotsTxt`, `isAllowed`), `rel=nofollow` is respected, and `rateLimit` plus `maxSockets` are first-class. This is a crawler that's polite by default.
 - Event cascades are powerful but fiddly. Termination is spread across half a dozen event handlers and two nested queues. It works, but the control flow is much harder to follow than `await queue.onIdle()`. This is the JS cousin of the "leaky abstraction" problem I described, where recursion-awareness ends up sprinkled across many handlers.
@@ -369,13 +369,13 @@ And in classic Node.js fashion, the `done` callback is what actually tells the s
 
 {% </info> %}
 
-## A note on markdown-link-check and the "industrial" crawlers
+## A Note on markdown-link-check and the "industrial" Crawlers
 
 Our README marks [markdown-link-check](https://github.com/tcort/markdown-link-check) as supporting recursion, but there's some nuance there: it recurses over *Markdown files*, not by spidering a live website. There's no HTTP frontier and no termination problem in the sense above. Worth a mention so the comparison is honest, not worth a teardown.
 
 If you want to see the pattern at full industrial scale, look at [Scrapy](https://www.scrapy.org/) (Python/Twisted) or [Colly](https://github.com/gocolly/colly) (Go). Both use the same approach: a scheduler (frontier) with a pluggable, optionally disk-backed queue, a dupefilter (often a Bloom filter rather than a `HashSet`), a bounded downloader pool, and explicit "engine idle → close spider" termination. They solve exactly the problems lychee struggled with ([distributed termination detection](https://en.wikipedia.org/wiki/Dijkstra%E2%80%93Scholten_algorithm), backpressure, dedup), just with years of dedicated crawler engineering behind them. The takeaway isn't "lychee should be Scrapy": it's that crawling is a well-trodden architecture, and lychee is simply standing on a different one right now.
 
-## Side-by-side
+## Side-by-Side
 
 {% <wide_table> %}
 | Tool | Lang / runtime | Concurrency model | Frontier | "Done?" signal | Dedup point | Per-host limiting |
diff --git a/content/2026/lychee-recursion/index.md b/content/2026/lychee-recursion/index.md
index 657db4b2..4cadb31c 100644
--- a/content/2026/lychee-recursion/index.md
+++ b/content/2026/lychee-recursion/index.md
@@ -125,7 +125,7 @@ In September 2021 we decided to do a bigger rewrite: a stream-based architecture
 
 And one honest aside on the language question, because I get asked it a lot: the counting problem here is **not Rust's fault**. A Go version with goroutines and channels, or a Python asyncio version, would hit the same off-by-one bugs. The race between "response processed" and "new requests discovered" is inherent to any concurrent recursive crawler. Rust's `Stream` trait and the way it plays with ownership made a streaming architecture feel natural, and that's what invalidated the work. So that's perhaps a Rust-specific point. 
 
-## Attempt 2: Feed It Back Through a Channel (January - July 2022)
+## Attempt 2: Feed It Back through a Channel (January - July 2022)
 
 Now that the stream architecture was in place, I took another stab at it. This time, instead of counting requests by hand, I'd [feed discovered URLs back through a *channel* connected to the collector](https://github.com/lycheeverse/lychee/pull/465).
 
@@ -306,7 +306,7 @@ After a burst of energy in January 2025, things slowed. Merge conflicts piled up
 
 > even though I was kinda denying it, it's pretty clear that I've lost motivation to keep working on this [...] I'm sorry T_T
 
-I didn't want her to apologize. She got further than anyone, on a hard feature, in a complex async codebase, as a volunteer. Instead, I'm grateful for the time she invested to push tings forward.
+I didn't want her to apologize. She got further than anyone, on a hard feature, in a complex async codebase, as a volunteer. Instead, I'm grateful for the time she invested to push things forward.
 
 {% <info title="Takeaways"> %}
 
diff --git a/content/2026/newsletter-setup/index.md b/content/2026/newsletter-setup/index.md
index 1bcc08c3..76452210 100644
--- a/content/2026/newsletter-setup/index.md
+++ b/content/2026/newsletter-setup/index.md
@@ -92,7 +92,7 @@ For a newsletter I send irregularly, that's nothing.
 
 {{ <figure page={page} src="plunk-dashboard.jpg" caption="The Plunk dashboard, showing the campaign overview and deliverability report. As you can see, I don't track who opens my emails." credits="[Plunk](https://www.useplunk.com/)" /> }}
 
-## This Feels Like Home!
+## This Feels like Home!
 
 I realized I could write issues as plain markdown files in a folder, version-controlled, with a small CLI for everything else.
 That's where I feel at home.
diff --git a/content/2026/personal-blog/index.md b/content/2026/personal-blog/index.md
index 077d89f4..6812fa2b 100644
--- a/content/2026/personal-blog/index.md
+++ b/content/2026/personal-blog/index.md
@@ -1,5 +1,5 @@
 +++
-title="Now's The Time To Start That Blog"
+title="Now's the Time to Start That Blog"
 date=2026-01-26
 draft=false
 [taxonomies]
diff --git a/content/2026/taste/index.md b/content/2026/taste/index.md
index 9cd12b03..b394bfb3 100644
--- a/content/2026/taste/index.md
+++ b/content/2026/taste/index.md
@@ -17,7 +17,7 @@ I got better at knowing what I value and what I can *take away*.
 Uncluttering brings joy.
 Maybe that's a deeply human thing?
 
-## Screenshots of my blog's design over the years
+## Screenshots of My Blog's Design over the Years
 
 {{ <figure page={page} src="2007.jpg" caption="2007" /> }}
 {{ <figure page={page} src="2011.jpg" caption="2011" /> }}
diff --git a/content/2026/why-i-still-believe-in-mentorship/index.md b/content/2026/why-i-still-believe-in-mentorship/index.md
index d1bc0731..1ea9c835 100644
--- a/content/2026/why-i-still-believe-in-mentorship/index.md
+++ b/content/2026/why-i-still-believe-in-mentorship/index.md
@@ -35,7 +35,7 @@ A session where a machine fixes everything is productive, but being productive a
 
 This is part of why I still believe in mentorship, even now that an LLM can answer so many programming questions.
 
-## Going beyond the superficial questions
+## Going beyond the Superficial Questions
 
 I run a one-on-one [Rust mentorship program](https://corrode.dev/mentorship/), so I have a personal stake in this.
 Most of my mentees come with a concrete question: