Full Width [alt+shift+f] Shortcuts [alt+shift+k]
Sign Up [alt+shift+s] Log In [alt+shift+l]
14

Getting A Local Mastodon Setup In Docker

from These Yaks Ain't Gonna Shave Themselves [alt+shift+b] in programming

This is the first in probably a series of posts as I dig into the technical aspects of mastodon. My goal is to get a better understanding of the design of ActivityPub and how mastodon itself is designed to use ActivityPub. Eventually I want to learn enough to maybe do some hacking and create some of the experiences I want that mastodon doesn’t support today. The first milestone is just getting a mastodon instance set up on my laptop. I’m gonna give some background and context. If you want to skip straight to the meat of things, here’s an anchor link. Some background Mastodon is a complex application with lots of moving parts. For now, all I want is to get something running so I can poke at it. Docker should be a great tool for this. Because a lot of that complexity can be packaged up in pre-built images. I tried several times using using the official docs and various other alternative projects to get a working mastodon instance in docker. But I kept running into problems that were hard to understand and harder to resolve. I have a lot to learn about all the various pieces of mastodon and how they fit together. But I understand docker pretty well. So after some experimenting, I was able to get an instance running on my own. The rest of this post will be dedicated to explaining what I did and what I learned along the way. One final note. I know many folks work hard to write docs and provide an out of the box dev experience that works. This isn’t meant to dismiss that hard work. It just didn’t work for me. I’m certainly going to share this experience with the mastodon team. Hopefully these lessons can make the experience better for others in the future. The approach Here’s the outline of what we’re doing. We’re going to use a modified version of the docker-compose.yml that comes in the official mastodon repo. It doesn’t work out of the box. So I had to make some heavy tweaks. As of this writing, the mastodon docs seem to want people to use an alternate...
2nd Jun 2024

Stay updated

Get a weekly newsletter with the top 5 articles worth reading every week.

More from These Yaks Ain't Gonna Shave Themselves

Running Pull Requests in Github Codespaces

Earlier this week, I was having a lot of trouble understanding how to get Dev Containers working. Dev Containers are the required way to enable Github Codespaces, which was my actual goal. I finally got to something that works, so I want to document what I learned. Dev Containers is a standard developed my Microsoft for using docker containers to run dev environments for a project. I use Docker for most of my projects these days. I think it’s a great tool both for simplifying local development and for packaging and deploying my projects. In the current project, I already have a Dockerfile and a docker-compose.yml file. I deploy to fly.io which will also run my docker build to deploy the project. This works fine for me, and I had never used Dev Containers. It seemed overly complicated (and I was right about that). I want to give more of the context about why I’ve been pursuing github codespaces, because I think it’s relevant. But if you wanna skip to the tips for getting Dev Containers and Codespaces working, feel free. (I’m also going to talk positively about using LLMs to code, so if that makes you want to skip too, there’s no hard feelings). Background Here’s the idea. I have a solo project that I’m working on, and instead of hacking away on the main branch, I’m using a full feature branch and pull request workflow to keep my changes organized. This might seem like overkill, but it’s helpful for me because I tend to bounce around and leave things half done. I can run things locally and test different things by switching between branches. But I’m also doing a lot more AI-assisted development. Locally I use Claude Code. But I’ve been experimenting with allowing Github Copilot to create PRs. I create a github issue, assign it to copilot, and it spins up in the cloud and does work. Afterwards it opens a pull request for me to review. So even though this is a “solo” project, I end up with pull requests that I didn’t write myself and I need to validate. Giving tasks to copilot in the cloud is cool for a couple of reasons: It’s better than setting an LLM lose on my laptop unsupervised. I’m still working on how to use them safely. When I’m using them locally, I babysit diligently and approve every command it wants to run. But this gets tedious, and that can only lead to cutting corners. With github codespaces, I can make it github’s problem. I get to work on the project even if I can’t sit in front of my computer. When I get excited about a project, I tend to think about it constantly. It’s tough to compartmentalize when I’m having ideas but I’ve got other things to do. The workflow of creating issues and assigning them to copilot helps me move forward even in-between work sessions. I plan to give more of my thoughts on AI-assisted development in a future post. The result is I’ve got PRs from copilot that I need to review. I can look at the diffs, but we know that even if it “looks good to me”,LLMs can and do make subtle mistakes and require extra scrutiny. What I want to do is actually spin up the app with the changes and kick the tires. Github codespaces seemed perfect for this. But it took a lot of trial and error to get to something that works for me. Leaning on docker and docker compose We need to take a slight detour before diving into Dev Containers. We will be using docker and docker compose to help us bypass some of the complexity. So this post assumes that you have a working setup using docker-compose.yml. I’m not going to go into detail about that here. If you’re interested, maybe I can do a future blog post. Your docker compose setup should also include a database if you need one. Most apps like mine require a database to connect to. There are lots of ways you can go about this locally. In fact, if you’ve got a local setup using docker compose, you’ve probably already figured this out. But there will also need to be a database available once we upload to a github codespaces environment. So for that purpose, this post also assumes that you have a database container alongside your app container. It usually looks something like this for me (stripped down for brevity). services: app: image: my-app container_name: my-app build: context: . dockerfile: Dockerfile ports: - "3000:3000" env_file: - .env postgres: image: postgres:17-alpine container_name: my-app-db environment: POSTGRES_DB: my_app POSTGRES_USER: postgres POSTGRES_PASSWORD: password ports: - "5432:5432" volumes: - ./backend/data/db:/var/lib/postgresql/data Note: There are a lot of other details to configuring a non-trivial docker compose environment. That’s out of the scope of this post. Sorry. This creates an app that uses my project files to build a docker image. The database is pulled from an existing docker image that runs postgres. The resulting app can reference postgres as the hostname of the database. Docker automatically creates an internal network where the two containers can see each other. Because we’re going to have Dev Containers read our docker-compose.yml from the start, this should work as expected. Getting a Dev Container working This walkthrough assumes you have a few prerequisites already installed: vs code Dev Containers extension for vs code Docker Note: The Dev Containers extension uses your local docker system to build and run containers. If you run into early issues, check that docker is running and that vs code has permission to access it. Reading the docs for Dev Containers seemed straightforward enough. I used the vs code worflow to create a devcontainer.json file. But nothing worked out of the box. It came with it’s own docker-compose.yml file. It wanted me to use a standard Microsoft docker image for the environment rather than the one specified in my own Dockerfile. I’m pretty sure we’re mostly expected to run their pre-built templates for dev containers. You pick the one that seems to match your project most closely, and it’ll probably work by just injecting your code into it. But if you want to be more opinionated about your build, you’re gonna have a bad time. Eventually, I abandoned trying to figure this out and instead configured the dev container to just use the existing docker setup I aleady had. Open your command palette and select “Dev Containers: Add Dev Container Configuration Files…”. You might run through a couple of options like whether to add the dev container files to the workspace or the user config. I chose workspace. Then you’ll be prompted to choose what approach you want to take to create the dev container configuration. You’ll see the option to create it from a predefined template. But what you want to do is select the From 'Dockerfile' option or the From 'docker-compose.yml' option. The trick is that these options only appear if these files are already present in your project. When I tried to recreate what I did for this blog post, I got tripped up by that. If you wanna get started with this before you tackle the docker stuff, you can just touch Dockerfile docker-compose.yml in your project root and that’s enough to enable the menu items. However, the setup may error at some point if there’s nothing in the files. Creating a Dev Container config through vs code The second confusing thing is it asks you to “chose a service”. There is very little context here for what service to choose and why. You’ll see this prompt, because you have to pick one of the services to be the “primary” one for the dev container. Say your docker compose file specifies multple containers, like a web app, a database, and maybe a background worker. You probably want to choose whichever one is the main app. So for example, I selected app, which is the name in my docker-compose.yml that runs the node server. When you run through these setup prompts, you end up with a devcontainer.json that is pretty different from the one you see from the standard tutorials. Instead of having a bunch of setup for your project in the config file, it just references your docker-compose.yml file. // For format details, see https://aka.ms/devcontainer.json. For config options, see the // README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-docker-compose { "name": "Project name", // Update the 'dockerComposeFile' list if you have more compose files or use different names. // The .devcontainer/docker-compose.yml file contains any overrides you need/want to make. "dockerComposeFile": [ "../docker-compose.yml", "docker-compose.yml" ], // The 'service' property is the name of the service for the container that VS Code should // use. Update this value and .devcontainer/docker-compose.yml to the real service name. "service": "app", ... Notice that you’ll see two docker-compose.yml files. The first one is your existing file. Assuming it’s in the root of your project, it gets referenced from inside the .devcontainer folder. The second one is a custom override created by the dev container setup. It lives inside the .devcontainer folder. Leave that as-is. From here, you can add “features” to the dev container and any other things you might want from the setup wizard. For example, I added the PostgreSQL client so that I can use it to connect to my database from inside the dev container. Finally, you’ll choose to expose any ports that your app exposes. These might be added automatically if it exists in your Dockerfiles. Here is the full version of the devcontainer.json that currently works for my project: // For format details, see https://aka.ms/devcontainer.json. For config options, see the // README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-docker-compose { "name": "Project name", // Update the 'dockerComposeFile' list if you have more compose files or use different names. // The .devcontainer/docker-compose.yml file contains any overrides you need/want to make. "dockerComposeFile": [ "../docker-compose.yml", "docker-compose.yml" ], // The 'service' property is the name of the service for the container that VS Code should // use. Update this value and .devcontainer/docker-compose.yml to the real service name. "service": "app", // The optional 'workspaceFolder' property is the path VS Code should open by default when // connected. This is typically a file mount in .devcontainer/docker-compose.yml "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}", // Features to add to the dev container. More info: https://containers.dev/features. "features": { "ghcr.io/devcontainers/features/aws-cli:1": {}, "ghcr.io/devcontainers/features/github-cli:1": {}, "ghcr.io/devcontainers/features/node:1": {}, "ghcr.io/devcontainers-extra/features/ripgrep:1": {}, "ghcr.io/robbert229/devcontainer-features/postgresql-client:1": {} }, // Use 'forwardPorts' to make a list of ports inside the container available locally. "forwardPorts": [ 3000 ] // Uncomment the next line if you want start specific services in your Docker Compose config. // "runServices": [], // Uncomment the next line if you want to keep your containers running after VS Code shuts down. // "shutdownAction": "none", // Uncomment the next line to run commands after the container is created. // "postCreateCommand": "cat /etc/os-release", // Configure tool-specific properties. // "customizations": {}, // Uncomment to connect as an existing user other than the container default. More info: https://aka.ms/dev-containers-non-root. // "remoteUser": "devcontainer" } Note: As of this writing, it looks like you can only get Node version 22 as a feature in the official Microsoft images. If you need other versions of node, you can get them from third-party community builds. From here you should be able to tell vs code to Open Workspace in Container. You’ll see it spin up and you’ll see a bunch of logs. If it’s working properly, you’ll see it build an image from your dockerfile and then spin up the containers. Eventually the vs code terminal will open, and you’ll be dropped into a bash prompt inside your dev container. Success! But obviously it’s not gonna work the first time. I had to debug several issues first. Required files should be optional Because I was only using docker compose for local development up to this point, I had my local .env file referenced in the docker-compose.yml under the env_file property. services: app: image: my-app container_name: my-app build: context: . dockerfile: Dockerfile ports: - "3000:3000" env_file: - backend/.env The problem is that by default, this file is required. If it’s not present, docker compose will error. When you go to build the dev container, this file may not be present. Probably because you put it in .gitignore so you didn’t accidently check it into version control. This is the right thing. So the fix here is to use the extended format to specify that the env_file is optional. services: app: image: my-app container_name: my-app build: context: . dockerfile: Dockerfile ports: - "3000:3000" env_file: - path: backend/.env required: false Adding your env variables back to the build Because Dev Containers won’t have your .env file, you’ll need to add the environment variables directly to the docker-compose.yml. Yes this is redundant, but I don’t know a cleaner alternative. Make sure you’re only adding standard env variables and not secrets. Secrets will go elsewhere, but they’re fine in the .env for now. According to the docker compose docs, you can have both env_file and environment specified in your config, but entries in environment will always take precedence. So you can have your .env file for local development and the environment entries for when it gets pushed to github. services: app: image: my-app container_name: my-app build: context: . dockerfile: Dockerfile ports: - "3000:3000" environment: PORT: "3000" AWS_REGION: us-west-2 S3_BUCKET_NAME: bucket-dev SENTRY_DSN: "..." env_file: - path: backend/.env required: false Note: You can also add environment variables directly to the devcontainer.json. But I didn’t try this and YMMV. Build args are different from environment variables My project uses Hono for the backend. The frontend uses the Vue framework and gets built for production using Vite. If you’ve dealt with Vite, you know it has a specific workflow for how to get environment variables into your frontend. When you prefix your environment variables with VITE_, they get built into your frontend bundle at build time. For example if you use S3_BUCKET_NAME on the backend, you have to use VITE_S3_BUCKET_NAME in frontend code. You may be more familiar with NEXT_S3_BUCKET_NAME in Nextjs. Same deal. When you use vite locally, it knows how to find the build variables in your .env file, and it just works. But when you’re using docker, these variables need to be present when the Dockerfile is being built. This can be a pain to figure out even without the added complexity of Dev Containers. I’ll just give you the answer here. The short version is that you reference the the vite variables as docker “build args”, then you inject them into the environment during the docker build. ARG VITE_S3_BUCKET_NAME ENV VITE_S3_BUCKET_NAME=$VITE_S3_BUCKET_NAME RUN npm run build ... Then you need to add these build args to your docker-compose.yml in the build section so they get passed into the Dockerfile execution. Yes this is redundant, but I don’t know a cleaner alternative. And once again, make sure you’re only adding standard build variables and not secrets. services: app: image: my-app container_name: my-app build: context: . dockerfile: Dockerfile args: VITE_S3_BUCKET_NAME: "bucket-dev" VITE_SENTRY_DSN: "..." ports: - "3000:3000" environment: PORT: "3000" AWS_REGION: us-west-2 S3_BUCKET_NAME: bucket-dev SENTRY_DSN: "..." env_file: - path: backend/.env required: false Note: You can also add build args manually using the cli. docker build --build-arg "VITE_S3_BUCKET_NAME=..." There may be other changes you need to make to your docker compose setup. But these are the major issues I ran into that related to Dev Containers specifically. If you’re lucky, you should be able to spin up a dev container for your project locally and try it out. Next we have to get this to work with github codespaces. Which of course requires even more steps. Note: If your dev container spins up, but your app doesn’t work, make sure the app can connect to the database, and make you’ve actually populated the database. It’s probably still empty! Getting Your dev Container working in Github Codespaces Once you’ve got a dev container working locally, you can check all of the config files into github and push it. This includes the .devcontainer folder and any changes you had to make to Dockerfile and docker-compose.yml. I did this in a branch at first. Mostly because I wasn’t confident enough yet to drop it into main. But also because I was explicitly looking for this to work on pull requests. Creating a codespace Github will recognize your .devcontainer folder in your project and allow you to create a codespace. But if you’re working in a private repo, you may need to make sure to enable codespaces first. Then you can go to your repo page and look for codespaces under the green “Code” button on the top right. Click to create a codespace, and make sure you select the appropriate branch that you want to use. The codespace will clone that git branch into the environment before running the build. The Codespaces docs do a decent job of introducing this stuff, so I won’t go into detail here. We’ve done most of the heavy lifting with the local Dev Container setup. Where to create new codespaces Adding secrets You can try to spin up a codespace in github, but it probably won’t quite work yet. Codespaces works almost like using Dev Containers locally. It can find your environment variables in your docker-compose.yml files. But it can’t find any secrets. Those have to be injected by github. Codespaces has it’s own separate space for variables and secrets. See this screenshot of the settings menu. Where to add secrets in github settings Once you’ve got the secrets in, try rebuilding your codespace to pick them up. Running the app When using docker containers, you usually specify a default command to run when the container starts up. This is usually where you start your web server. By default, Dev Containers overrides your command. Instead they add a simple command that just sleeps and keeps the codespace up and running so you can connect to it. What this means is that your app is not running by default. You’ll have to go into the codespace terminal and run it. For me it’s just an npm script. npm run start This is important because you want github to create a unique url for you to access your app from the web browser. That doesn’t happen until the codespace detects that a port is being used. You can leave your terminal running with your app, or you can put it in the background and manage it with something like systemd. Depends on how sophisticated you wanna get. Wrapping up Hooray! Hopefully you’ve successfully got a github codespace running your app. Github will give you a unique, generated url to access it. And you should be able to spin one up against any branch or pull request. I hope this saves someone some headaches when getting Github Codespaces working. Once you get it going, it’s very cool and useful. Unfortunately I don’t have any advice for getting this working if you don’t already have your own docker setup. But the docker approach isn’t well documented in the searches I did, so this is my contribution to fixing that.

23rd Oct 2025 • 24 votes
How to Build Fly Locally With Docker for Mac

In my recent side projet, I’ve been deploying to fly.io and really enjoying it. It’s fairly easy to get setup. And it supports my preferred workflow of deploying my changes early and often. I have run into a few snags though. Fly.io builds your project into a docker image and deploys containers for you. That process is mostly seamless when it works. But sometimes it fails, and you need to debug. By default, fly builds your docker images in the cloud. This is convient and preferred most of the time. But when I wanted to test some changes to my build, I wanted to try building locally using Docker Desktop. This should be easy. The fly cli is quite nice. And there is a flag to build locally. fly deploy --build-only --local-only This failed saying it couldn’t find Docker. > fly deploy --build-only --local-only ==> Verifying app config Validating /Users/polotek/src/harembase/fly.toml Platform: machines ✓ Configuration is valid --> Verified app config ==> Building image Error: failed to fetch an image or build from source: docker is unavailable to build the deployment image I spent quite a bit of time googling for the problem here. You can also run fly doctor --verbose to get some info. (If you run this in your fly app folder, it will show more info not relevant to this topic.) > fly doctor --verbose Testing authentication token... PASSED Testing flyctl agent... PASSED Testing local Docker instance... Nope (We got: failed pinging docker instance: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?) This is fine, we'll use a remote builder. Pinging WireGuard gateway (give us a sec)... PASSED No app provided; skipping app specific checks I found various forum posts discussing this problem. The folks at fly have spent a lot of time investigating some deep technical issues. I appreciate that work, but ultimately none of it seems to reflect my problem. And the issue felt simpler to me. Fly couldn’t find docker. Why not? Where is it looking? Eventually I found the answer on stackoverflow. It turns out that things have settled pretty recently to a basic config setting. By default, Docker Desktop installs the socket for the daemon in a non-global space. Usually in your personal user folder, e.g. ~/.docker/run/docker.sock. But other tools expect the docker daemon socket to be available in a standard location, e.g. /var/run/docker.sock As of this writing, Docker Deskstop has added a recommended way to enable the standard location. In the Docker Desktop dashboard, got to Settings > Advanced and enable “Allow the default Docker socket to be used”. Docker for Mac settings screen This will require your system password and restart. Then you should be able to see the docker socket in the standard place. And fly will be able to see it! Hopefully the next person who’s banging their head against this will have an easier time.

2nd Oct 2023 • 18 votes
How to Actually Integrate Angular and Nestjs

I don’t know who needs to hear this. But your frontend and backend systems don’t need to be completely separate. I started anew side project recently. You know, one of things that allows me to tinker with new technology but will probably never be finished. I’m using Angular for the frontend and Nestjs for the backend. All good. But then I go to do something that I thought was very normal and common and run into a wall. I want to integrate the two frameworks. I want to serve my initial html with nestjs and add script tags so that Angular takes over the frontend. This will allow me to do dynamic things on the backend and frontend however I want. But also deploy the system all as one cohesive product. Apparently this is no longer How Things Are Done. I literally could not find documentation on how to do this. When you read the docs and blog posts, everybody expects you to just have two systems that run entirely independently. Here’s the server for your backend and here’s the entirely different server for your frontend. Hashtag winning! When I google for “integrate angular and nestjs”, nobody knows what I’m talking about. On the surface, this seems like is a great technical blog post from LogRocket. It says “I will teach you how. First, set up two separate servers…” I think I know why the community has ended up in this place. But that’s a rant for another blog post. Let me try to explain what I’m talking about. Angular is designed as an a frontend framework (let’s set aside SSR for now). The primary output of an Angular build is javascript and css files that are meant to run in the browser. When you run ng build, you’ll get a set of files put into your output folder. Usually the folder is dist/<your_project_name>. Let’s look at what’s in there. polotek $> ls -la dist/my-angular-project -rw-r--r-- 1 polotek staff 12K Sep 13 14:15 3rdpartylicenses.txt -rw-r--r-- 1 polotek staff 948B Sep 13 14:15 favicon.ico -rw-r--r-- 1 polotek staff 573B Sep 13 14:15 index.html -rw-r--r-- 1 polotek staff 181K Sep 13 14:15 main.c01cba7b28b56cb8.js -rw-r--r-- 1 polotek staff 33K Sep 13 14:15 polyfills.2f491a303e062d57.js -rw-r--r-- 1 polotek staff 902B Sep 13 14:15 runtime.0b9744f158e85515.js -rw-r--r-- 1 polotek staff 0B Sep 13 14:15 styles.ef46db3751d8e999.css Some javascript and css files. Just as expected. A favicon. Sure, why not. Something about 3rd party licenses. I have no idea what that is, so let’s ignore it. But there’s also an index.html file. This is where the magic is. This file sets up your html so it can serve Angular files. It’s very simple and looks like this. <!doctype html> <html lang="en" data-critters-container> <head> <meta charset="utf-8"> <title>MyAngularProject</title> <base href="/"> <meta name="viewport" content="width=device-width, initial-scale=1"> <link rel="icon" type="image/x-icon" href="favicon.ico"> <link rel="stylesheet" href="styles.ef46db3751d8e999.css"> </head> <body> <app-root></app-root> <script src="runtime.b3cecf81bdcc5839.js" type="module"></script> <script src="polyfills.41808b7aa9da5ebc.js" type="module"></script> <script src="main.cf1267740c62d53b.js" type="module"></script> </body> </html> It turns out the web browser still works the way it always did. You use <script> tags and <link> tags to load your javascript and css into the page. But we want to let the backend do this rather than using this static html file. I’m using NestJS for the backend. It’s modeled after Angular, so a lot of the structures are very similar. Just without all of the browser-specific stuff. Nest is not so important here though. This problem is the same with whatever backend you’re using. The important thing is how static files are served. If you copy the above html into a backend template, it probably won’t work. This is what you get in the browser when you try this with NestJS. Angular fails to load. This is part of my gripe. By default, these are two separate systems right now. So NestJS doesn’t know that these files exist. And they’re in two separate folders. So it’s unclear what the best way is to integrate them. In the future, I might talk about more sustainable ways to do this for a real project. But for now, I’m going to do the simple thing just to illustrate how this is supposed to work. In NestJS, or whatever backend you’re using, you should be able to configure where your static files go. In Nest, it looks something like this. async function bootstrap() { const app = await NestFactory.create<NestExpressApplication>(AppModule); app.useStaticAssets(path.resolve("./public")); await app.listen(3000); } bootstrap(); So there should be a folder called public in your backend project, and that’s where it expect to find javascript and css files. So here’s the magic. Copy the Angular files into that folder. Let’s say you have the two projects side by side. It might look like this. polotek $> cp my-angular-project/dist/my-angular-project-ui/* my-nest-project/public/ This will also copy the original index.html file and the other junk. We don’t care about that for now. This is just for illustration. So now we’ve made NestJS aware of our Angular files. Reload your NestJS page and you should see this. Assets loading properly. Angular Welcome screen loading. We did it! This is how to integrate a cohesive system with frontend and backend. The frontend ecosystem has wandered away from this path. But this is how the web is supposed to work in my opinion. And more importantly, it is actually how a lot of real products companies want to manage their system. I want to acknowledge that there are still a lot of unanswered questions here. You can’t deploy this to production. The purpose of this blog post is to help the next person like me who was trying to google how to actually integrate Angular and a backend like NestJS because I assumed there was a common and documented path to doing so. If this was useful for you, and you’re interested in having me write about the rest of what we’re missing in modern frontend, let me know.

15th Sep 2023 • 13 votes

More in programming

Bikepacking across Kyushu

Five days and 540km on a bike across Kyushu, without a laptop. Notes on the peace of riding all day, convenience store dinners, and Japan's emptying countryside.

6 hours ago • 1 votes
Modifications to add a booty to Loops by Kat's Ditto amigurumi

I found a wonderful free crochet pattern for the Pokémon Ditto from Loops by Kat, but I decided I wanted to make a version with more than 3 "leg" blobs like the original pattern had. Specifically, I wanted to add two more smaller blobs in the back to help stabilize Ditto when they're sitting and also add a butt to our favorite transforming blob. Hazel Knits Cadence, a worsted weight superwash merino, in Terrywinkle that I had in my stash (I used about a third of the skein/36 grams/66 yards/60 meters), and I crocheted with a 2.5 mm hook. I make very tightly stitched amigurumi - do whatever is a good fit for you and your yarn! I used two 6 mm round safety eyes, and I embroidered the mouth with scraps of Hazelknits Cadence in Coral, Bloom, and Signature Black. The above photo is more true to color than some of the ones I took where Ditto looks more pink. I made Ditto's 2 additional booty blobs intentionally off-center by embracing the natural lean of crochet stitches - this gives a more animated or "in motion" feel to Ditto. As an added bonus, this simplifies the pattern as everyone's tension will be a little different, and thus everyone's off-centering a little delightfully different, too, but centering it instead wouldn't be the same for everyone! Here's all the information to modify Kat's crochet pattern to create a 5-blobbed Ditto. I use US crochet terminology. This pattern modification is also available as a pdf. Follow Kat's pattern through round 13. At round 14, it's time to start modifying to add the space and shaping for the additional blobs. There are also 3 more rows in this section to better fit the new 5-blob proportions. Modified increases in body, beginning at round 14 (with additional rounds, too): Round 14: 3 sc, 1 inc, 46 sc, 1 inc, 3 sc (56) Round 15: 56 sc (56) Round 16: 2 sc, 1 inc, 2 sc, 1 inc, 44 sc, 1 inc, 2 sc, 1 inc, 2 sc (60) Round 17: 60 sc (60) Round 18: inc, 4 sc, inc, 48 sc, inc, 5 sc (63) Round 19: 63 sc (63) Round 20: dec (through front loop of first stitch and both loops of second stitch), inc, 9 sc, inc, 38 sc, inc, 11 sc (65) At this point, the original pattern suggests placing the safety eyes, but I think it makes more sense to do this after you've made the "butt" and divided the stitches the 3 main "front" "leg" blobs from the original pattern. You'll still have plenty of access to place them then. Roadmap for doing 5 "leg" blobs instead of 3 To make 5 blobs, you use some of the main body's stitches and some created stitches for each. Created stitches are a combination of chains, pickups on the back of chains, pickups in the connections between the chains and the main body, and pickups in the connections between the chains. The "butt" "leg"/mounds are created before the 3 original "legs," and the left "butt" "leg"/mound is made before the right one. 1. Left "butt" "leg"/mound: This is the left "butt" cheek when viewed from the bottom. (While this is really the right butt cheek from Ditto's perspective, I'm calling it left because we're crocheting while viewing from below so it's backwards.) The start of round is the same as the start of round from making the body of the blob, so you can continue as usual. Round 1: 13 sc, chain 11 (24) Round 2: connect chain at previous start of round (skipping 52 stitches) then 24 sc (24) Round 3: (6 sc, dec) x 3 (21) Round 4: (2 sc, dec, 3 sc) x 3 (18) Round 5: (sc, dec) x 6 (12) Round 6: 6 dec (6) Finish off by looping through front loops of all 6 stitches and pull tight, etc. 2. Right "butt" "leg"/mound: This is the right "butt" cheek when viewed from the bottom. The start of round for this "butt" "leg" is 12 stitches before the body/left "butt" leg start of round. This is the second stitch in an increase from the last round of the body. Round 1: 12 sc, 1 dec in the corner of body connected to first "butt" "leg" (pictured below), 4 sc in the bottom loops in the existing chain, chain 7 (24) Round 2: connect chain at start of round for this "butt" "leg" (skipping other blob's additional 7 chains and 40 stitches in the main body) then 24 sc (24) Round 3: (6 sc, dec) x 3 (21) Round 4: (2 sc, dec, 3 sc) x 3 (18) Round 5: (sc, dec) x 6 (12) Round 6: 6 dec (6) Finish off by looping through front loops of all 6 stitches and pull tight, etc. Getting back to the original pattern for the 3 main "legs": After both "butt" "legs"/mounds are done, there are 40 stitches on the original body, 7 chain stitches that can be picked up from each "butt" leg" that haven't been picked up in a second location, which totals the original 54 stitches - this sets you up for the 3 blobs as described in the original pattern. Between each "butt" "leg" and the main body and between the two "butt" "legs" themselves are an additional 3 connections that are also picked up and decreased appropriately to keep the seams between "legs" tight. As a reminder, here's the road map, which shows how to divide up these stitches for the Ditto's main three "legs:" You might find it helpful to visualize this division by temporarily stringing up some scrap yarn to preview the divisions: If you'd like, place stitch markers like I did to delineate the division: Now that you've visualized how you're dividing the main "leg" blobs, it's a good time to place safety eyes if you're using safety eyes for eyes. I placed mine between rows 7 and 8 counted down from the small head blob and left 8 stitches between the eyes. Now you can proceed to make the main legs in the same order as the original pattern. 3. Main "leg" blob 1: This is the left "leg" blob labeled 1 in the original pattern. To start, connect your yarn into the first stitch in the main body after where the main body meets the left "butt" mound. Round 1: 18 sc, chain 9, 1 sc in the 2nd bottom loop in the chain right of the body/left "butt" mound connection, dec through the leftmost bottom loop in the chain on the left "butt" mound and the loop on top of the meeting of the main body/left "butt" mound (pictured below). (29) In the start of the original pattern "leg" 1, here are the two loops in the decrease through the left most chain loop on the left "butt" mound and the loop on top of the meeting of the main body/left "butt" mound. Follow the original pattern's Rounds 19 to 23 and finish off blob "leg" 1 as written. 4. Main "leg" blob 2: This is the right "leg" blob labeled 2 in the original pattern. To start, connect your yarn into 15th stitch from where the main body meets the right "butt" mound - there should be 7 skipped stitches along the front of the Ditto between this start of round and the left "leg" blob's last stitch on the front side of Ditto before the chaining. Round 1: 15 sc, dec through the loop on top of the meeting of the main body/right "butt" mound and the rightmost bottom loop in the chain on the right "butt" mound (pictured below), 4 sc in the bottom loops in the chain on the right "butt" mound, chain 9 (29) In the start of the original pattern "leg" 2, here are the two loops in the decrease through the loop on top of the meeting of the main body/right "butt" mound and the rightmost chain loop on the right "butt" mound. Connect chain at start of round for this blob "leg" at the beginning of round 2's first sc and continue the original pattern's Rounds 2 to 6 for blob "leg" 2 as written. As in the original pattern, now is a good time to stuff your Ditto most of the way! 5. Main "leg" blob 3: This is the center "leg" blob labeled 3 in the original pattern. Round 1: Start in the corner next to left "leg" 1 on the front side (pictured below). 37 sc into the following stitches you pick up: 7 stitches along the main body 1 stitch in the corner of the main body and right "leg" 2 9 stitches in the bottom loops of the chain along right "leg" 2 1 stitch in the corner of right "leg" 2 and the right "butt" mound 2 stitches in the bottom loops of the chain along the right "butt" mound 1 stitch in the corner between the two "butt" mounds 5 stitches in the bottom loops of the chain along the left "butt" mound 1 stitch in the corner of the left "butt" mound and left "leg" 1 9 stitches in the bottom loops of the chain along left "leg" 1 1 stitch in the corner of left "leg" 1 and the main body (37) My lime green running stitch marker indicates the start of round pickup location for making the main blob "leg" 3. To compensate for the extra 5 stitches from those corners, I decreased in the second round at the corresponding locations instead of just single crocheting the whole way around to ensure the end of my round 2 of this section had the specified 32 stitches: Round 2: 6 sc, dec, 8 sc, dec, sc, dec, 4 sc, dec, 8 sc, dec (32) After round 2, I continued with the rest of the original pattern to finish the middle blob "leg" 3. Make the two arms according to the original pattern. I attached them less symmetrically than the original suggested. Finally, embroider a mouth for Ditto. You can either do this in black to match the safety eyes or create a two-toned mouth in red and pink to make a very happy looking Ditto like I did. FYI, this is also documented as a project on Ravelry (though it's a lot harder to follow since photos couldn't be inline).

13 hours ago • 1 votes
Tyding up my side projects

Being focused is about doing less things, and giving more space to the stuff that matters. I am spread out on too many projects and I can’t give enough attention to all of them. It’s time to clearly sort out which one I will keep maintaining and which I should drop entirely. Chuttersnap Mikochi Mikochi is a self-hostable remote file manager I’ve started in 2023. It’s my most successful open source project. I personally use it every day, and thousands of people have adopted it and started using it on their own servers. This year the project has been receiving more and more attention. Maybe it just reached a critical mass of users. In practice, that means a bit more maintenance work, since people have been pointing out bugs and suggesting new features. At the same time, working on Mikochi is fairly enjoyable. It’s a small, self-contained project made with technologies I enjoy working with. I’ve got no complaints about spending some time working on it. Verdict: Keep maintaining Mikochi and actively continue improving it. Itako Itako is an investment portfolio tracking SaaS. I built it for the most part between 2023 and 2025. In terms of scope, it’s the largest project I’ve done entirely by myself. Is it a success? Not really. There are definitely a lot of people who tried Itako, and some who’ve kept using it a bit. But it’s not engaging enough for anyone to consider getting the premium plan. And honestly I don’t find myself using it that much. My view of investing and portfolio management has significantly shifted since I started this project. While I used to think that more sophisticated analysis would lead to better returns, I now realize that the only strategies that consistently make money are honestly stupidly simple. Or maybe it’s a U curve: on one end you’ve got a monkey throwing darts, on the other end you’ve got Jane Street, and everyone in-between fails to beat the market. Anyway, the biggest issue with Itako is how dull working on it is. The interesting parts of the projects are working on statistics and data visualization. But in practice, 90% of the time is spent tediously fixing data, understanding why some German stocks have an exchange labelled XETRA instead of XETR, why some Belgian stocks still have quotes while Euronext shows them as delisted… Verdict: Shut down Itako today. Milou Milou is static site generator for press kits. It started as a fork of presskit.html which was completely abandoned at the time. It’s a very useful tool. At Tsukumogami, it’s part of our Cloudflare pipeline which builds our website in a few minutes whenever we need to change something. It seems like a few other game studios have picked it up, although I rarely get any feedback about it. I’ve not spent too much time working on it in 2026. I think it could be interesting to come back to it and add a feature or two. Better support for multiple languages could be an idea. At least, I need to make sure we don’t fall into the good old Node.js dependency rot. Verdict: Spend some time on Milou. Luluka Earlier this year, I created Luluka. It’s a CLI that allows previewing the output of Ebitengine shaders. I do still think Ebitengine is a great engine and Go is better suited for game development than most people realize. However, after quite a long period of experimentation around it, we’ve decided to remain a Godot studio. On top of having quite a large sunk cost in infrastructure surrounding Godot, the tooling and possibility of doing 3D games still makes it a more attractive engine for our use cases. And I’ve been doing a lot of 3D work lately, so better put those hours to use. Verdict: Archive the project. The rest I’ve had a lot of good ideas that stayed as almost empty repositories in my GitHub. For example, Hakumei was a terminal companion to Mikochi. I made a few commits on this project and never found the time to work on it again. I have to admit I’m probably never going to have the time to work on all those repositories. Time to archive them all!

4 days ago • 1 votes
Not everybody is an AI expert - and that’s fine

This post was previously published through my newsletter on November 9, 2026. From time to time, I will republish newsletter issues on my blog here if I think people (and search engines) might benefit from it. If you want to read everything I’ve written once it is posted, I recommend signing up for the newsletter. If you’re doing anything to stay on top of what is happening in the world of software testing and test automation, like browsing or even posting on LinkedIn, which I stopped doing for the foreseeable future, or reading blog posts - my preferred way of keeping up these days, and I highly recommend Dawid Dylowicz’s excellent Software Testing Weekly aggregator mailing list if you prefer longer-form reading, too you’d be thinking that AI has consumed our entire field, and that everybody (or at least those who post or write in public) is an AI expert these days. The reality, though, is far from that. Yes, some people use a lot of AI, even when I would only call a small fraction of them ‘experts’. I definitely do not classify myself as an ‘AI expert’, by the way. A much larger group uses AI on a less frequent basis, and they’re getting some value out of it. Sometimes more, sometimes less. That’s the group I’m probably in. And then there’s a group of people who haven’t really been using a lot of AI at all so far, beyond maybe the odd prompt to ChatGPT or Claude. I don’t have the actual numbers, but I suspect that this group is a lot larger than you would think from browsing your feed or surfing the blogosphere. You just don’t see them, because they’re typically not the people who do a lot of work in public. A few weeks ago, I started working with a small group of testers to teach them how to use AI in their daily work. This work covers both test automation as well as broader software testing tasks, as some of them contribute to automation on a daily basis, but not all of them do. I’m working with them one day per week, on average, for three months, and we’re making small steps towards making AI a more prominent tool in their tool belt. So, what are we working on right now? I’m pulling ideas from my ‘Valuable Feedback, Fast with AI’ course, and so far, we’ve spent some time setting up Claude, going over some important concepts such as context windows, models, tokens, and (of course!) the probabilistic nature of LLMs, and what that means for the results they provide. We have gone through several initial conversations, using Claude to learn more about and review specific user stories, which was an excellent segue into using talking about MCPs and setting up a connection to both Jira and Confluence using the Atlassian MCP. Last week, we also started experimenting with writing straightforward skills to make it easier for Claude to repeat certain actions in a structured way. These actions ranged from reviewing stories and acceptance criteria to refactoring small chunks of code in their (Robot Framework-based) test automation suite. What I loved about this is the avalanche of ideas that popped up in their heads when they saw how easy it was to use Claude. We made a short to-do list of ideas to try out for the next couple of weeks, and I’m looking forward to seeing them getting more confident around using Claude. One thing I have noticed is that their level of comfort around using AI varies quite a bit. Some of them are naturally quite cautious, which means they’ll ask ‘can we really do this?’ and ‘should we really do this?’ frequently before even submitting a single prompt. This is a good habit, I think, but we’ll have to do some work to get them more comfortable with using LLMs, without losing too much of that caution. Others in the group are the opposite: I need to hold them back a little, because otherwise they’ll create a beautiful mess within days, simply because they see so many opportunities to use Claude in their work. That, too, isn’t inherently bad, but I do want to teach them not just how to get the most out of an LLM, but also (more so) how to use AI prudently. Over the next couple of months, we’ll dive deeper into writing better prompts, creating and structuring skills, better context management, and creating and using agents, and probably a few more things, too. I’m looking forward to seeing these people grow more comfortable around using AI in their daily work, and figuring out where AI genuinely adds value and where it doesn’t in their own context. Is there a deeper message in this newsletter? Maybe not, and I’m just happy to tell you about this project, and how it is a great example of a what I call ‘corporate mentoring’, a very efficient way of teaching a small group of engineers new skills, within their own context. But maybe it’s also to show you that, despite what you might see on the Internet, especially those places featuring a lot of self-congratulation (I’m looking at you, LinkedIn), not everybody out there is an AI expert. At least not yet. So, if you feel like you’re ‘behind’ simply because you’re not running at least 17 agents continuously, creating 5400 merge requests per day, know that you’re not alone. Quite far from it, I would say.

5 days ago • 1 votes
Keyhive 08 · Rain Diagrams

Certflow diagrams laid out in time

6 days ago • 1 votes
📚 BoredReading

You seem to be enjoying this.

Join free to unlock everything.

Create free account

Already have an account? Sign in