As a web developer, I've created some websites for family and friends. My default tool for that was WordPress, because you could easily set them up, pick a theme, mess with the CSS a bit and let them write the content.

But hosting a wordpress website is always a trade-off between reliability and costs. On one side you have free hosts giving you a terrible VM that can barely handle the administration side, on the other overpriced plans for what's really a tiny website with usually almost no traffic.

I've always thought that WordPress was using a tank to kill a fly.

So until now, for non technical business owners, I've set up a free host and the administration of the website was usually quite slow and unreliable. If the client wanted something more reliable, I'd get a paid hosting plan, but that would include some overhead for me.

For my personal projects I personally used custom made static websites, with or without automatic generation. But I didn't see myself explaining the details of git push, markdown and CLI use to my parents. I thought I should work on an ideal, user friendly static website editor one of those days.

Today i discovered Publii and thought i'd give it a try for my blog. If it's satisfactory, I might recommend it to my less tech-savvy friends in the future. Until now I've been pleasantly surprised.

Back when I was working at virtualQ, I had to do some documentation. At first I didn't quite enjoy it, feeling like this was a chore. But documenting a system can be a very interesting task. I also had to explain our systems to new hires after we raised some funds and quickly grew the team.

We had a documentation website for our API, based on markdown. It was very technical, with manually copy pasted sample API responses. It wasn't very visual. It had endpoints documented publicly while they were only for internal use. It had a lot of outdated content, and felt more like a patchwork of data bits than a comprehensible thing.

My fist step was to remove the documentation off irrelevant endpoints. The docs were kind of an hybrid between a public api documentation and some internal guide for new hires. I made dedicated to customers trying to use our api only.

It still had a "wall of text" feeling though. To make it more palatable, I tried to add visuals. Integrating mermaid to the docs was quite easy, I styled it roughly with some css rules. Sequence diagrams are awesome. I used them to communicate the different workflow we had and some typical scenarios the clients would like to use our API for.

We had a complex state machine that tracks the state of a caller through our system. I tried to represent it as a graph, but that was a bit too cluttered, so i split it in two graphs and removed some of the transitions that were not normally happening.

Finally, I wanted to fix our outdated sample API requests and responses. Our API was evolving rapidly and having outdated samples was more confusing than helpful. I created a tiny script that curl commands and update the API answer samples with them. I had to do some dirty grepping on the answers to replace dates, ids, etc .. to avoid polluting the git log with meaningless edits every time we'd refresh the samples.

We deployed the new version of the documentation. Some of our new hires still had some use for the old version (that documented more endpoints) so we added a link to it. We don't have any tracking on the docs website, so I have no idea what the readership is, but it was great as a learning experience.

It made me love mermaidJS so much, that I eventually ended up building a google docs addon for it.

I like the idea of writing tutorials as markdown, with E2E test instructions mixed in, and outputting the result (text, screenshots, response samples) as a document. It would guarantee that the tutorials stay in sync with the product and don't become outdated, with always fresh screenshots. It would make the task of writing E2E tests for some web app a dual purpose task, where you'd generate both a helpful document and some smoke tests in one go.

DO + MUP = 💙

I've migrated my main project, from Heroku to Digital Ocean, with the help of the awesome meteor up tool.

I wanted a way to automate the backups of production to my own computer. In meteor, the only thing really worth backing up is the content of the mongoDB.

We need two things : a script that does the backup, and a cron job to run regularly

Backup script

You just need to configure the two environment variables at the top (in bold)

daily_backup.sh

#!/bin/sh  
  
\# folder where to store the last 7 daily backups, without trailing slash  
DUMPFOLDER="**/home/renan/cl/app/dump**"  
  
\# IP of your digital ocean droplet  
DO\_INSTANCE\_IP="**46.101.232.182**"  
  
\# so that notifications know on which display to show when called from the cron tab  
export DISPLAY=:0  
  
\# Let it quit when it crash  
set -e  
  
DUMPFILE="$DUMPFOLDER/daily\_$(date +"%y-%m-%d").backup.gzip"  
  
if \[ ! -f $DUMPFILE \];  
then  
  continue  
else  
  echo "Already done today" && exit 0  
fi  
  
notify-send "Backing up ..."  
  
\# ssh to the instance, then ask the mongodb container to output an archive of all dbs, then stream that back to your machine.   
ssh "root@$DO\_INSTANCE\_IP" "docker exec mongodb mongodump --archive --gzip" > "${DUMPFILE}"  
  
\# Only keep the last 7 dumps   
ls -tp $DUMPFOLDER/ | grep -v '/$' | tail -n +8 | xargs -I {} rm -- $DUMPFOLDER/{}  
  
notify-send "... backup done."

Make sure the script is executable with chmod +x daily_backup.sh

CRON setup

We will run this script every hour. The first time it runs it will do the backup, and the next time it will see the file exists already and just exit. The next day the filename will be different and therefore a new backup will be run.

Open the cron editor : crontab -e

Add the following line, modifying the path in bold to point to your script.

1 * * * * /**home/renan/cl/app/.production/daily_backup.sh** >/dev/null 2>&1

This will run the script every hour when minutes are equal to 1, so if you start your computer at 8:30 it will first run at 9:01

The redirect after the command are to avoid having errors show up in the logs. Ubuntu is a bit confused when cron jobs generate outputs.

How to restore such backup

Having backup is nice, but knowing out to restore them is better.

#!/bin/sh  
  
\# folder with the dumps  
DUMPFOLDER="**/home/renan/cl/app/dump**"  
\# IP of your digital ocean droplet  
DO\_INSTANCE\_IP="**46.101.232.182**"  
  
\# Let it quit when it crash  
set -e  
  
\# find the latest backup file  
LATEST\_FILE=$(ls -t1 "$DUMPFOLDER/" |  head -n 1)  
LATEST\_DUMP="$DUMPFOLDER/$LATEST\_FILE"  
echo "Restoring to production from $LATEST\_DUMP"  
read -p "Press enter to continue .."  
  
\# pipe file to the mongorestore inside the mongodb docker container inside the droplet   
cat "${LATEST\_DUMP}" | ssh "root@$DO\_INSTANCE\_IP" "cat | docker exec -i mongodb mongorestore --archive --gzip --drop"

I really like the look of the default Publii theme, however some modifications weren't quite working using the in-app options. I wanted this website to have a very low level of interactivity, i don't need a mobile hamburger menu for 2 short entries (code & life).

So I started looking for a different theme but I couldn't find what I was looking for, that is, a minimalist theme. I resolved to just strip things away from the default theme to make it lighter and JS free.

Opening the default theme gave me the same feeling that I got when trying to customize the code of a 40$ admin panel. Lots of code, neatly organized, most of it unused.

What is all this code, what is it for ? Oh, i can get rid of it.  

I managed to strip down the source by removing the parts I wasn't interested in. I think now the design looks clean, and I got rid of most useless css and js I could find. I'm not sure that this is the right approach, as those changes definitely won't survive a theme update (but why would I want to update it ?) and are a bit hacky. I'm pretty sure those changes are only stored on my machine, so if I try to edit the website from somewhere else it will revert back to it's default look.

However, i'm not too worried about this. This personal website is a playground for experimentation after all.

I have a setup to know when my main app, ciboulette.net, is down.

It's based on statuscake, which pings my marketing site every 5 minutes, and also my main app.

It used to ping a third endpoint, which was an order form deep inside my app.

The idea was to check the the clients of my clients should be able to order veggies, so pinging a specific, real page would make sense.

I also used to log every action that would happen on such an order, directly in an array within the "order" document.

It means that every 5 minute, the document was getting a tiny bit bigger.

Today, i tried to mongorestore a production dump on my local dev environment to get fresh data. It's very useful to see how the real data would look like in the new version, and lets me see missuses and bugs that i would miss otherwise.

So i tried to import my production dump (the db needs renaming from "ciboulette" to "meteor" to work locally)

renan@renan-hp:~/cl/app$ cat dump/daily\_21-03-24.backup.gzip | mongorestore --archive --gzip  --nsFrom='ciboulette.\*' --nsTo='meteor.\*' --uri=mongodb://127.0.0.1:3001/  
2021-03-24T15:31:06.076+0100 preparing collections to restore from  
2021-03-24T15:31:06.083+0100 reading metadata for meteor.shortUrls from archive on stdin  
2021-03-24T15:31:06.102+0100 restoring meteor.shortUrls from archive on stdin  
2021-03-24T15:31:06.263+0100 reading metadata for meteor.opens from archive on stdin  
2021-03-24T15:31:06.278+0100 restoring meteor.opens from archive on stdin  
2021-03-24T15:31:06.753+0100 reading metadata for meteor.Orders from archive on stdin  
2021-03-24T15:31:06.767+0100 restoring meteor.Orders from archive on stdin  
2021-03-24T15:31:07.308+0100 reading metadata for meteor.logs from archive on stdin  
2021-03-24T15:31:07.318+0100 restoring meteor.logs from archive on stdin  
2021-03-24T15:31:07.827+0100 no indexes to restore  
2021-03-24T15:31:07.827+0100 finished restoring meteor.shortUrls (8224 documents, 0 failures)  
2021-03-24T15:31:08.269+0100 no indexes to restore  
2021-03-24T15:31:08.269+0100 finished restoring meteor.opens (21263 documents, 0 failures)  
2021-03-24T15:31:08.503+0100 finished restoring meteor.Orders (32999 documents, 1 failure)  
2021-03-24T15:31:08.503+0100 Failed: **meteor.Orders: error restoring from archive** on stdin: bulk write error: \[{\[{**write to oplog failed: BadValue: object to insert exceeds cappedMaxSize**}\]}, {<nil>}\]  
2021-03-24T15:31:08.503+0100 32999 document(s) restored successfully. 1 document(s) failed to restore.

It took me quite a while to pinpoint the problem.

Luckily, the same dump would import fine in a real mongod instance, the problem seemed to be only with the meteor provided development mongo instance.

The problem seemed to be be with some order documents.

So, first i wiped the local "meteor" db in mongod

mongo mongodb://127.0.0.1:27017/meteor --eval "db.dropDatabase()"

Then i imported the dump there

cat dump/daily\_21-03-24.backup.gzip | mongorestore --archive --gzip  --nsFrom='ciboulette.\*' --nsTo='meteor.\*'

I tried removing all documents from db.Orders, dumping, and then importing that to meteor, it worked. But i was missing my main collection.

I then used this script to find the biggest document and its _id within my mongo collection

 mongo  mongodb://127.0.0.1:27017/meteor --eval "(()=>{var max=0,maxId=null; **db.Orders**.find().forEach(o=>{var s=**Object.bsonsize**(o);if(s>max){max=s;maxId=o.\_id}}); return {max,maxId}})()"  
      
MongoDB server version: 4.4.4  
{ **"max" : 14199831**, "maxId" : "GBeerkZ46dcjAgLtu" }

14 199 831 bytes, holly molly ! About 14 megabytes of text in one document.

A findOne query allowed me to see that it was the "Order.logs" field that was so full.

So i cleaned up this field in  all documents :

renan@renan-hp:~/cl/app$ mongo mongodb://127.0.0.1:27017/meteor --eval 'db.Orders.update({logs:{ $exists:true}},**{$unset:{logs:""}},{multi:true}**);'  
MongoDB shell version v4.4.4  
connecting to: mongodb://127.0.0.1:27017/meteor?compressors=disabled&gssapiServiceName=mongodb  
Implicit session: session { "id" : UUID("bb02fe49-5241-4beb-82ea-fbdc4c325998") }  
MongoDB server version: 4.4.4  
WriteResult({ "nMatched" : 180383, "nUpserted" : 0, **"nModified" : 180383** })

And re-run the maximum size check

mongo mongodb://127.0.0.1:27017/meteor --eval "(()=>{var max=0,maxId=null; db.Orders.find().forEach(o=>{var s=Object.bsonsize(o);if(s>max){max=s;maxId=o.\_id}}); return {max,maxId}})()"  
{ "max" : **7578**, "maxId" : "eYdGxbBKDNfKZYZw8" }

Much, much better :)

So, all that was left was to dump that data, load the dump in meteor and all was fine.

I added a migration to clean that field in production too. It will run on the next deploy.

I added a few of my projects to https://1mb.club/. I'm not sure what for, but eh, it's free link estate ! I stumbled upon a touch type trainer in 2 KB of js. The best thing about it is not really the tool (it's limited, obviously) but the absurd way the author got down to that 2kb size, in particular this little gem.

https://github.com/KaarelP2rtel/keyboard-tutor/blob/master/minify.sh

sed -i 's/tutor-window/tw/g' "$target"
sed -i 's/tutor-container/tc/g' "$target"
sed -i 's/tutor-completed/tm/g' "$target"
sed -i 's/tutor-cursor/tr/g' "$target"
sed -i 's/tutor-uncompleted/tu/g' "$target"
sed -i 's/tutor-result/te/g' "$target"
sed -i 's/tutor-status/ts/g' "$target"
sed -i 's/current-layout/cl/g' "$target"

I have no words, it's beautiful :)

I remember going to similar extremes on importabular.

All the private methods had names prefixed by an underscore, and then i had some instructions for the minifying tool to not keep names with that prefix.

It shaved a few kilobytes from the already tiny lib, but i reverted it after to make it easier to subclass the Importabular class.

Anyway, gzipped code golf is always a lot of fun.

My app has 4 main collections in mongo :

• A user has many weeks and clients

• Each week has many orders, one per client, where the order content is stored (can be empty if the client didn't order that week).

Initially, my documents were quite dry, I was doing the "joins" work on the client. It got laggy though, so I moved the joins logic to the meteor server, with hooks (matb33:collection-hooks) in every directions to keep denormalized fields in sync.

It was a pain though, really hard to follow what was going on and to debug.

There's also potential for chain reactions and never ending hooks loops.

But mostly, it was buggy in edge cases.

So I'm migrating away from those hooks, and creating an aggregation pipeline per collection (week, client, order) that computes all the dynamic fields for some given ids, and returns the documents where the value is different, plus some additional ids to check in the next pass.

It's not yet in production, but after this rewrite, my e2e tests are passing.

Meteor uses mongodb 4.2 in development server. I didn't feel like forcing an update to 4.4, which brings in two very useful features for my use case (the $function operator and the ability to $merge to the collection that you are aggregating on).

So I've been $writing:{ $some: {$nested: {$queries:'It's a pain''}}} . I'm back to junior level of mastery in this new paradigm, where "It works" comes as a surprise. I'm sure i'll rewrite those ugly aggregations at some point, but for now they seem to do the job.

One nice approach to using aggregation pipelines in meteor is to declare them in a separate js file, and then have a simple, non-meteor script that runs the aggregation and logs the results.

I use nodemon to watch the files, and get a very fast feedback loop, without the need to wait for the meteor server to recompile. Great when you're learning as you go.

I start the script like this (-r esm allows me to use modern imports)

nodemon -e js  -r esm tests/scripts/mongofun.js

And the script itself is very simple. It just runs the query

tests/scripts/mongofun.js :

const mongoUrl='mongodb://127.0.0.1:3001/meteor'

async function actual_aggregation(db) {
  const result = await db
    .collection('Orders')
    .aggregate([
      {
        $match: {_id:'<some test id>'}
      }, 
      ...the_pipeline_imported_from_the_meteor_source
    ])
    .toArray();
  console.log(result);
}

const mongodb = require('mongodb');
const client = new mongodb.MongoClient(mongoUrl, {
  useUnifiedTopology: true
});

client.connect().then(
  async () => {
    const start = Date.now();
    await author_aggregation(client.db());
    console.log('took ' + (Date.now() - start) + ' ms');
  },
  e => console.error(e)
);

Anyway, that's all for today :)

i3 is nice. End to end tests are nice. Chromium is nice. But they don't get along so well by default.

When you run you e2e script with nodemon, each run opens and closes the test browser window. By default, that window appears right by your editor, messing the layout.

It's easy to fix though : you just need to tell i3 what to do with that test browser window.

To make every new chromium window appear in the workspace $ws5, add this in ~/.config/i3/config

assign [class="Chromium-browser"] → $ws5

The workspace name is a variable here, but you can put anything. I assign that window to a rarely used workspace.

Chromium has a different class from Google Chrome, so this has no impact on where the "real" browser is started.

To get the class infos for other browsers, run xprop in a terminal and then click on a window.

I had some TODO and FIXME instructions in random locations in my code that served no purpose, as I was never looking for them. I also use "console.log" for temporary debug logs that should be removed in production.

I sometimes forget some console.log statements, and basically always ignore the TODO/FIXME comments.

So i made a very simple script that fails if there are TODOs, FIXMEs or console.log in your code. This way the PR won't look like it's passing if it's missing an important part.

Save it in .github/workflows/check_todos.yml

name: Look for todos and fixmes
on:
  pull_request:
    branches:
      - master
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - run: |
         if grep --exclude-dir={.git,.github} -rE "TODO|FIXME|console\.log"; then
              exit 1
         else
             echo "All good"
         fi

I exclude .git because it could contain the text. And I exclude .github so that the regex doesn't match itself. Package files should not be a problem as the script doesn't pull any external dependencies (no npm install)

The search is case sensitive, so it will only trip for clear TODOs and not some random method names.

You get the results really quickly, and because only the source is checked out ,all the generated files/packages should be excluded from the search.

I've been working with smstools3 which uses a folder and its subfolder as its state store.

Instead of running "tree" manually in the /var/spool/sms folder, i'd rather have it be done automagically whenever the files change.

I've used inotifywait for that, which needs to be installed on ubuntu with

sudo apt install inotify-tools .

Then it's just a matter of cd-ing to the proper directory and running :

clear && tree && inotifywait --monitor --quiet --recursive --event modify . | while read; do clear; tree; done

I felt like having a small break from my main project this month, so I'm giving myself some weeks to try out other ideas I've been putting off. Just happy coding of open source MVPs for various ideas I've had for a while. I'm giving myself a max of 7 days per app to make sure the scope stays reasonable.

The first one is pretty close to done now, and it's called picnic : https://txt.lecaro.me/

It's a simple web app that lets you create a plain text document and edit it with friends in real time (on PC and smartphone).

It's end-to-end encrypted, so the client side does the encryption with window.crypto (despite not really adding much security) and sends that to my node server over web sockets. The server saves that document and forwards it to the other clients that can decode it thanks to the key stored in the URL. "Rolling your own crypto" is generally a bad idea, but I think here i'm "using pre-made crypto" which is alright, despite a very strong feeling on "I have no idea what I'm doing".

Speaking of haphazardly reaching a decent solution : syncing edits is hard. When you type some words in the text, the full value of that text is sent over to the server, who forwards it to everyone as-is. So each client receives the latest version, but might have done its own edits that are not yet sent for syncing (two people typing at the same time).

I end up doing a three-way merge of full text, using a homemade, quite naive approach. It works most of the time, though it quite easily gets confused. Initially, just typing alone on the document would get super messy when the updates from the server would conflict with your local edits.

My 3 way merge algorithm performs well when the edits are far from each other, but it performs terribly when two users are adding a thing at the same spot in the doc. Luckily, this only really happen when a user tries to apply his own edits. So I just made the editor ignore any edits that came from itself (using a session ID that only lasts for the duration of the web page).

Furthermore, some edits would arrive in the wrong order, and my algorithm would consider a reversed addition as a deletion. I could solve that quite easily too, by just adding a version number to each document, incrementing it at each edit, and ignoring stale edits. The server keeps the authoritative value for the current version number and blocks any stale edit form propagating.

Finally, the app reconnects with exponential back-off and retries to send user's edits whenever the sync fails for any reason, until it's up-to-date with the server. Overall, I'm quite pleased with the result, it's usable, loads fast and more reliable than my previous attempt at solving the same project. It's also quite easy to self-host as the DB is simply the local file system.

In 2022 in got a new job at Della AI and moved to Nantes. I focused less on ciboulette.net than before, and had less time for side project.

Working at Della has been interesting. I took over a React fronted (with Redux that i'm slowly getting rid of). I had to learn typescript, but in the end I don't fully exploit it. It helps avoid mistakes, but also forces you to write code that looks more like java than proper Javascript. I had never seen so many enums in a codebase.

Anyway, I'm quite happy with the way things are going, and our company has been bought out by a bigger one, Legisway. I visited their offices and they are neat !

On the hacking side, over the Christmas/New year vacations I started a small game project. It's a chilled out city builder, made in web tech. You can have a look at it here : https://drmp.lecaro.me/ (there's no good name for it yet).

That's all for today, I had to dig up this website from an old save to publish something new on my new computer.

Ciboulette.net has a large battery of tests that ensure I don't break too many things when doing a deployment. The app also connects together many services, like google maps, google custom search, Stripe and Sumup.

I wanted to make sure those integrations would keep working, so i embedded the real services in my test. For example, playwright would attempt to connect to a test account at sumup when running the e2e test.

Recently, sumup changed their login flow, and added a captcha. I don't see how I can work around this. The tests are a bit flaky for a few other reasons anyway, so i think i'll just run them by hand and complete the captcha every time.

Still, i'm sure there's a better way. I tried to just copy the result of the authentication request but this only worked for a single run of the tests. During the next run Sumup would refuse them for some reason.

Long time no see ! I haven't posted much in the last year, mostly because I couldn't find a way to edit the site. Publii can be confusing at times.

Summary of 2023

I spent the first half of 2023 working for Della, and making a small project (https://drmp.lecaro.me/).

I then resigned from Della and went to do the Camino de Santiago with a friend in September. We walked for 30 days in spain, it was great, not really challenging. Here are my main tips if you want to do that trip : bring sandals and a hat (the path is easy but it gets hot), don't reserve ahead of time (the best places don't give reservations), take your time (we went too fast), don't worry too much about bed bugs (we didn't encounter any).

Then, I moved to Créteil and started programming. I first focused on making https://sms.lecaro.me/ as a standalone app that lets you program sms sending from your phone. It's much simpler than the first app I made to let ciboulette do it. I recognized that my android programming skills are low, and so i should keep most of the logic on the server.

I worked on many other aspects of ciboulette to improve its performance and modernise the codebase.

Summary of 2024 so far

• I spent some time learning rust, and made a project with it https://obm.lecaro.me/ It kinda works, but i feel like the potential for improvement lies in better algorithms, much more than the use of a fast language.
• I spent way too much time playing brigador https://www.gog.com/en/game/brigador
• I switched from using one average 15" laptop to having two devices : a powerful desktop and a very light 13" laptop.
• I started using syncthing for absolutely everything, this tool rocks
• I rooted my old redmi note 7 phone with LineageOS and i love it. It's so clean, no Xiaomi adware getting in the way.
• I learned to cook chinese food, Mapo tofu in particular is amazing
• I learned a bit of chinese with Hello Chinese, that app is not bad.
• I did some freelancing for https://heyhosystems.com/ and refreshed my rails skills
• I just moved this blog off Publii and back to some handcrafted HTLM

Goals for the rest of 2024

• make ciboulette.net lower mantenance, to be able to go back to the industry if I want to
• get my driver license (I'm 32, it's about time)
• Sell the things I don't really need
• Push one of my previous project further, to hopefully get it to help real people
• use more markdown files, less online services

A while ago I made a small tool called importabular, that would help me import data into ciboulette.net It's a spreadsheet like UI with named columns. It was my first attempt at writing a spreadsheet UI and there were some issues. It was trying to do too much, and was too specific for one use case, and the lack of virtualization brought some issues.

Today I worked on a new version and I'm quite happy with the result. Given that the project scope and data model are quite different, I picked a new name. NanoSheets was free, and puts the emphasis on how light that lib is (2.5Kb minified and gzipped). The other libraries in this domain seem to all be Swiss army behemoth where you first need to turn off 90% of the features.

Anyway, here's the demo website : https://nanosheets.lecaro.me/

I've been developing a meteor app since 2015 now, and the production deployments have always been quite slow, around 15 minutes.

It used to be because heroku was taking its sweet time. Heroku got too slow and too expensive quite quickly though, and I switched to https://cloud.digitalocean.com + https://meteor-up.com/

My upload speed then became the bottleneck, because I lived in the countryside, where DSL is the only option. So I made sure that my CI runner (first circle CI, then github CI) would do the upload of the bundled app for me.

However, the CI workers you get for free aren't the fastest, they just can't compete with my desktop workstation on any criteria. I now also have fiber, and so the upload speed is no longer a problem. I've switched to running meteor up locally, with great success.

I can now deploy my app in 2 minutes, and by setting the correct meteor up flags, I barely get 10 seconds of downtime after each deploy. It saves me all the trouble that comes with load balancing and rolling deploys when they go wrong.

As a bonus, I can also tag the commit I just deployed with the current date, to be able to easily rollback to a previous version.

I've noticed that deploying to my staging instance is faster than the production one. It's not a big difference, something like two minutes vs two minutes twenty. My staging server is on Hetzner, so I guess my production will go there soon too.

Here's the production mup.js config, by the way

module.exports = {
  servers: {
    one: {
    	// my server public ip
      host: '46.101.232.182',
      username: '***',
      pem: '~/.ssh/***'
    }
  },
  app: {
    name: 'ciboulette',
    path: '../',
    servers: {
      one: {}
    },
    deployCheckWaitTime: 300,
    buildOptions: {
      serverOnly: true
    },
    env: {
      ROOT_URL: 'https://app.ciboulette.net',
      MONGO_URL: 'mongodb://mongodb/meteor',
      MONGO_OPLOG_URL: 'mongodb://mongodb/local',
      ENV: 'PRODUCTION',
      TZ: 'Europe/Paris'
    },
    docker: {
      image: 'zodern/meteor:root',
      prepareBundle: true,
      useBuildKit: true,
      stopAppDuringPrepareBundle: false
    },
    enableUploadProgressBar: true
  },
  mongo: {
    version: '6.0.3',
    servers: {
      one: {}
    }
  }
  , hooks: {
    'pre.deploy': {
      localCommand: 'npm run build'
    },
    'post.deploy': {
      localCommand: 'git tag -f $(date +%Y-%m-%d)'
    }
  }
};

Hosting my SAAS over 9 years

I run an app (ciboulette.net) in the cloud. This app generates about 1000 € / month of revenues. I try to run it in a way that doesn't cost too much, while keeping good performance.

Heroku

I started by hosting it on Heroku with a paid mLab database. It quickly got expansive, the database in particular. At the time I had barely 6 clients and the hosting was already costing around 40 € / month adn getting laggy.

Digital ocean

I switched to Digital Ocean, with a small instance at 5€ per month I could run the app much more smoothly. Hosting the db on the same machine as the app itself got rid of most of the lag.

I couldn't have made that switch without the help of meteor up, an amazing free tool that helps you deploy meteor apps very easily.

For backups, I just have a cron on my dev machine that ssh to production and pulls a mongo dump every day. They are about 650MB each now, and I've upgraded the production instance to "premium intel" : 2 vCPUs, 4GB ram, 80 GB SSD storage. It costed 28$ / month.

I host static files on an s3-like "spaces" bucket that cost 5$ more per month. So in total i got good performance for 30 € / months

Hetzner

I heard that hetzner could be a bit cheaper than digital ocean, so I opened an account there. I was happily surprised, it is indeed better value. I use two cx32 machines, one for prod and one for staging. They each cost 7.56€/month, with 4 vcpu and 8gb ram, basically double the power of the DigitalOcean machine for less than a third the price.

Benchmark

I thought it would be interesting to compare cloud and physical machines, here are the result, and below are the details

Note that the heroku machine does not match the specs you pay for at all, it should have 0.5GB of ram not 64GB, as explained below.

Power consumption

I would like to compare cloud machines with computers I physically own, so cpu tests on both of them. I measure the electrical consumption of the machine, both while performing the test and idle. Realistically, the machine is mostly idle but needs to be fast enough to work in the day.

The monthly price was computed this way for physical devices :

monthly_cost = power consumed idle (watts) * 24 (hours per day) * 30 (days per month) / 1000 (Kw per w) * 0.25 (€/kwh price in france)

For cloud devices, the price is simply the one demanded by the hosting service

Ram and Processor info

I got the ram with this command

~ $ free -h
               total        used        free      shared  buff/cache   available
Mem:            61Gi        30Gi       2.0Gi        67Mi        30Gi        31Gi
Swap:          121Gi       1.2Gi       120Gi

I then took the total Mem size

For cpus, I ran

cat /proc/cpuinfo | grep "model name"

sysbench benchmark

I ran two tests on each machine, the first one is sysbench

sudo apt install sysbench
sysbench cpu run --threads=16

The result would look like the code below, "events per second" is the result, higher is better

sysbench cpu run --threads=16
sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

Running the test with following options:
Number of threads: 16
Initializing random number generator from current time


Prime numbers limit: 10000

Initializing worker threads...

Threads started!

CPU speed:
    events per second: 11162.86

General statistics:
    total time:                          10.0009s
    total number of events:              111655

Latency (ms):
         min:                                    0.33
         avg:                                    1.43
         max:                                  160.65
         95th percentile:                        4.49
         sum:                               159767.60

Threads fairness:
    events (avg/stddev):           6978.4375/1210.28
    execution time (avg/stddev):   9.9855/0.01

To test most devices, I just logged in by ssh and ran the commands.

MD5 benchmark

My M700 gave an absurd result for sysbench because I ran freebsd on it, and the compiler for that target optimized away most of the benchmark code. That's what pushed me to add a second benchmark test that's easier to run on any pc (the MD5 hashing).

# MD5 benchmark
time (for i in {1..16}; do (dd if=/dev/zero bs=1M count=1512 2>/dev/null | md5sum > /dev/null) & done; wait)

You should check the "real" line in the output, lower is better

real	0m2.121s
user	0m28.930s
sys	0m11.597s

Heroku testing

For heroku, I used the "heroku run" command, but the results are suspiciously good. I suspectrf this kind of command gets a beefier dyno assigned that any regular process.

mkdir benchmark
cd benchmark
git init
heroku create benchmark
heroku git:remote -a benchmark
echo "web: bash" > Procfile
echo "python-3.11" > runtime.txt
echo "sysbench" > Aptfile
heroku buildpacks:add --index 1 https://github.com/heroku/heroku-buildpack-aptck-apt
git add .
git commit -m "Initial commit"
git push
heroku run bash
sysbench cpu run --threads=16

So I then changed my approach and used the procfile directly.

Procfile

web: bash bench.sh

bench.sh

free -h
cat /proc/cpuinfo | grep "model name"
time (for i in {1..16}; do (dd if=/dev/zero bs=1M count=1512 2>/dev/null | md5sum > /dev/null) & done; wait)
sysbench cpu run --threads=16

This still showed very hight ram and CPU

heroku logs -t

[web.1]: total        used        free      shared  buff/cache   available
[web.1]: Mem:            61Gi        26Gi       4.5Gi       111Mi        31Gi        35Gi
[web.1]: Swap:          121Gi       175Mi       121Gi
[web.1]: model name	: Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz
[web.1]: model name	: Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz
[web.1]: model name	: Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz
[web.1]: model name	: Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz
[web.1]: model name	: Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz
[web.1]: model name	: Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz
[web.1]: model name	: Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz
[web.1]: model name	: Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz
[web.1]: real	0m8.683s
[web.1]: user	0m38.177s
[web.1]: sys	0m12.991s
[web.1]: sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)
[web.1]: 
[web.1]: Running the test with following options:
[web.1]: Number of threads: 16
[web.1]: Initializing random number generator from current time
[web.1]: 
[web.1]: 
[web.1]: Prime numbers limit: 10000
[web.1]: 
[web.1]: Initializing worker threads...
[web.1]: 
[web.1]: Threads started!
[web.1]: 
[web.1]: CPU speed:
[web.1]: events per second: 12035.49
[web.1]: 
[web.1]: General statistics:
[web.1]: total time:                          10.0012s
[web.1]: total number of events:              120387
[web.1]: 
[web.1]: Latency (ms):
[web.1]: min:                                    0.33
[web.1]: avg:                                    1.33
[web.1]: max:                                  168.64
[web.1]: 95th percentile:                        2.39
[web.1]: sum:                               159648.02
[web.1]: 
[web.1]: Threads fairness:
[web.1]: events (avg/stddev):           7524.1875/1082.56
[web.1]: execution time (avg/stddev):   9.9780/0.02

The specs of the web "basic dyno" is 500MB ram one "VCPU", but it seems like we are getting way more than that here. There's something wrong with my method for Heroku. Let me know (renan@lecaro.me) if you have an idea why that is so.

Taking a look at meteor cloud

My favorite framework has a cloud hosting offering, this is how they finance the development of the open source framework, and it shows. Once you pass the free usage threshold, the pricing looks scary : a "professional" container with 2 GB of ram and 2 "ECU", whatever that is, costs 158 $ / months. Instead of 5$.

Summary

1€ / month of electricity can run a production app on premise, with an initial investment for the server.

10€ / month lets you rent a server from Hetzner with similar performance and greater stability.

100€ / month lets you pay for other people's free tier and "not worry about scaling" with things like meteor cloud / heroku / aws

For a while now, i've had those two lines in my i3 config

bindsym $mod+J exec subl  ~/Documents/Journal/$(date +%Y%m%d).md
bindsym $mod+B exec subl  ~/projects/lecaro.me/src/$(date +%Y%m%d).md

They let me quickly start a note or blog post with a simple keyboard shortcut.

However, I've found that renaming the file to add a title would make my life easier when scrolling through blog and notes.

So, i've replaced it with these lines

bindsym $mod+J exec ~/projects/bins/today.sh ~/Documents/Journal/
bindsym $mod+B exec ~/projects/bins/today.sh ~/projects/lecaro.me/src/

And added these lines of bash (thanks ChatGPT) in ~/projects/bins/today.sh

#!/bin/bash
# Check if the directory parameter is provided
if [ -z "$1" ]; then
    echo "Usage: $0 /path/to/journal/directory/"
    exit 1
fi
# Set the directory where the journal files are stored
JOURNAL_DIR="$1"
# Ensure the directory path ends with a slash
JOURNAL_DIR="${JOURNAL_DIR%/}/"
# Get today's date in the format YYYYMMDD
TODAYS_DATE=$(date +%Y%m%d)
# Search for a file in the journal directory that starts with today's date
MATCHING_FILE=$(ls $JOURNAL_DIR$TODAYS_DATE*.md 2>/dev/null | head -n 1)
# Check if a matching file was found
if [[ -n "$MATCHING_FILE" ]]; then
    # Open the matching file with Sublime Text
    subl "$MATCHING_FILE"
else
    # If no matching file is found, open the standard file
    subl "${JOURNAL_DIR}${TODAYS_DATE}.md"
fi

Now, if I rename the file (but keep the prefix), it will still open when pressing window+B or window+J later that day.

When shopping, the products pushed forward are usually bad value. You have to dig a little to find the good stuff. In software, even more so. Here's a summary of what works for me.

Operating system

I started on OG Windows 98. I discovered Fedora in my first internship at university, in the Windows 7 era. I adopted Ubuntu on my dual boot laptop, then only used ubuntu, then got tired of the snap apps taking forever to start.

I'm currently using Debian. Always using old-ish sofware can be a bit annoying but I enjoy the stability and quick apps startup. I use i3 as a window manager.

I've tried FreeBSD for Desktop computing and I'm considering doing the switch eventually, to have a simpler OS that I better understand. The documentation is great and it's a chance to finally learn standard Unix tools from scratch.

Browser

I used to be a big fan of Chrome. I now avoid it like the plague.

I switched fully to firefox on both desktop and mobile when I realized that firefox mobile supported ublock. My ad blocker works well, firefox syncs my passwords and the web is fast. I use duck duck go for search.

Firefox has been going in the wrong direction though. I'm looking at ways to extract the password management with pass, to be able to use a browser that dislikes ads as much as I do, something like LibreWolf.

Code Editor / Git Hosting / Project tracking

I've started with Dreamweaver, notepad and notepad++. I relied on github to host my code.

Nowadays, I'm a happy paying user of sublime text and jetbrain products. I host my git repos on my VPS (hetzner). I edit my translation files with BabelEdit. I'm still using trello for some project tracking, but more and more I use the Readme of the project as a todo list instead.

I'd like to use Fossil for versionning and project tracking but I haven't made the jump yet.

Web Hosting / App hosting

I used to recommend wordpress for websites, then moved to heroku for web apps, then discovered that my apps ran much faster on DigitalOcean. I used to host my websites on github pages, then cloudflare pages.

All my project are now hosted on hezner heroku instance. I have set up nginx to automatically serve folders in my www directory to [folder_name].lecaro.me. Some Docker containers are managed by mup and run node and meteor apps. SSL certificates are provided by LE, wich has been a bit troublesome as they broke compatibility with devices running android 7 and older in the default browser.

I'm very happy with that setup, then only thing I might change would be to switch to FreeBSD for the OS and use a VPN to connect to the machine's private web services instead of exposing their interface publicly.

Email / Notes / Photos / Backups

I used to rely on google mail, google keeps, google photos and google drive.

I switched my email to hostinger and Syncthing takes care of the rest : notes are now a bunch of md files edited with QuickEdit+, photos are synced between my computer and phones whenever both are on wifi, and my "travel laptop" gets synced to my main workstation before every trip, which also serves as backup.

I will self host my email server because the service i currently pay for is disappointing, constantly interrupting me to push more features I don't need. For backups, I'd like to setup a server offsite with encrypted backups.

Games

I used to dual boot for games, then game on linux, but now I have a dedicated windows 10 mini pc just for gaming.

I get my games from GOG and itch.io. I mostly play old offline games, but a few of them are only avaliable through steam, so I have installed that bloatware, I just try to start it as rarely as I can. On mobile,

In the future, once windows becomes too pushy, I'll probably disconnect that pc from the net, load DRM free games using a usb key, and remove steam entirely.

Messaging, social networks, news

Whatsapp is sadly still needed, but I try to use signal whenever possible. I only use facebook to have a presence there for ciboulette.net, same thing for instagram. I've got a mastodon account and I read my news using Feeder.

I'm considering building an E2E encrypted social network at some point, as a toy project, and I also have a syncthing / markdown based news reader project that I would like to improve.

Android, maps, calendar, AI

I've flashed a LineageOS rom on my Redmi Note 7, and enjoy a very clean and responsive system. I look for apps on F-Droid when I can and my Text Launcher is super nice.

I'm still using some google products though. I pay for youtube premium because Nebula doesn't have enough content. I'm still using google maps and calendar. I moved from ChatGPT to Mistral.

I love to cook, and I dislike dull knives. I used to like pull sharpener, but the knives don't stay sharp for long with them.

OUTDOORS55 opened my eyes in his very basic video

I went on to buy a very cheap 400 grit diamond stone for 3.87€ and a polishing leather and paste for 4.64€.

It took me a bit of getting used to, but I now have very sharp knives and they stay sharp. You don't need to add water, the diamon stone should stay dry.

What's a bit sad is that an expert like that guy really just needs to make one video, clearly explaining how to get a normal knife sharp. If he wants to make a living though, he'll have to constantly push new videos that aren't really needed, presenting products that we clearly could do without.

Breakout v1 : strategic but complicated

I find the concept of the breakout game fascinating. It's so simple and open, and can be extended in all sorts of directions.

It also helps that it's visually intersting, non violent and doesn't make my girlfriend sick as 3D games do. We spent a lot of time playing with the excellent LBreakoutHD this summer and I really wanted to make a version of my own.

My first attempt sticked to the classic formular, where the ball bounces around and drops fall slowly to be picked up by the player. I tried to make most drop a real choice : each negative status effect would simultaneously boost the score multiplier.

I added many different drop types, increasing the density of drops over time as the user progresses past many levels. I decided to also reveal drops from the start, instead of randomly spawning some when the brick broke, to encourage strategic play.

I found this a bit too complex and not very approachable for beginners, requiring a lot of explanation.

Breakout v2 : you phone is the controller

My second attempt simplified the game mechanic (no more status effects, only simple coin drops) but enabled split screen play. You could play 2 players with a keyboard, or remote control the puck using your phone as a game pad, AirConsole-style.

Breakout v3 : coins explosions

The third version focuses on game feel and "juice". I added more brick colors to enable more interesting levels. Each color makes a different note when hit, so the ball bouncing around plays a sort of melody. I made sure that each level would spawn plenty of points (500 coins per level).

Wrapping a web app in a very small APK

I found that the browser experience was a bit inconsistent, particularily around fullscreen behaviour and sounds. Therefore, I wanted to wrap this very small game (66kb, 22kb compressed) into an equally small APK file.

This tutorial was very helpful, but a bit out of date, as I also needed to comment out the compose = true bit in build.gradle.kts.

I made an vector icon out of a small svg add added a full screen webview that displays the content of app/src/main/assets

package me.lecaro.breakout
import android.os.Bundle
import android.util.Log
import android.view.Window
import android.view.WindowManager
import android.webkit.ConsoleMessage
import android.webkit.WebChromeClient
import android.webkit.WebView
class MainActivity : android.app.Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        window.setFlags(
            WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN
        );
        val webView = WebView(this)
        webView.settings.javaScriptEnabled = true
        webView.settings.domStorageEnabled = true
        webView.loadUrl("file:///android_asset/index.html")
        webView.webChromeClient = object : WebChromeClient() {
            override fun onConsoleMessage(consoleMessage: ConsoleMessage): Boolean {
                Log.d(
                    "WebView", "${consoleMessage.message()} -- From line " +
                            "${consoleMessage.lineNumber()} of ${consoleMessage.sourceId()}"
                )
                return true
            }
        }
        setContentView(webView)
    }
}

All in all, the file size is now really reasonable, adding 10kb to the web version :

You can find the apk file here : https://renanlecaro.itch.io/breakout71

Adding some bells and wistles

After 3 months of iterating over the app, the kotlin code is still just one tiny file : https://gitlab.com/lecarore/breakout71/-/blob/main/app/src/main/java/me/lecaro/breakout/MainActivity.kt?ref_type=heads

I added support for downloading and uploading save files, and gameplay videos.

The game itself has grown significantly. Because it bundles translations for multiple languages, and that each translation takes a bit of space, we've reached an index.html file of 500kb, compressed to 200kb in an apk.

This is still tiny by apks standard, but not as small as I wish it was.

I chose to bundle everything in one html file to allow players to open that file offline on their desktop computer, and to make it easy to share. It does mean thaugh that every language file needs to be bundled and parsed before the game can run, which is a bit suboptimal.

Still, the game is very fun, very light, runs on tons of devices, and weights almost nothing. Posting it on F-droid was a good idea, this is where I got most of my users and even a bit of funding.

I have i3 keyboard shortcuts to write a new blog entry or note

~/.config/i3/config

bindsym $mod+J exec ~/projects/bins/today.sh ~/Documents/Journal/
bindsym $mod+B exec ~/projects/bins/today.sh ~/Documents/lecaro.me/src/

Mod + J opens today's journal entry, and Mod + B opens a blog post. I find it very comvenient, and even use it to open sublime and then look at some other files.

The issue with that is that the buffer is kept as an empty tab, and sublime asks me if I want to save it when I try to close it. I created a small plugin to stop asking to save empty buffers for files that don't exist on disk. All I needed to do was to extend sublime_plugin.EventListener in a python file placed in the ~/.config/sublime-text/Packages/User/ directory. Mistral AI struggled to follow my prompt so I ended up writing it by hand.

~/.config/sublime-text/Packages/User/dont_prompt_save_empty.py

import sublime
import sublime_plugin
import os.path

class NoSaveEmptyTabsListener(sublime_plugin.EventListener):
    def on_load_async(self, view):
       if view.file_name() and not os.path.isfile(view.file_name()): 
          view.set_scratch(True)

    def on_init(self, views):
      for view in views:
         if view.file_name() and not os.path.isfile(view.file_name()): 
             view.set_scratch(True)

    def on_modified_async(self, view):
       if view.is_scratch() and view.size() and view.file_name():
          view.set_scratch(False) 

Edit on 2025-01-14 : added the on_init part to also mark empty documents as scratch when sublime starts up.

I've bought a Xiaomi phone (Redmi Note 7) that was always a bit annoying (ads, spyware, random installs), until I finally managed to unlock the bootloader and install a pretty clean ROM.

So naturally, when that device had an defective battery, I sent it to the repair shop while buying myself a nicer, more modern Xiaomi Phone, the Redmi note 12 Pro. It even had NFC.

I thought I would just unlock it as the previous one, flash a usable ROM and be happy. The unlock process didn't really work, I though it was because the phone was brand new, so I tried to wait a few month. My old phone was working fine anyway, and sikly smooth despite being a budget phone from a few years back. It's funny how little processing power you need to run clean software.

When developing Breakout 71, I made sure to try the game on as many devices as possible, so I got that note 12 out of the box, and it's indeed a really nice phone and very capable. Sadly, when trying to unlock it again, i've been confronted to all the same dark patterns you'd expect from a company that makes ad supported cheap devices : they don't want you to clean the phone.

You first need to figure out the steps, because nothing is explained. All software (windows unlock tool, mi community app) is out of date and needs to be pulled from unknown sources.

You need to create a xiaomi account, wait 30 days, sign up for "mi comunity", configure your account to "global", click a button to "unlock your booloader" in their forum app (wtf) and then be told, every day, that the "quota" of people that got their request accepted has been reached. The company literaly pits its clients against each other for the privilege of truely owning what they bought.

It's nasty. Chinese users are even forced to "level up" their account by participating in the forums before they can ask to unlock their phones.

Next time, i'll just buy something useable from the start. Phones are so good those days, you don't need to spend more than 200€ to get a solid machine, I spent 400€ on that junk note 12 and i'll not do that mistake twice.

Keep your 120FPS advertising hell xiaomi, i'd rather use a phone that I truely own.

Beautiful software starts simple and focused on the main use case. Labels are short, screens are structured, important buttons stand out. For command line interfaces, the important options are obvious and there are good defaults.

Behind the surface however, beautiful software is capable and configurable. In the settings you will find the extra features you need, and turn them on in a click. They are not upsells of course.

Beautiful software is polished. What doesn't work well is refined until it does. Only once the known bugs are fixed and the performance is good will new features be added.

Features will wait for you to need them and not jump in you face as soon as they've been rushed to production. User happiness is the metric, not feature adoption.

The team behind good software is small, focused on one product and directly involved with users. Each team member understands every major aspect of the products and can do anything in the stack.

Ugly software wins contracts, beautiful software wins hearts. Because it's not as focused on extracting money from users as the competition, is is less profitable, and therefore looses auctions for ad clicks.

Beautiful software doesn't come to you, you have to look for it. I need more beautiful software in my life.

Written in ghostwriter.

Born from Atlassian's annoying behavior, it's a Kanban board desktop app based on local markdown files. The idea is to have a very simple, offline-only app that lets you open any markdown file as if they were a Trello board.

Minimal UI

The app is meant to be used daily and therefore puts the data up front. It is made of three parts.

The tab bar at the top lists your opened files. They are listed by title, to avoid having three "Readme.md" there. You can double click a tab to locate the file in the files browser.

The + button lets you add a file as a tab. You could also do ctrl+O. The opened files list is saved, and they are reopened when you reopen the app.

The search box filters the cards based on the presence of a keyword, and does not reset when going from one tab to the next

I try to support common keyboard shortcuts and Trello shortcuts.

• Drag and drop cards and lists to move them
• Click a card/list title to edit it
• Drag the background to scroll horizontally

Data format

Each board is one markdown file.

Anything before the first h1 is ignored, so markdown headers will be left untouched.

The first top-level title is the board name. If it is not found, the file name is used as the tab name.

Level two titles are column names.

Level three titles are card names.

Anything immediately following a title is considered its description.

Descriptions can be seen and edited in the card view.

Technologies

Currently the app is vanilla JS wrapped in Tauri. I might do a web version at some point, but local file editing is only supported in Chromium based browsers at the moment.

As most of my work, it's very lightweight. 30 Kb of js source code, but it becomes a 5 MB Tauri app once bundled. Still lighter than Electron.

Pricing

I think I'll make this app paid but DRM-free.

Something like 20€, money-back guarantee for 7 days.

I prefer to publish software as open source, like I did for Breakout 71 and many other projects, but responding to email, bug reports and inquiries takes a lot of time. Companies usually open source their complement, not their core business, and my core skill is making front ends that don't suck too much.

But at the same time, my plan is to make something very simple, with a limited feature set, that doesn't need a high price or subscription to justify its existence.

Syncthing for notes and photos

Have you heard of syncthing ? It syncs a folder between devices, like Dropbox, without the need for someone else's computer. No cloud, it's just your pc talking to your phone, directly and automatically, through your home WiFi.

It's a near perfect solution to sync your phone's photo with your computer, making google photo nearly redundant. It works great for text notes synchronization too, as long as you don't edit the same file on multiple devices while offline.

This got me thinking, how sensible could personal tech be, if it was truly serverless ?

More things could be just files

Now, this got me wondering : what if my calendar was just a bunch of text files representing events, stored on my drive. What about my mailbox, I could use pop to yank mails out of the server, add them to a list of email files that would then sync without the need to store them on the server.

What about my browser ? I use Firefox sync to synchronize my favorites, passwords and settings. Maybe those could just be files, maybe the Firefox profile folder already works when shared between android and Linux.

My contacts don't need to be on my google account. The could just be text files. Google map location history is creepy, unless it was only for me. My marked places on the map should be plain text files too. Of course my SMS should be file.

What about self hosting ?

The main private alternative to this is to self host a "cloud" service on your own hardware, be it a virtual machine on a VPS or a physical device in your home. In both cases, keeping that device reachable and secure creates a non trivial work load, requires system administration skills and it's difficult to migrate data from one app to another when the data is in db.

I've been sticking to google products for so long because I don't want to manage my own server for those things, nor do I want to switch to a different service that could shut down or enshitify tomorrow.

I wish the "data sync" and "application" parts could be separated. This would lower the chance of my data getting stuck in an app that no longer matches my needs.

Getting there

I think that for this to work we would need plugins that sync app content with a local folder of text files, in a way that doesn't break when conflict files are generated, and that generates many small text files instead of one sqlite file for example.

Sometimes we'd need full rewrite and dedicated app, for a contacts or calendar app on android for example.

Sometimes we'd use different apps on mobile and desktop to work with the same files, like I use kanbanmd on desktop and a text editor on mobile for my kanban boards.

In some case, the sync protocol can bring niceties, like Teamtype that offers real time collaborative editing.

https://syncthing.net/

Two months after writing about how we should have peer to peer data sync for contacts and calendars, I stumbled upon a project called DecSync CC on F-Droid.

It maps data (calendar, contacts, rss, map favorites) to a collections of text files specifically arranged to avoid conflicts when synchronizing them.

However, the main dev hasn't pushed any commit since 2022.
He must have gotten tired of maintaining alternate storage plugins for radicale, evolution, multiple feed readers .. It was a beautiful idea. But I think it's an incredibly hard task to keep all sorts of external apps synced this way.

Maybe the solution is to build simple, basic apps based on this sync logic, that would work both on mobile and desktop.

It might be easier to build a simple app and keep it simple, than to keep a plugin up to date with an app that's constantly evolving.

Those apps could actually be paid because of such a unique value proposition, even if the kind of people that want a p2p system for their personal life data are probably not going to be interested in a closed source paid app.

It's easy to start a cool project. It's hard to keep it running and up to date for years without pay. It's even harder to find a way to make it truely sustainable.

I've built a desktop app to use markdown files as trello boards. I thought I'd make it paid to avoid having to handle support for free users (that can get tiring with open source projects), but after seens 0 interest I'm just going to release it for free and see.

I use it daily, it's usable, even if not perfect. It's linux only for now. https://kanbanmd.lecaro.me/

I've spent a lot of time exploring various solutions to computing problems and thought I'd share a bit of my findings. You'll find a heart next to things I'd 100% recommend checking out.

Desktop

My pc runs ❤️ Debian with i3. Much more stable and simple than ubuntu, while still running all the mainstream oss apps.

• i3 as window manager
• Firefox despite some user hostile behavior. As plugins I have ❤️ ublock orgin with javascript off by default. Redirector helps avoid bad habits. ublacklist bans spam domains from search results. My search engine is now kagi, I'll give it a try with a one year starter plan. duckduckgo is also great, but I feel bad using it while blocking ads.
• Thunderbird for emails, calendar and contacts. It's a bit annoying that it can't archive + mark as read in one keypress, the calendar ui feels a bit rigid, and the "mark as spam" function just keeps the mail there. The plugins look sometimes out of place. It usually looks bad on small windows dimensions. Overally, it's a great project, I even donated, but I feel like things could be better. I'd like to contribute code there one day.
• Jetbrain All Products Pack for real world projects in all sorts of languages (js, php, ruby, rust, python)
• ❤️ Sublime Text 4 for simpler projects and notes.
• Sublime Merge when things get too hairy to manage with the git cli
• KanbanMD for project tracking instead of Trello. I need to fix the ctrl-z and tab behavior.
• BabelEdit for translations editing, so much better than doing it by hand. I just wish it was OSS to a paid translation service attached.
• OBS for screen recordings
• ❤️ flameshot for screenshots, it's great and works on windows/mac too.
• ❤️ VLC for music and movies
• Syncthing for sync of notes, photos and music mostly.
• Signal desktop but I barely use it

Mobile

My goal is to eventually transition all mainsteam apps to my iPhone X, and use a degoogled Sony Xperia 10 VI as main phone. I'm not there yet thought, so here's what's really running on my android phone :

• ❤️ Text Launcher is the simplest launcher I could find, and makes you want to debloat your phone.
• ❤️ Aegis Authenticator for 2FA OTP without cloud bs
• Breakout 71 of course, but I don't play it much.
• Clock a simple AOSP based clock.
• Fossify Contacts to display the contacts synced by DAVx5
• ❤️ OsmAnd~ for offline maps navigation. Great, feature full, but crashes from time to time. It was a real pain to export my thousands of marked places in google maps and import them here, but I managedto do it, I should share the script one day.
• Syncthing Fork to sync notes, documents, music and photos with my desktop.
• KDE connect to remote control my pc, not required but rather nice
• Fossify file manager
• ❤️ F-Droid of course
• ❤️ Feeder, and amazing rss client
• Fossify Gallery
• ❤️ kashkal to connect to my cardav server
• open camera as a simple camera that can take low res photos (i don't need 40mpx photos of my groceries receipts)
• fossify phone for a simple phone dialer
• QUIK SMS for sms/mms
• sms.lecaro.me to send welcome sms to users that signup on https://ciboulette.net/
• ❤️ thumb key is an amazing keyboard. instead of training a model to recognize your swipes, you build muscle memory to use a keyboard layout, and then you get nearly the same typing speed as gboard without the need for an ai to "read your mind" and guesstimate what you want ot type.
• thunderbird is an allright mail client.
• ❤️ vlc for music
• ❤️ Breezy weather as a simple, very reliable weather app
• wireguard to connect to my vpn.
• fossify calculator
• mastodon but I think I prefer RSS

Some of the apps i'd like to remove or move to the iPhone :

• The play store
• Aurora Store, but i'm not using it much, multiple apps refused to start after installing from there. Google's push for install source checks is working.
• Xed-Editor for text editing (notes, todo, recipes, blog posts..). Maybe too featureful for my needs, and a bit buggy, I often get crahses when reopening a file. All I want is a plain text editor with a folder view, some tabs, full text search in folder, and maybe syntax highlighting but that's not even required. I tried markor but it's opinionated in a different direction from what I want. Basically I'm looking for sublime text mobile.
• Fennec as a slightly cleaner firefox, but I no longer trust mozilla
• My banking apps, they'll move to my iPhone soon
• IDF mobilité from the play store, it uses google maps layers
• Nebula as a youtube alternative
• signal from the play store, I want to degoogle fully and I think they rely on google services, also, feature creep.
• Whatsapp (shame, shame!). Sadly I need it to talk to customers of https://ciboulette.net/. But maybe I can offer another contact method.
• YouTube : I pay (a small price) for premium, because the content available there is just not visible anywhere else.
• Unifi endpoint (to open the office door at work, I'd rather not have work software on my personal phone)

Servers

I rent three servers from ❤️ Hetzner (about 17€/month total).

The first CX32 hosts

• ciboulette production

The second CX32 hosts

• ciboulette staging
• my email with dovecot + postfix
• A cloud sms service to send SMS from real android phones
• An E2E encrypted collaborative text files editing
• breakout 71 and its archives
• the website you are reading.

The third server is a CX23 for private use only.

• radicale stores my calendar and contacts.
• git stores my private repos
• wireguard connects all my devices in a virtual private network.

The only exposed port of the private server is a random port for wireguard. I've had some issues with wireguard, It stopped working randomly for my mobile devices, but I'm not yet sure of the root cause. It could very well be my home router that's the issue.

Some of the services I'd really like to self host now are:

• Discourse or another forum instead of discord for breakout discussions. I find IRC and matrix a bit too involved. I don't even have time to chat now, so this is not urgent.
• fossil as an alternative to git for projects where I work alone anyway.
• some automatic incremental backup software for my family and myself. The trick is to find something with clients for windows and mac too. Ideally, I'd like the backup to only be readable by their author and not myself as an admin of the server.

I fixed the undo/redo bahavior, added board backgrounds and dark mode.

What is Kanban Md

It is a desktop app to manage solo projects as kanban boards, with a simple markdown file as a backend. It is offline first (for the most part, actually the background feature is online only for now). It only runs on linux for now. It is free to use, but not open source for now. I use it every day.

Fixed undo/redo

The logic of undo redo is now a little bit more sensible. If you have a card or section opened, do some edits and press undo/redo, only edits to the current card will be changed.

If you then close the card and undo, the whole edit is undone.

Before I tried to deal with both in one undo stack and that made things very complicated.

Background images

If you add an image before the first h2 of your markdown file, it will be taken as a background image for the board.

Try some of those for example

![Cover image](https://i.imgur.com/PGHn9xr.jpeg)
![Cover image](https://i.imgur.com/cUXkOfc.jpeg)
![Cover image](https://i.imgur.com/v5TrjuQ.jpeg)

Note that for now the picture must be hosted online, relative paths won't work.

Dark mode

The little button at the top right near the search lets you switch between light and dark mode.

Memorized scroll position

The app now remembers what your scroll position was on the board last time you closed it, so you are no longer sent back to the left side of the board when it refreshes or when switching tabs.

How to update/try the app

Head to https://kanbanmd.lecaro.me/ and download the linux binary, a deb or rpm. If you are still using trello, make a json export of your board and use the tool at the bottom of the page to convert it to markdown.

Happy hacking.

Renan

It is based on breakout 71 but with a focus on easier learning and less metaprogression.

The name is "Zala", for "золотой" or "golden" in Russian. As with B71, the gold is to get as many gold coins as possible. I'm trying to get a steam page ready.

It's very tempting to share the link to get encouragements, but I think I need to focus on building the game a bit more first. So for now, the result is not public. I'll push a demo when the steam page is ready.

I've updated kanban md with a few fixes to make it nicer to use every day.

• Right click actions have been added to the tabs, lists and cards
• Much nicer behavior on paste, and you can force copied sections to be pasted as cards with ctrl + shift + v
• Added the prevent default plugin to disable some shortcuts
• Focus the next card after archiving one
• Detect and close files that have been deleted or removed
• Option to open a file with the default system text editor
• More predictable undo/redo behavior, and keeps the scroll postion
• [escape] clears the search even if that input is not focused
• Remove the "duplicate" shortcut with "d" that was too easy to trigger accidentally, and not super useful
• generate a sync conflict file if the local file is not in expected state when trying to overwrite it
• check if the file changed after a long time of inactivity

This makes the app much nicer to use for me. You can get it here for linux : https://kanbanmd.lecaro.me/

Just the minimum

I keep my notes as plain text markdown files. They sync between my desktop and phones with syncthing.

However, once on device, I didn't find the perferct editor for my needs, something with strictly only what I need.

Tabby is a text editor that lets you open local text files, modify them and close them.

It asks for no permissions and has no settings. It takes almost no space on your device once installed (500kb). It has only one mode, plain text editing. It does not have syntax highlighting. It will open any text-ish file you throw at it.

Avoiding conflicts

There's only an edit mode, that tries to keep the content of the file and a textarea in sync.

You change are autosaved after 2s without editing.

The content of the editior is refreshed when you leave the app and come back to it.

You can open multiple files as tab, but you're really just editing one at a time, as your changes are saved if you leave a tab for another.

Usage

Click the + button to pick a file to edit, it will open as a tab. Edit your file, it will be saved automatically. Long press a tab to close it.

Download

You may download it (25kb) or check the source.

I'm not very good a android native dev so this is basically 500 LOC of vibe coded kotlin using google's free ai agents.

The Play Store does not run on my old devices; this led me to accidentally experience some joy while using Android.

I've recently acquired 10 identical Android 6.0.1 phones. The plan is to equip them with some SMS gateway software and ship them to some customers.

Because those phones are so old, I've had to improvise. And because I have 10 of them, I'm not too scared of experimenting. It gave me a taste of what a degoogled, compile-from-source Android OS is like. I'm starting to think I'd actually enjoy using that.

I'm forced to pick lightweight apps because the OS only has 2 GB of ram. They happen to be my favorite kind of app. I'm making my own (slop) apps when I can't find exactly what I want.

This joyful fidling comes with a big letdown by Google. I was hoping to publish my new game on the store and charge for it, but their review process is so broken, I think I'll stick to F-Droid and itch.io.

Google is simultaneously grabbing full power over app developers with their latest monopoly-consolidating move, and botching the review process to a level I have never witnessed before.

Google never cared about my apps. The review process is humiliating, alien, infuriating. The reasons an app is rejected are never clearly explained. This has always been the case; publishing mermaid gdocs years ago led me to the start of my degoogling journey.

I tried to offer my text editor Tabby on the Play Store, but it was rejected. They attached an NSFW screenshot of some unidentified app. Google is literally sending me nudes as part of their review process. I appealed, stating that this had nothing to do with my app, and (as expected) the appeal was rejected without explanation. Someone probably looked at the same screenshot and thought, "Yep, that's still p0rn"

I suspect some of the automatic app listing translations they added contained a link to some dodgy website. I'm blocked from reading the content I submitted anyway, so I can't tell. Maybe they mixed up apps during the review. Maybe they opened the wrong text file in the editor. I don't know; I can't ask anyone, and any repeat offense can lead to a full dev account deletion, so I will not try to "debug" their review process.

I no longer care. Google is never pushing free apps forward. It seems pretty clear to me that counting on Google is a bad idea. I'll keep building tools and games and share them with the people that are brave enough to venture outside the Play Store.

Google, if you want the exclusive power to gatekeep apps, you should do a much better job of reviewing them.

Edit on Oct 13, 2026: The Google Play team saw this post and apologized about the bad experience. They were really nice. They seem to really want to make it right and suddenly care a lot about getting one more text editor on the store. I'm not sure why. I'm good, though. The frog jumped out. It isn't getting back in. Thanks for kicking the pan.

I've degoogled my main phone. F-droid is now my only app store. I took the time to do a bit of digging and found some nice things I'd like to share.

Basicsync takes care of syncing notes, photos, music and videos with my computers. davx5 syncs my contacts with radicale, kashcal directly syncs with a calendar hosted on my server with radicale.

For photos, I really like "lomo camera", with its minimal ui. I review the photos in Iris gallery which is light and snappy, but a bit too featureful for my taste.

My home screen used to be "text launcher" but now it's also a vibe coded alternative which gets rid of the search, among other things.

Binary eye is fantastic to read qr codes. I've found it handy that it can also make a QR code from raw text.

I used to rely on juicessh to connect to my servers, but now ConnectBot does the job just as well.

I tried a few games and liked Edge Roll's simple inputs, and "find words" as a light brain-teaser. "quiet grid" has tastefully created clones of many board games. I haven't played much Breakout 71 or Zala recently, too busy with other projects. But my idea list if full of potential games I'd like to build one day.

My email are in thunderbird, VLC reads videos (no more youtube or nebula), breezy weather tells me if it will rain.

My browser is fennec, and I get to mastodon through snowdrop. My keyboard is Thumb-key, I love that keyboard.

I downloaded wireguard and signal as apks manually as they are not on fdroid. Signal works without the google play services, nice. I edit texts with Tabby, a text editor I vibe coded, still a bit rough but already my favourite as it has so few features.

I might have coded myself into a corner.

I started ciboulette.net 10 years ago. I have a hundred customers. It's a lot of Meteorjs code that has to keep running.

I first hosted it on Heroku, but it was expensive and slow. Then I moved to DigitalOcean thanks to meteor up, a CLI tool that takes care of setting up docker, mongo, nginx and let's encrypt certificates. It was really easy to get up and running. I moved to Hetzner eventually and added more apps on top of the mup setup.

Over time, I've understood bit by bit how some of its components work. But it's difficult to start learning when everything is already deeply integrated.

Meteor up hasn't been updated in a while. It's stuck on an old version of nginx and docker. Now, I finally have to understand what's going on on my servers. Time to learn a lot of things at once.

I feel like this often happens in tech. You find a tool that gives you superpowers. It lets you do things you could not do before. You take advantage of it, count on it, reap the benefits. Then you realize that when serious issues happen, you suddenly need to understand everything your tool did for you.

It wrote code you weren't capable of writing. Now you need to reverse engineer and debug that code.

I should resist complexity much more and keep things very basic and flat, and use tech I know well. Because building something without deep understanding is just postponing the learning time to the worst possible time.

This applies to AI of course, where you could easily vibe code a mess, then be unable to understand what you built. But also to hosting tool like meteor up or Kamal, that set up production hosting for you. Programming Frameworks often carry the same risk. They let you put all your eggs in one basket that you don't yet understand.

Those tools are useful. I'm forever thankful to zondern for meteor-up. But it's a good idea to be curious and slowly learn what's happening under the hood.

I've left whatsapp and google behind recently, and the experience has been insightful.

When leaving whatsapp, I tried to make a backup of my conversations, but that required a slow manual manipulation to be performed for each conversation one by one on mobile. It's like they don't want you to do that.

When leaving google photo, there was no way to delete my 40k photos in one go, only a laggy "scroll, select, delete, repeat" manual process.

In google maps, my takeout of all the map pins was inexplicably unusable. They gave me a csv full of web links to google map, that even gemini didn't know what to make out of. Some people made a business out of the shortcomings of that tool.

In tech, I've often seen a combination of "are you really sure ?" dark patterns and buggy, low-effort takeout options.

In real life, things get more personal. The gym suddenly treats you like a dog for cancelling your membership. They don't return your calls. The bank hides behind the fine lines of the contract. Everyone needs an expensive snail mail request for everything they don't want to do. All the sweet talk evaporates.

For some companies, it's the opposite, they only start caring about you when you churn. Your telephone rate suddenly goes cheaper. Your natural gas price inexplicably gets slashed in half. They go from treating you like an anonymous excel line to a VIP.

All that to say, if you're not sure about investing more into a company, try to leave and see how that goes. Often you'll get to see their true face or get a nice discount.