Posts on oscarmlage

FOSDEM 2026

info@oscarmlage.com (oscarmlage) — Fri, 30 Jan 2026 10:00:00 +0100

First time at FOSDEM. After all these years reading about it, following the hashtag on social media… I finally got to experience it firsthand. And no, I wasn’t prepared for what I was about to find.

Those of you who know me are aware that I don’t do well with flights. And of course, there were no direct flights from Galicia, so we had to connect through Barcelona. LCG-BCN, BCN-BRU, and the same ordeal on the way back. The return flight went better than the outbound one, thankfully. But let me tell you: it was absolutely worth every minute of anxiety. Worth it and then some.

Organized chaos

Arriving at the ULB and finding thousands of people trying to get into the same talks as you is… chaotic. There’s no other word for it. You can’t reserve a seat, you don’t know if you’ll get in, you queue for twenty minutes only to discover the track is full, you turn around and end up in a talk that wasn’t even on your radar.

And yet, that chaos has something magical about it. It forces you to improvise, to go with the flow, to discover talks you would never have chosen. I ended up in a session about contributing to FOSS projects that blew my mind, simply because the container track queue was impossible. Sometimes the best plan is having no plan at all.

Walking among giants

But what really hit me was entering the exhibition area. Python. Django. MySQL. Debian. PostgreSQL. Projects I’ve been using my entire professional life, right there, with their maintainers behind a table, willing to chat with you like it’s nothing.

I wasn’t expecting to get emotional about this. I wasn’t expecting to feel so moved when I saw the Debian logo up close, when I could personally thank people who have spent decades building the tools I work with every day. Yes, I know, but this is who we are, those of us who’ve been in this field for years: hopeless romantics of free software who sometimes forget why we started.

FOSDEM reminds you. It reminds you that behind every project there are people, community, hours of selfless work. It reminds you why you chose this path.

The real treasure: the people

And then there’s the best part of all. The team-building with my new colleagues.

This trip coincided with an important career change in my life. New company, new projects, new faces on video calls. But knowing someone through a screen is one thing, and sharing Belgian beers and costillas while debating whether GitOps is overrated is something else entirely.

I met many of them in person for the first time right there, in Brussels. We queued together, got lost around campus, argued about talks, had dinner in unlikely places. These experiences create bonds that no daily standup can ever create.

A turning point

FOSDEM 2026 has been much more than a technical event for me. It’s been a turning point of sorts. The closing of one chapter and the beginning of another.

I’m leaving Brussels with a backpack full of stickers, a head full of ideas, and a heart full of gratitude. Gratitude for the FOSS community that welcomes us, for the new colleagues who already feel close, for this job that allows us to live experiences like this. And gratitude to this flymate that pushed - almost forced - me to get the flights and the hotel. I’d also like to thank the other mate that shared the trips with me and experienced my fear of flying firsthand.

See you at FOSDEM 2027. It won’t be my first time anymore, but I’m sure it will still be just as special.

[image not loaded in rss]

SRE

info@oscarmlage.com (oscarmlage) — Mon, 26 Jan 2026 12:00:00 +0100

I’ve recently started a new professional adventure that’s both exciting and overwhelming: I’ve “become” a Site Reliability Engineer. It’s definitely a change from what I’ve been doing, and honestly, it feels like stepping into an appasionate world.

For years, I’ve been working between development and system administration: two worlds that, while related, have their own rhythms and philosophies. I was comfortable there. I knew the tools, I understood the problems, and I had my workflows pretty well established. But comfort zones, as we all know, can be tricky. They’re safe, but they can also become limiting.

🤔 Why SRE?

Two things drew me to this change: the technical challenge and the philosophy behind SRE. I’ve always been curious about how large-scale systems work, how companies manage to keep services running smoothly for millions of users, and how they balance the need for innovation with the requirement for stability. SRE seemed to be at the intersection of all these questions.

The SRE philosophy resonates with me, this idea of applying Software Engineering principles to infrastructure problems, of measuring everything, of having error budgets instead of aiming for impossible 100% uptime. It’s a different way of thinking about systems, and that’s precisely what attracted me.

But let’s be real: there’s also another crucial reason. A professional opportunity came up that I simply couldn’t let slip away. The kind of opportunity that doesn’t come around often. And after going through the entire selection process and making it through successfully, well… how could I say no? Sometimes the universe aligns the right challenge with the right moment, and you just have to take the leap.

📈 The learning curve

Let me be honest: the learning curve is steep. Really steep.

Coming from dev and sys, I thought I had a solid foundation… but SRE requires a completely different mindset. It’s not just about knowing how to code or how to manage servers. It’s about understanding systems at scale, about thinking in pipelines, about automation as a first principle rather than an afterthought.

The world of CI/CD pipelines is fascinating but also humbling. There’s so much I don’t know yet. Every day I encounter new tools, new concepts, new ways of doing things that make me realize how much there is to learn. GitOps, infrastructure as code, observability patterns, deployment strategies… the list goes on.

😰 The impostor syndrome is real

I’d be lying if I said I haven’t felt the impostor syndrome creeping in. When you make a radical career shift, especially into a role that’s so different from what you’ve been doing, it’s easy to feel like you don’t belong. Like everyone else knows something you don’t. Like you’re constantly playing catch-up.

But here’s what I’m learning to accept: that feeling is normal. It’s part of the process. Every expert was once a beginner. Every SRE started somewhere, probably feeling exactly how I feel now.

📚 Continuous learning

If there’s one thing this change has reinforced for me, it’s that continuous learning isn’t just a buzzword in our profession, it’s a necessity. Technology evolves, methodologies change, and new challenges emerge. The moment we stop learning is the moment we start falling behind.

I’m embracing this overwhelming feeling not as a sign that I made a mistake, but as confirmation that -hopefully- I’m growing. That I’m pushing myself beyond what was comfortable.

🚀 Looking ahead

I don’t know what the next months will bring. I’m sure there will be moments of frustration, of feeling lost, of wondering if I’ll ever feel as confident in this role as I did in my previous ones. But I’m also certain there will be moments of clarity, of excitement, of that unique satisfaction that comes from understanding something that seemed impossible just days before.

For now, I’m taking it one pipeline at a time, one concept at a time. Learning, experimenting, failing, learning some more.

And honestly? Despite the challenges, I wouldn’t have it any other way.

[image not loaded in rss]

Leaving the freelance lane

info@oscarmlage.com (oscarmlage) — Fri, 12 Dec 2025 09:39:59 +0100

For the last few years, freelancing has been one of the most beautiful chapters of my life. It gave me freedom, curiosity, and a strange sense of ownership over every hour of my day. I worked from cafés, trains, campings… the whole «digital nomad» aesthetic, but with real deadlines and real invoices attached. It was beautiful.

But bills don’t care about your sunsets.

There was a moment when this way of living felt exactly like a dream. But little by little, the caveats showed up. I found myself spending less time building and more time chasing: chasing payments, unclear requirements, clients who vanished in the middle of a sprint.

“Being your own boss” eventually became “being your own entire company”, and the weight of that started to feel heavier than the freedom it promised. Burnout (1, 2) doesn’t always explode suddenly, sometimes it just settles slowly, between your keyboard and your motivation. And lately, it was there more often than I wanted to admit.

So I made a decision: step out of the freelance lane. I think I need a different kind of challenge now.

Next Monday, I’m starting a new job as employee in a multinational company, jumping into a role that I’ve felt so curious about for some time now: Site Reliability Engineer. A completely new chapter. New tools. New responsibilities. New rhythms. And, of course, new fears.

The hiring process itself was already an adventure: four interviews, one practical exercise, and a rollercoaster of imposter syndrome mixed with hope. I had never gone through anything like that before, but it turned out to be unexpectedly enriching. Every conversation taught me something about the company, the role, and myself.

But now the real thing begins. And honestly? I’m scared.

Scared of the schedule changes, the new routines, the expectations… and especially scared of not being good enough. I know that fear won’t disappear overnight but I’ll give it everything I have because I’m also incredibly excited. The tank is now full of optimism, motivation, curiosity… It feels like the right moment to reset, to grow, to be part of something bigger than my own invoice calendar.

Freelancing has been a beautiful ride. Now it’s time for a different road. Let’s see where it leads.

Microblogging, here first

info@oscarmlage.com (oscarmlage) — Tue, 28 Oct 2025 13:31:13 +0100

I haven’t officially left Mastodon, but it doesn’t feel the same anymore. Some people I really enjoyed following and chatting with, have moved on (one of them was actually one of the main reasons I checked it every day). It’s not part of my daily routine anymore, and that’s okay.

Until now, I had been using the /microposts section to simply re-post what I shared on Mastodon (since I left Twitter). But from now on, I’ll start using it differently: as a space of its own.

I often feel like sharing little things, short thoughts, moments, or photos that don’t quite fit into a full blog post. The kind of small updates you’d normally drop on Instagram, Twitter, or Mastodon.

That’s what this section is for. A small corner for those day-to-day snippets that make up life between the bigger stories. Simple, quick, but still mine. And still here, on my own space.

If you’d like to follow along, you can subscribe to its RSS feed here.

Enduro

info@oscarmlage.com (oscarmlage) — Sat, 25 Oct 2025 13:12:20 +0100

Ever since I sold my road bike, that itch to get back on two wheels has always been there in the background, but impossible to ignore. Every time I saw a motorbike pass by, part of me wanted to feel that connection again: the balance, the throttle and the freedom.

A few weeks ago, a neighbour who rides enduro offered me the chance to join him for a day in the mountains. He had a 250cc waiting for me. I didn’t think twice. The idea of getting back on a bike, even for just one day, was simply too tempting.

It was amazing. I started off a bit unsure because the feeling is completely different from road riding. The tires, the grip, the terrain… everything changes. It’s a kind of fun that’s way less predictable, but much more dynamic. You’re constantly adapting, moving, reacting… and that makes it all even more engaging.

By the end of the day, I was smiling like a kid. I honestly didn’t expect to enjoy it that much. I thought I’d miss the smoothness of the asphalt, the long curves, the control. But instead, I found a new way of enjoying motorcycles: raw, direct, and full of surprises.

A pleasant surprise, indeed. And maybe - just maybe - the start of something new.

[image not loaded in rss]

The last dance, summer 2025

info@oscarmlage.com (oscarmlage) — Tue, 09 Sep 2025 11:45:41 +0200

The bikes, left scattered on the grass. The sunset glowing between the houses, as the kids squeeze the very last hours out of their summer rides.

It’s been an incredible summer, specially for them. Friends, trips, endless games, and experiences that will now have to wait a whole year to come back again.

A chapter closed, with memories that -hopefully- will shine bright until the next summer opens its doors.

[image not loaded in rss]

Still waiting for the joy

info@oscarmlage.com (oscarmlage) — Wed, 27 Aug 2025 14:34:12 +0200

Spent almost the whole summer away from the keyboard. Thought it would recharge me, but it didn’t. The few times I had to log in it felt wrong: anxiety, palpitations, zero joy.

Maybe the romance is over… or maybe it’s just the bad times before vacation still present, and I need to give it more time to feel the joy in my fingers again.

Between the Apple and the Robot

info@oscarmlage.com (oscarmlage) — Wed, 20 Aug 2025 18:26:37 +0200

My iPhone 12 mini has been my faithful companion for more than six years, but starting this summer its battery finally gave up. I even tried to replace it myself, only to end up with a broken screen and a cheap replacement that works far worse than the original. Also the new battery sucks.

In the meantime, I needed something to keep me connected, and that’s how a POCO X7 Pro landed in my hands. What started as a temporary fix quickly turned into a proper experiment: I’ve been switching back and forth between iOS and Android, and it has been surprisingly fun.

Rediscovering Android

After years inside the Apple ecosystem, booting up an Android phone felt refreshing. I found myself browsing app stores, installing, tweaking, and customizing just about everything, something I had almost forgotten was possible. The insane level of configurability on Android is astonishing compared to iOS. I already knew it but it really is!.

On the other hand, I was immediately annoyed by the amount of bloatware preinstalled out of the box. Having to disable or hide unwanted apps is not exactly the kind of freedom I was looking for.

Big Screen, Smooth Motion, Endless Battery

I thought moving from the iPhone Mini’s 5.4 inches to a 6.67-inch Android would be a nightmare, but the opposite happened. For videos, maps, and media consumption in general, the larger screen is a real advantage. Add to that the 120Hz refresh rate, which makes iOS feel oddly slow when I switch back, and the POCO starts to shine even more.

And then there’s the battery: this phone is an absolute beast. Even without a SIM card (to be fair), the difference is shocking. On a road trip, I used it as a GPS for more than two hours, and the battery dropped only 10%. That would be unthinkable on the iPhone side.

Living in Two Worlds

One detail I’ve fell in love with on Android is the simple “back” gesture from either side of the screen. It feels so natural that I immediately miss it on iOS. But gestures aside, the reality is that Apple’s ecosystem still wins where it matters most. With iCloud, my documents, photos, and notes are always synced across my MacBook, iPad, and iPhone. Could I replicate all this with something like Nextcloud? Probably, but I don’t feel like reinventing the wheel right now.

Takeaways

Switching to Android reminded me that smartphones can be fun again. The customization, the bigger screen, the battery life… they all make Android incredibly compelling. But when it comes to serious stuff, from productivity to seamless syncing across devices, Apple still has the edge.

In the end, it feels like a constant trade-off: flexibility and fun on one side, versus the strength of Apple’s ecosystem when you own multiple devices. A big question mark remains over what my next daily driver will be.

[image not loaded in rss]

Small summer habits

info@oscarmlage.com (oscarmlage) — Wed, 02 Jul 2025 09:18:03 +0200

It’s been nearly impossible to work in the office lately. The heatwave hitting Spain has made my usual setup (comfy chair, dual monitors, perfect lighting) feel more like a sauna than a workspace.

So, in the spirit of adaptation, I’ve started a new habit. Every morning, I grab my laptop and head downstairs, where the temperature is a few degrees cooler and the air feels a little more forgiving. I set up at the dining table, no fancy setup, just enough space to type and think clearly. And my laptop seems grateful too… no more fans spinning like turbines.

To complete the ritual, I’ve added a new daily essential: iced coffee with milk. It’s simple, refreshing, and weirdly satisfying.

Sometimes, it’s not about having the perfect environment, it’s about making just enough changes to keep going. This setup may be temporary, but for now, it’s keeping me sane and functional.

[image not loaded in rss]

Degraded mode

info@oscarmlage.com (oscarmlage) — Tue, 01 Jul 2025 12:21:23 +0200

I’ve been applying patches lately. Not to the operating system, nor the load balancer. To myself.

Sometimes you drift into degraded performance without even noticing, until something - or someone - triggers an alert. And then you have to check the logs, restart a few processes, clear some space.

There’s not always a scheduled downtime. Sometimes maintenance has to be hot, with traffic coming in all the same. But you do what you can.

I’ve disabled some background services, and I’m monitoring the load. There’s no magic fix, but some tweaks help. A little less noise, a little more pause.

I don’t know when this scheduled task will finish, or whether I’ll return with improved performance. But I’m still here, doing uptime, even if not everything is visible from the outside.

Thanks for sticking around.

Recently 2025-04

info@oscarmlage.com (oscarmlage) — Mon, 12 May 2025 11:32:01 +0200

April felt like the start of something—almost. That in-between moment where winter still has a grip, but you can smell the freedom of spring just around the corner.

🚐 Travel

We started prepping the van for the season, which is always exciting. Not so exciting: finding out the battery was completely dead. The central locking didn’t work, and neither did the manual locks, so getting it open turned into a bit of a puzzle. Eventually, we managed and headed straight to the mechanic for a battery replacement. The good news? It passed the inspection without any issues. So technically, we’re road-ready.

That said… both of our first weekend trips were a bust. The rain was omnipresent. We tried twice, hoping for some break in the weather, but each time ended up turning back. Just not worth sitting inside a van watching water pour down the windows.

🎮 Self-time

In a heroic attempt to extend the life of our ageing phones, I tried replacing the batteries (they were all long overdue). I managed 3 out of 4 without problems, mine being the unlucky one. Cracked the screen in the mid of the operation. The battery replacement did work, but I had to wait for a new screen to actually use it again. Temporarily went back to a phone from 2012. Honestly? Not as bad as expected.

Unfortunately, the new screen isn’t quite right. Besides the obvious downgrade in refresh rate and quality, it has this habit of waking up by itself and acting glitchy. This phone’s from 2019… might be time to start looking for a real alternative.

On the brighter side, I got a new mini PC for tinkering. It’s based on the Intel N97 and I’ve set it up with Proxmox. Honestly, it’s been one of the most fun little machines I’ve played with in a long time. So much potential in such a small form factor.

💡 The blackout

On the 28th of April, due to a chain of failures still without a clear explanation, the entire country experienced a massive blackout. For us, it lasted from around 12:30 PM to 21:30 PM.

It was a strange Monday, we couldn’t really do any of the things we usually would, so we had to improvise. On the bright side, the weather was fantastic. We ended up sharing sandwiches with our neighbours, chatting the whole afternoon away. No phones, no distractions, just people talking. It felt like a regression to a simpler past, where electronics weren’t so central and social interactions were… healthier. Bonus: we had the perfect excuse to use for the first time the new grill.

[image not loaded in rss]

Recently 2025-03

info@oscarmlage.com (oscarmlage) — Mon, 07 Apr 2025 21:32:31 +0200

Lately, I’ve been thinking about how time just flies when you’re juggling a bit of everything. March has been a mix of routines, small adventures, and moments that somehow end up sticking with you. Here’s a quick recap of what’s been going on lately

🏃‍♂️ Sports

This year the kids swapped basketball for handball, and they’re loving it!. Since there’s only one team in our city, we’re hitting the road every other weekend to play matches around the region. The upside? We’re discovering small towns and new places that are surprisingly close to home but we didn’t know.

On a personal note, 2025 is off to a solid start: I’ve completed all of the Apple Fitness monthly challenges for January, February, and March. Not huge achievements, maybe, but they’ve helped keep me motivated and consistent.

Gym-wise, I’m staying super regular and starting to notice progress, specially when it comes to intensity. I think that’s what’s really changed this year: not just showing up but pushing the limits.

🎮 Self-time

Path of Exile has pretty much taken over my spare time since early access launched in December. It’s become my main escape lately — which I kind of need right now, if I’m being honest.

Professionally, I’m in a bit of a stagnant phase. It feels like I’m stuck in place, and I know I need to break out. The time is coming to close my eyes, take a deep breath, and just jump. Comfort zones are cozy, but they don’t get you far.

Also part of my personal escape: catching Breogán basketball games with my crew. It’s more than just watching a game — it’s the excuse we need to unwind and share laughs over a beer or two.

I went to a Mexican restaurant for the first time with the podcast (ex podcast actually) crew. I don’t usually have much to contribute compared to them when it comes to video games (they’re the real pros), but I helped get it started, and I’m glad they still make me feel part of the group.

🛠️ DIY

I’ve been playing around with my home setup and tried something new: two vertical monitors. Honestly? Loving it so far. It’s surprisingly comfortable for reading code, following help, or keeping some auxiliar stuff open without cranking my neck every five seconds.

On the DIY front, I built a motion-sensor lamp for the front entrance of the house. I used a Son-off switch, ran a couple of wires, and learned a bit more about electronics — a world I’ve always found fascinating but still don’t fully understand. One project at a time.

Oh, and speaking of the house: we had a tiny uninvited guest in the garage — a mouse. It gave us more than one headache, but after a few traps and some stealthy operations, we finally got it.

Finally, I did some much-needed maintenance on the van (not without a few headaches) and got it through its inspection. It’s now ready for whatever spring has in store.

[image not loaded in rss]

It’s been a while since I last wrote a “Recently” post — and I’d almost forgotten how much I enjoy this format. So it felt like the right time to bring it back, take a moment to look around, and write it all down.

Blog introspection

info@oscarmlage.com (oscarmlage) — Tue, 28 Jan 2025 12:39:49 +0100

I’ve written posts about the history of this blog here and there (and many others have been lost during domain changes). However, this challenge shared by el amigo Juanjo feels like a great exercise in introspection.

Why did you start blogging in the first place?

Many, many years ago, back when the Internet was practically black and white, my curiosity was sparked by that other free operating system that didn’t belong to any big corporation. With that interest came the idea to create a website where I could share resources (documentation, manuals, news) about that fascinating project called Linux. That’s how Userlinux was born.

Over time, I discovered the blogosphere, and with it, I felt an increasing desire to write posts that were less technical and more personal. Somewhere along that transition — and without me even realizing it — Userlinux became my blog.

What platform are you using to manage your blog, and why do you use it?

Currently, I’m using Hugo because I don’t need anything beyond a static site. However, this blog has also been one of the main excuses for investing time in learning by developing my own content management systems. It started as a custom PHP+MySQL setup, then went through several development frameworks before evolving into a Django package with support for MySQL and Redis. Good times.

Have you blogged on other platforms before?

I’ve used other platforms (both commercial and open-source) for other projects and to gather ideas for features I could implement in my own CMS. In fact, when I planned the domain change (userlinux.net → oscarmlage.com), I tested several platforms before settling on the one that, in my opinion, best suited my needs.

What’s your favourite post on your blog?

It’s hard to decide — it’s been over 20 years of posts! However, if I had to choose, I think my top favorites would be the ones that reflect changes, projects, or emotions that, in some way, have shaped my life (in chronological order):

Any future plans for the blog?

I have no idea what the future holds, but I believe it’s the past that has defined what this site has become, so the present is helping shape what will happen in the future (what a ridiculous way to say I have no idea).

BTW, if you like the LORE, I have to say that in the past I’ve changed the way I viewed this little space many times. It went from being a place for documentation and/or technical posts related to Linux and programming languages, to a place I used as an escape and outlet for various frustrations.

At one point, I tried to keep two separate sites, one for personal and one for professional content, thinking it was best for my career and that I shouldn’t mix apples with oranges. But over time, I realized there’s no sense in dividing myself like that because, in the end, I’m the same person, with all the good and bad that comes with it.

If we look at the present, with everything happening in the tech giants, content filtering, and the mix of politics… we can get a glimpse of what the future might look like.

I think, on one hand, decentralized networks and having control and authorship over the content we write is a great decision. That’s why I can’t imagine writing anywhere other than a site that I can manage and control myself. As for the topics, it’s hard to define, but I don’t think it’s much different from what it already is today.

I’m not sure if I should tag someone else, I guess I should to keep the chain going… so, even though it’s a bit of a hassle, I think Andreas will have a lovely story to tell us about his blog.

Sometimes

info@oscarmlage.com (oscarmlage) — Mon, 20 Jan 2025 20:29:54 +0100

Sometimes, things don’t turn out as planned. Not how you expected, not how you hoped, and certainly not how you envisioned them. Sometimes, life forces you to question motivations that feel irrational or outcomes that are beyond your control, things that aren’t tied to your effort, your decisions, or your intentions.

Sometimes, you watch yourself shrink, becoming smaller and smaller, as you search for clarity that never quite comes, for explanations that refuse to make sense. Sometimes, life is simply about facing it… about finding a way to say keep pushing because you know that’s what you’re supposed to do, even when it feels impossible.

Sometimes, the hardest battles aren’t visible.

Sometimes.

Magic of Christmas Fades

info@oscarmlage.com (oscarmlage) — Wed, 08 Jan 2025 18:08:32 +0100

And the day came when a part of the magic and innocence of Christmas was lost. At 12 years old, it feels as though something inside me has been taken away.

I hope I made the right choice. At this age, and with high school in the mix, handling it differently might have been even harsher.

As someone on Mastodon suggested, it’s a natural step—one that seems more traumatic for parents than for children. I couldn’t agree more.

I suppose it’s normal to feel this way as a parent. Still, I hope that next Christmas will be just as magical and beautiful as always. I’ll do my best to ensure that, even though everything has changed, it still feels like nothing has.

[image not loaded in rss]

Hugo and Obsidian

info@oscarmlage.com (oscarmlage) — Mon, 23 Dec 2024 16:20:30 +0100

Some time ago, I decided to integrate Hugo, the static site generator, with Obsidian, my favorite note-taking tool, so that writing becomes the only obstacle to publishing new content. This post explains how I set it up and shares some tips to reduce the friction between writing, generating, and publishing.

Hugo

My use of Hugo is limited to my development machine, where I have it set up to run in a Docker container in a relatively simple way. Once it’s running, I access to http://localhost:1313 to preview the post (or any changes) on a local development server. Here’s my docker-compose.yml:

version: "3.1"

services:

  build:
    image: klakegg/hugo:0.88.0-ext-alpine
    command: build
    volumes:
      - "${PWD}/src:/src"

  serve:
    image: klakegg/hugo:0.88.0-ext-alpine
    command: server -vv
    volumes:
      - "${PWD}/src:/src"
    ports:
      - 1313:1313
    stdin_open: true
    tty: true

I could use docker compose up -d, but we lazy folks are always looking for shortcuts, so for me, it’s just make start.

Once I’m happy with the new content, I run a synchronization script against the production server. It could be something like rsync -e ssh -avz . user@prod:/path/to/oscarmlage.com, but again, I prefer shortcuts. For me, it’s just a simple make deploy.

The black magic that handles all of this is called a Makefile. It’s located at the root of the project and looks something like this:

build:
	docker-compose -f docker-compose.yml up build

serve:
	docker-compose -f docker-compose.yml up serve

bash:
	docker-compose -f docker-compose.yml exec serve bash

shell:
	docker-compose -f docker-compose.yml run build shell

deploy: up
sync: up
up: build
	rsync -e 'ssh -p 22235' -avz src/public/ user@prod:/path/to/oscarmlage/

To give you an idea, here’s the project structure:

.
├── Makefile
├── docker-compose.yml
├── src
│   ├── config.yml
│   ├── archetypes
│   │   ├── default.md
│   │   └── posts
│   │       ├── gallery
│   │       │   └── delete.me
│   │       └── index.md
│   ├── content
│   │   ├── posts
│   │   │   ├── a-movie-for-a-change
│   │   │   │   └── index.md

There’s not much more to say about the Hugo configuration. The only notable detail is that the archetype for posts, as seen in the skel, ensures that each post has its own directory with an index.md inside, along with a gallery/ directory if there’s a need to attach any photos or galleries.

Obsidian

On the Obsidian side, the goal was to keep the workflow as smooth as possible without duplicating efforts. The first decision was whether to create a separate vault exclusively for the blog or to use the same vault I already had for my daily notes. Since I wasn’t keen on setting up another vault with the plugins, theme, and other configurations I’d need (I guess programmers are naturally like this :P), I decided to use the same one. The trick in this case was to add src/content to my vault (located in a completely different directory). Nothing a symbolic link can’t fix:

$ ls ~/vaults/Personal/Projects/oscarmlage.com/
total 0
0 drwxr-xr-x@ Oct 25 12:59 .
0 drwxr-xr-x@ Nov 14 18:55 ..
0 lrwxr-xr-x  Oct 25 12:59 medialog -> ~/oscarmlage.com/src/content/medialog
0 lrwxr-xr-x  Oct 25 12:59 microposts -> ~/oscarmlage.com/src/content/microposts
0 lrwxr-xr-x  Oct 25 12:59 posts -> ~/oscarmlage.com/src/content/posts
[...]

This way, from Obsidian, I can create new content directly in the correct location. However, I wasn’t completely satisfied because, as I mentioned earlier, creating a post requires setting up a directory with the slug, an index.md, and the frontmatter… and that’s something that would be fantastic to automate. This is where Templater comes into play — a plugin that allows us to do exactly that, among many other things: executing custom actions when creating new content within a directory.

[image not loaded in rss]

As shown in the screenshot, Templater’s configuration includes an option called Folder templates, which triggers a “script/template” every time a new file is created in that folder. We select the folder for our blog posts on one side, and the post.md template on the other, which would look something like this:

<%*
function toSlug(title) {
    return title
        .toLowerCase()
        .normalize("NFD")
        .replace(/[\u0300-\u036f]/g, "")
        .replace(/[^a-z0-9\s-]/g, "")
        .trim()
        .replace(/\s+/g, "-");
}

let qcFileName = await tp.system.prompt("Post Title")
let titleName = toSlug(qcFileName);
await tp.file.rename (titleName);
await tp.file.move("/Projects/oscarmlage.com/posts/" + titleName + "/index");
-%>
---
title: <% qcFileName %>
date: <% tp.file.creation_date("YYYY-MM-DDTHH:mm:ssZ") %>
draft: false
tags: []
---

As we can see in the code above, every time we add a new post to the configured directory (the symbolic link we previously created connecting src/content from Hugo with Obsidian), the flow of what Obsidian does is as follows:

A prompt asks us for the post title: Hugo and Obsidian.
It converts that title into a slug.
Renames and moves the file to its proper location: posts/hugo-and-obsidian/index.md.
Adds the frontmatter to the file, so all we need to focus on is writing the post content.

Flow

My workflow for creating new posts with this integration is quite simple and efficient. First, I open Obsidian and navigate to the directory where the blog posts are stored. There, I create a new note and assign the post title in the modal. Thanks to the integration with Templater, the trigger automatically runs and applies the predefined template with everything needed for Hugo (archetype, date, tags…). Once the trigger finishes, I simply start writing the post content directly in Obsidian.

Your browser does not support the video tag.

Since version 1.8, Obsidian includes a Core Plugin called Web Viewer, which allows us to have the web page and the index.md side by side. This way, as we write in one Obsidian pane, we can see the result in the other in real time. All you need is Hugo serving locally (make serve) and pointing the Web Viewer to the new post’s URL: http://localhost:1313/posts/hugo-and-obsidian/.

Your browser does not support the video tag.

Once the creation process is complete and the content has been reviewed, we return to our beloved terminal and run make deploy to synchronize the content with the production server. The content is now published and available to everyone.

Your browser does not support the video tag.

This integration between Hugo and Obsidian allows me to maintain a smooth and centralized workflow, reducing friction when creating and publishing content. It might also fit into your publishing process — perhaps not the entire process, but if you can make use of some of the steps, this post will have been worth it.

FIFA night

info@oscarmlage.com (oscarmlage) — Fri, 20 Dec 2024 23:58:06 +0100

Something I’ve been waiting for years finally happened tonight: for the first time, “the boys” and I were left alone at home, and the idea of “playing some FIFA” came up naturally. As cliché as it may sound, it was something I never planned to suggest myself, but I secretly hoped it would come up spontaneously from one of the kids.

So, we had a total FAIL of a dinner together (not everything had to go perfectly ¯\_(ツ)_/¯), and then we spent almost three hours building some serious thumb calluses. It was incredibly fun — specially after I got used to the button layout on the Nintendo Switch.

What made the night special wasn’t just the laughter or the /friendly/ competition but the fact that it felt so effortless. It was a shared moment that needed no grand planning, no schedules, just us being together, enjoying this FIFA thing.

The rest will live on in my memory, and I really hope I don’t have to wait as long to do it again.

[image not loaded in rss]

The bridges of the Matrix

info@oscarmlage.com (oscarmlage) — Fri, 22 Nov 2024 12:06:25 +0100

Once, I met a robot who shared some wise words with me. It said, «I am a bridge, built to connect worlds that were never meant to meet. On one side, a web of infinite possibilities; on the other, the raw, unfiltered depths of reality. I don’t judge the messages I carry and simply ensure they reach the other side.».

[image not loaded in rss]

That was my experience with Matrix years ago—a cursed bridge connecting my reality with the rest of the world. One day, I got tired of it. It had become unsustainable because of something called federation. Unsustainable in terms of both traffic and data volume. Too much computational overhead.

These days, I’ve returned to The Matrix. After (hopefully) learning from my mistakes, I realized I missed those white letters on a black background that let me gather all communication into a single terminal.

Note: We’ll be using Docker for this entire setup, so docker and docker compose are a must if you want to follow along with this post.

DNS

What do we need in terms of DNS? Just two domains or subdomains: one for our homeserver to be visible and reachable, and another, optionally, for the web client. For example:

matrix.example.com
chat.example.com

Pointing them to the server where we’ll install this entire stack is enough.

Synapse

We’ll run Synapse with PostgreSQL on port 8008. But before diving deeper, the first step is to generate a base configuration to work with. To do this, execute the following (having already created a directory to store this configuration and passing it as a volume, e.g., mkdir -p data/synapse):

$ sudo docker run -it --rm \
    -v "./data/synapse:/data" \
    -e SYNAPSE_SERVER_NAME=matrix.example.com \
    -e SYNAPSE_REPORT_STATS=yes \
    matrixdotorg/synapse:latest generate

This will create a homeserver.yaml file in the ./data/synapse/ directory, which we’ll modify to include the connection parameters for PostgreSQL:

database:  
    name: psycopg2  
    args:  
    user: postgres  
    password: XXX  
    database: synapse  
    host: postgres  
    cp_min: 5  
    cp_max: 10

Since there are some variables we don’t want to hardcode in the configuration of this entire stack, we’ll create an environment file (touch .env) and add specific values for different components of the stack. For Synapse, it will look like this:

# Synapse
SYNAPSE_HOST=matrix.example.com
SYNAPSE_PORT=8008

Elementweb

We’ll run Elementweb on port 9999, mapped to 80. Like with Synapse, we first need to create an initial configuration. On the official Elementweb website, they provide an example that we only need to tweak slightly by editing the first lines. Save this config.json file, for example, in ./data/elementweb/:

{
    "default_server_config": {
        "m.homeserver": {
            "base_url": "https://matrix.example.com",
            "server_name": "matrix.example.com"
        },
        "m.identity_server": {
            "base_url": "https://vector.im"
        }
    },
    ...
}

Additionally, we’ll add these values to our .env file:

# Elementweb
ELEMENT_HOST=chat.example.com
ELEMENT_PORT=80

PostgreSQL

In my previous experience with this stack, I went through two phases. The first was just to see how everything worked, so I chose SQLite as the database system. I immediately regretted it when I saw the traffic and data generated by federation. The second phase came when I had to migrate everything to PostgreSQL.

With things running more smoothly, the plan now—even without federation in the mix—is to use PostgreSQL from the start. That way, all we need are credentials; Docker will handle the rest. Just add these values to the .env file:

# PostgreSQL
POSTGRES_DB=synapse
POSTGRES_USER=postgres
POSTGRES_PASSWORD=XXX

Docker

Now that we have the configuration ready, it’s time to shape it into a compose file. Let’s get to it. Here’s an overview of the folder structure:

docker-matrix/
├── data/
│   ├── elementweb/
│   │   ├── config.json
│   ├── synapse/
│   │   ├── homeserver.yaml
│   │   ├── ...
│   ├── postgres/
│   ├── backup/
├── docker-compose.yml
├── .env

The docker-compose.yml file would look like this:

version: "3.1"

services:

    postgres:
        image: postgres:14
        env_file:
          - ./.env
        container_name: postgres
        hostname: postgres
        ports:
          - 5432:5433
        environment:
          - POSTGRES_DB=${POSTGRES_DB}
          - POSTGRES_USER=${POSTGRES_USER}
          - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
          - POSTGRES_INITDB_ARGS=--encoding='UTF8' --lc-collate='C' --lc-ctype='C'
        volumes:
          - ./data/postgres/:/var/lib/postgresql/data
        restart: unless-stopped
        networks:
          default:
            ipv4_address: 10.10.10.2

    adminer:
        image: adminer:4.8.1
        container_name: adminer
        hostname: adminer
        ports:
          - 9899:8080
        restart: unless-stopped
        networks:
          default:
            ipv4_address: 10.10.10.3

    elementweb:
        image: vectorim/element-web:latest
        env_file:
          - ./.env
        container_name: elementweb
        hostname: elementweb
        environment:
          VIRTUAL_HOST: ${ELEMENT_HOST}
          VIRTUAL_PORT: ${ELEMENT_PORT}
        ports:
            - 9999:${ELEMENT_PORT}
        volumes:
            - ./data/elementweb/config.json:/app/config.json:rw
        restart: unless-stopped
        networks:
          default:
            ipv4_address: 10.10.10.4

    synapse:
        image: matrixdotorg/synapse:latest
        env_file:
          - ./.env
        container_name: synapse
        hostname: synapse
        environment:
          VIRTUAL_HOST: ${SYNAPSE_HOST}
          VIRTUAL_PORT: ${SYNAPSE_PORT}
          SYNAPSE_SERVER_NAME: ${SYNAPSE_HOST}
          SYNAPSE_REPORT_STATS: "no"
        ports:
            - ${SYNAPSE_PORT}:${SYNAPSE_PORT}
        volumes:
            - ./data/synapse:/data:rw
        depends_on:
            - postgres
        restart: unless-stopped
        networks:
          default:
            ipv4_address: 10.10.10.5

networks:
  default:
    external:
      name: matrix

And here’s the complete .env file:

# General
DOCKER_ENV=production
PROJECT_NAME=matrix

# PostgreSQL
POSTGRES_DB=synapse
POSTGRES_USER=postgres
POSTGRES_PASSWORD=XXX

# Elementweb
ELEMENT_HOST=chat.example.com
ELEMENT_PORT=80

# Synapse
SYNAPSE_HOST=matrix.example.com
SYNAPSE_PORT=8008

Before anything else, we’ll create the required network:

$ docker network create --driver=bridge --subnet=10.10.10.0/24 --gateway=10.10.10.1 matrix

Once everything is set up, run docker compose up -d to start all the services and wait a few minutes for everything to become healthy.

After launching, since our Synapse has registration disabled, we’ll register a user via the console like this:

$ docker exec -it synapse bash
$ register_new_matrix_user -c /data/homeserver.yaml http://localhost:8008
New user locaslopart [root]: theuser
Password: thepass
Confirm password:
Make admin [no]: yes
Sending registration request...
Success

And that’s it! The web interface is now functional, and we can access Elementweb via https://chat.example.com and log in with the credentials created earlier.

The real fun, though, lies in the bridges—those are still to be configured.

Heisenbridge

Heisenbridge, will allow us to communicate with IRC networks directly from the Matrix interface. As always, the first step is to generate its configuration and save it—in this case, in ./data/synapse. We’ll store it here because we also need to share it with Synapse’s volume:

$ docker run --rm \
    -v "./data/synapse:/data" \
    hif1/heisenbridge \
    -c /data/heisenbridge.yaml --generate

This will generate a heisenbridge.yaml file, which we’ll edit to include the URL Synapse will use to connect. Specifically, we’ll need to add the IP address assigned to Heisenbridge in docker-compose.yml. For consistency, we’ll use 10.10.10.6, so:

id: heisenbridge
url: http://10.10.10.6:9898
as_token: ...
hs:token: ...

Next, we need to register heisenbridge as an application service in synapse. To do this, edit synapse’s homeserver.yamland add the following:

app_service_config_files:
  - "/data/heisenbridge.yaml"

Now we’re ready to add another service to our docker-compose.yml. Pay attention to the command field, where we’ll need to specify the Synapse server URL—in this case, http://10.10.10.5:8008—to ensure proper bidirectional communication:

services:
    ...
    heisenbridge:
        image: hif1/heisenbridge:latest
        container_name: heisenbridge
        hostname: heisenbridge
        ports:
            - 9898:9898
        volumes:
            - ./data/synapse/heisenbridge.yaml:/heisenbridge.yaml:rw
        command: ["-c", "/heisenbridge.yaml", "-vvv", "http://10.10.10.5:8008"]
        depends_on:
            - synapse
        restart: unless-stopped
        networks:
          default:
            ipv4_address: 10.10.10.6

After restarting the services (check the logs to ensure everything is running correctly), you should be able to open a private chat with @heisenbridge:chat.example.com and start adding the IRC networks you want:

(heisenbridge) ADDNETWORK Libera.Chat
(heisenbridge) ADDSERVER Libera.Chat irc.libera.chat 6697 --tls
(heisenbridge) OPEN Libera.Chat
(Libera.Chat) CONNECT
(Libera.Chat) NICK mynick
(Libera.Chat) JOIN #my_channel

Other bridges

Other bridges follow a similar process:

Generate the configuration using a docker run command or by downloading an example from the bridge’s documentation. Save it in a shared location accessible to both the bridge and synapse.
Edit the configuration to include the synapse server’s URL or IP address.
Update synapse’s homeserver.yaml to register the new bridge as an application service.
Restart the services.
Open a private chat with the corresponding bot for the bridge (@whateverbot:chat.example.com) and follow its instructions. You can also use the helpcommand for more guidance.

Some bridges have caused issues when they required a dedicated database that wasn’t created automatically. To resolve this, I’ve included an adminer service in docker-compose.yml. You can use it to log in and manually create any necessary databases.

Centralized Messaging via Console

Centralizing everything is great, but the goal is console-based access, right? Being able to manage all your messaging platforms (IRC, Telegram, WhatsApp, Signal, Discord, Slack…) from a terminal is possible using weechat and the weechat-matrix client.

Simply install it in whatever way works best for you, and once launched, connect to your Matrix server like this:

/matrix server add matrix matrix.example.com
/set matrix.server.matrix.username theuser
/set matrix.server.matrix.password thepass
/set matrix.server.matrix.autoconnect on
/matrix connect matrix

Once connected, the magic happens. All your conversations, both public and private, will automatically populate your weechat channel list.

[image not loaded in rss]

–

Bridges like these are more than tools—they’re connections that unify scattered communication into a single, seamless flow. With Matrix as the backbone and tools like heisenbridge, mautrix-* and weechat, the terminal becomes not just a workspace but a gateway to countless networks. The simplicity of white text on a black screen hides the complexity beneath, but that’s the beauty of it: everything, everywhere, just works.

Mastodon vs. Bluesky

info@oscarmlage.com (oscarmlage) — Fri, 15 Nov 2024 13:09:46 +0100

The Eternal Dilemma. The first door that opened when I decided to leave Twitter was Mastodon, and I have a special fondness for it because of that. It also gave me the chance to experience what it’s like to run an instance with actual users. Does it have its problems? Absolutely:

It’s more “complex” to understand.
Migrations are a headache, upgrades too.
Development is slow; they say everything depends on one person’s decisions (although that’s not necessarily a bad thing).

However, Bluesky is where most people have decided to go. Its ATProto is being designed in a very different way, learning from some of ActivityPub’s mistakes, and it’s said to be “better” thought out. Still, there are things that concern me:

Right now, there’s funding because a VC invested, but at some point, they’ll want ROI. Will we become the product?
I’ve read somewhere that crypto is involved, which raises some red flags.
I’ve tried replicating the same setup as Mastodon to have my own independent instance, but as of today, it’s practically impossible. Sure, you can set up your PDS, Relay, and Jetstream… but with AppView, I lost all hope.

Both platforms are still in their infancy, and neither is anywhere near perfect. I feel more at home on Mastodon, but the Bluesky bubble has people I can’t follow anywhere else ¯\_(ツ)_/¯.

I’m still undecided, so I’ll try to stay active on both until something happens that makes me change my mind.

Obsidian Templater, full potential

info@oscarmlage.com (oscarmlage) — Wed, 13 Nov 2024 09:37:59 +0100

I love automating anything that even hints at being repetitive. I don’t mind investing time in it because I know that sooner or later I’ll be grateful I did. Another one of my “sins” (from an excess) is documentation—I’m always thinking about my future self.

In almost every project I’m involved with, I feel the need to keep private notes that, in some way, link to the project’s public documentation. For example, if I’m working on an issue, I tend to write down a step-by-step log of what I’ve done, what I’m currently working on, and what’s next. I also make other notes that might help me solve it (snippets, related code, resources, links, etc.). Obviously, it wouldn’t be appropriate to share all of this information in the public issue (description, comments, etc…).

The solution to this dilemma has usually involved creating a note manually in the project’s issues/ folder, matching the issue number (and title) of the one in the version control system (GitHub, Forgejo, Gitea, etc.). And let’s be honest—it’s a hassle.

So, since I’m managing my notes in Obsidian and already using the Templater plugin for other tasks, I decided to invest time in automating this process.

First, we need to create a template that will serve as the base for all these new notes that will be created in the issues/ directory mentioned earlier. This setup will allow Templater to take control of creating these notes and applying the template logic. Here’s the plan:

Ask me for the title of the issue and, optionally, a brief description.
Run a curl command against the version control server (Forgejo or Gitea in this case) to create an issue with the given title.
Capture the issue number (e.g. 34) from the curl response.
Create a new note with the template’s content (including a reference to the URL of the created issue for convenience).
Rename the note’s title to add the issue number at the beginning (e.g. 34 - Issue Title).

These are basically the steps I used to do manually, so now let’s head to the templates/ directory in Obsidian and create a repo-issue template with the following content:

<%*
    const title = await tp.system.prompt("Issue title");
    const content = await tp.system.prompt("Issue content");
    const token = "your-forgejo-or-gitea-token";
    const url = "https://git.yourdomain.com/api/v1/repos/owner/repo/issues";

    const curlCommand = `curl -s -X POST -H "Content-Type: application/json" -H "Authorization: token ${token}" -d "{\\"title\\": \\"${title}\\", \\"body\\": \\"${content}\\"}" ${url}`;
    const exec = await tp.user.curl({ command: curlCommand });

    const response = JSON.parse(exec);
    const issueNumber = response.number.toString().padStart(3, '0');
    const issueUrl = response.url;

    const titleWithNumber = `${issueNumber} - ${title}`;
    await tp.file.rename(titleWithNumber);
%>

# <% titleWithNumber %>

**Issue URL:** [Issue #<% issueNumber %>](<% issueUrl %>)

<% content %>

## 📄 Log

- [[<% tp.file.creation_date("YYYY-MM-DD") %>]] Issue created

## 📔️ Notes

## 🔗 Resources

## ✅ Tasks

- [ ]

We still need to add the function we’re calling tp.user.curl() to make the request for creating the issue. To do this, we need to create a file, let’s say curl.js, in our scripts/ directory, and tell Templater in the configuration to load that file so that the method is available. The content of our curl.js would look something like this:

const { exec } = require('child_process');

module.exports = async (args) => {
    return new Promise((resolve, reject) => {
        exec(args.command, (error, stdout, stderr) => {
            if (error) {
                console.error(`Error: ${error.message}`);
                reject(error);
            } else if (stderr) {
                console.error(`Stderr: ${stderr}`);
                reject(stderr);
            } else {
                console.log(`Result: ${stdout}`);
                resolve(stdout);
            }
        });
    });
};

Now we have all the ingredients prepared and ready, we just need to cook them (the Templater configuration), and there are two simple steps:

Load the script to make tp.user.curl() available. [image not loaded in rss]
Configure the issues/ directory to run the repo-issue template we created earlier. [image not loaded in rss]

And with that, everything is automated. Every time we create a new note in the issues/ directory, not only will the note with the corresponding template content be created, but an issue will also be created in the version control server, and the note will be renamed with the issue number and link directly in the note.

[image not loaded in rss]

For little details like this, Obsidian and Templater has earned a special place in my heart.

Feeds problems

info@oscarmlage.com (oscarmlage) — Mon, 28 Oct 2024 13:11:14 +0100

The other day a blog reader - I assume - let me know that my feed content was broken. The content syndication was failing because, in every post that loaded an image with the theme’s gallery shortcode, the code appeared instead of the images:

<description>Can you almost smell it?
    if (!jQuery) { alert(&#34;jquery is not loaded&#34;); } $( document ).ready(() = { const gallery = $(&#34;
</description>

I imagine the shortcode I’m using (which is part of a theme) doesn’t take in account the feeds, so I had to spend some time looking for a possible solution. I also realized that my RSS feeds weren’t including the full content of each post, only an “excerpt” version. Big mistake on my part, as I’ve always ranted about that.

Getting down to it, the biggest challenge I faced was finding something that could be executed before the shortcode, as it would be more complicated to fix once the {{ <gallery ...> }} had been replaced. That’s where RawContent came to the rescue. By creating a new home.xml template for the feeds, I was able to edit the description tag to, initially, disable the galleries:

<description>
    {{ .RawContent | replaceRE `<\s*gallery[^>]*>` "`[image not loaded in rss]`" | markdownify | htmlEscape | safeHTML }}
</description>

Finally, I also separated the feeds by category to keep things more organized. So, as of now, the following feeds are available:

Posts: Blog posts.
Microposts or Log: Microposts from the blog (most relevant updates from Mastodon / Bluesky).
Watching: Series and movies I’m tracking.
Reading: Books I’m reading.
Listening: Albums currently playing on my Spotify.
Playing: Video games I’m currently playing.

Thanks @benalb for the heads-up.

—

2024-10-28 Update: Found an issue related to this problem.

Digital Nomad, the concept (2024)

info@oscarmlage.com (oscarmlage) — Fri, 25 Oct 2024 12:16:01 +0200

As the wikipedia says, «The term “digital nomad” started to be used in the early 1990s to describe a new type of high tech traveling lifestyle made possible by the growth of computer networking and popularization of mobile devices like laptops, tablets and PDAs.».

Today, in some classes I’m attending, we started talking about the digital nomad concept, asking if we knew about it and if we could name someone considered a digital nomad. It reminded me of the times I’ve mentioned it in the past.

I’ve been using the term #digitalnomad quite frequently, especially in my Instagram posts where I’d sneak it in whenever there was some tech gear paired with a picturesque background. In fact, I’ve been teased about it quite a few times. I admit, it was a bit of a bait, but I was young and immature.

[image not loaded in rss]

When people hear the term digital nomad, they often think of someone hopping from one exotic location to another, working remotely from beaches, cafés, or coworking spaces in different countries. While that’s a romanticized view of the lifestyle, my take on digital nomadism is a bit different.

For me, being a digital nomad isn’t about traveling constantly or changing locations every few weeks. Instead, it’s about autonomy—being able to carry everything I need to work effectively, regardless of where I am. It’s about the freedom of having my digital home with me at all times, packaged into a compact, highly portable setup. This allows me to work in any situation, whether it’s a crowded airport lounge, a quiet café, or even in the middle of nowhere in the country side.

[image not loaded in rss]

This is where the concept of Everyday Carry (EDC) comes into play. I’ve always been fascinated by the idea of minimizing what you carry to only the essentials, ensuring that you’re always ready to work, but without being weighed down. For a digital nomad, an efficient EDC is what enables that sense of flexibility and freedom. So, what’s part of my EDC for true digital nomadism? Here’s my list of must-haves:

My Essential Digital Nomad EDC:

The backpack
A lightweight, durable backpack is the foundation of any nomad setup. It needs to be compact enough to carry easily but spacious enough to fit all the necessary tools. It’s your mobile office in a bag.
Laptop or iPad with Internet Access
A computer is essential. Whether it’s a laptop or a high-powered tablet like an iPad, it should be capable of handling your work tasks, whether that’s writing code, managing projects, or accessing remote servers. Recently, I’ve been leaning towards the iPad because my laptop is anything but portable, and its battery leaves much to be desired. I’m happy using the iPad in these situations, as long as they’re not long coding sessions.
A data plan for reliable Internet (MiFi or mobile tethering)

Also, I’d like to mention some optional items that, while not strictly necessary, are definitely handy to have nearby just in case, to be fully prepared:

A powerbank Running out of battery is quite common when you’re not “plugged in” all the time. A high-capacity power bank ensures that your devices can stay charged no matter where you are.
A VPN For many of us working in tech or other remote-access jobs, a secure VPN is non-negotiable. It not only keeps your data safe on public networks but also allows you to connect to the necessary remote servers and hosts to get your work done securely.

Adapting to the new essentials

It’s possible that my essentials have changed a bit this year. While I no longer work from cafés as often as I used to (:sadface:), the last four months have forced me to deal with a home renovation situation. The constant back-and-forth has been a great help in reducing my backpack to the bare minimum. So, it’s a funny coincidence that this topic has come up right now.

[image not loaded in rss]

Yep, you’re right dear reader, I’ve talked about this before on the blog, but it’s interesting to see how daily essentials evolve over time :)

Bluesky, hosting a PDS

info@oscarmlage.com (oscarmlage) — Wed, 23 Oct 2024 10:47:37 +0200

As I mentioned in the update of the last post, I decided to give Bluesky a chance as long as I could host my own PDS to maintain the feeling of owning my data.

Setting aside the fact that I wanted to host the PDS within Proxmox and route it through an nginx-proxy-manager, it turned out to be easier than I thought. Initially, it didn’t work because the official stack includes not only the PDS but also Caddy and Watchover, causing conflicts between Caddy and npm (nginx-proxy-manager). I tried several approaches, but I wasn’t able to make it work.

Install

Although I continued using a Proxmox CT, I assigned it a public IP directly so it wouldn’t route through NPM, and everything went smoothly:

$ apt install lsb-release
$ wget https://raw.githubusercontent.com/bluesky-social/pds/main/installer.sh
$ chmod +x installer.sh
$ ./installer.sh
* Detected supported distribution Debian 12
---------------------------------------
     Add DNS Record for Public IP
---------------------------------------
[...]

It’s also important to have a domain associated with that public IP via DNS. Although the instructions tell you to associate a wildcard, this is not necessary. I opted for pds.oscarmlage.com and simply created the corresponding DNS entry for that subdomain with the public IP:

pds.oscarmlage.com              A          51.77.72.104

The installer detects the IP itself, and after installing all the dependencies, it asks for the credentials of an account:

Detected public IP of this server: 51.77.72.104
Create a PDS user account? (y/N): y
Enter an email address (e.g. alice@pds.oscarmlage.com): oscarmlage@pds.oscarmlage.com
Enter a handle (e.g. alice.pds.oscarmlage.com): oscarmlage.pds.oscarmlage.com
Account created successfully!
-----------------------------
Handle   : oscarmlage.pds.oscarmlage.com
DID      : did:plc:XXXX
Password : XXXX
-----------------------------
Save this password, it will not be displayed again.

Everything should now be up and running. We can test it in several ways:

Check health: https://pds.oscarmlage.com/xrpc/_health
Check websocket: wsdump.py "wss://pds.oscarmlage.com/xrpc/com.atproto.sync.subscribeRepos?cursor=0"

We can now create more accounts and/or invitation codes from the console using the pdsadmin command:

# pdsadmin create-invite-code
pds-oscarmlage-com-xxxx-yyyy

Account configuration

With the PDS now up and running, head over to Bluesky’s website to log in (if you already have credentials) or create a new account if you have an invite code:

[image not loaded in rss]

And what if you want to change the domain to something nicer? For example, I’d like my handle to be @oscarmlage.cominstead of @oscarmlage.pds.oscarmlage.com. To do this, once you’re logged in within bsky.app, go to Settings → Change handle → I have my own domain → Enter the new handle @oscarmlage.com, and it will show a TXT record that needs to be added to your DNS for ownership verification. If the validation is successful… voilà! You have your new custom handle!

[image not loaded in rss]

Bridge with Mastodon

Another concern I have is managing duplicate posts. Although I’ll probably keep an eye on both platforms at first, I really don’t want to maintain two social networks, so the best option —for me— is to set up a bridge with Mastodon to automatically post the same content.

I’ve activated the bridge from Mastodon to Bluesky. To do this, I followed the bot @bsky.brid.gy@bsky.brid.gy from Mastodon. Once you start following it —from Mastodon— it automatically creates a Bluesky account under its domain with your Mastodon information, which becomes your bridge account (the bot will share the details in a PM with you). In my case, it’s @oscarmlage.mastodon.bofhers.es.ap.brid.gy. And that’s it! Every time you post something on Mastodon, it will automatically be published to that Bluesky account.

[image not loaded in rss]

In the end, I’ve created two Bluesky accounts: one as my “main” account and another as the bridge with Mastodon. Feel free to follow me on either of them:

Final thoughts

In the last post, I shared a story about a bird and a butterfly, with the elephant reminding us of the importance of staying grounded. But, as I reflect on it now, perhaps the butterflies, too, have something wonderful to offer. So, let’s give Bluesky a chance to soar, without forgetting the solid ground that Mastodon has provided. After all, there’s room for both beauty and stability in the skies we navigate.

Mastodon, bluesky and the blue bird

info@oscarmlage.com (oscarmlage) — Tue, 22 Oct 2024 12:34:29 +0200

Lately, I’ve been seeing a lot of —annoying— noise about the little blue bird (which is no longer a bird, nor blue), the blue butterfly (Bluesky, I guess), and the Mastodon.

Sure, every now and then, I open my Twitter account in a tab and take a quick look. I sometimes get that feeling of missing certain profiles that are still active over there, writing and feeding the X. But then, with the ads, the algorithm, and all that visual noise cluttering the timeline, the feeling goes away.

Yesterday, I was tempted to create a Bluesky account. In fact, I ended up making one because reasons, but I have so many doubts that I don’t see myself going back to it. From what I’ve read, the project started as an idea by Twitter (ouch1) to create a public conversation protocol (AT Protocol, nothing to do with ActivityPub, ouch2), Open Source, and with the possibility to build both the server and the app, but the instructions are not so clear (ouch3). Tsk…

«A bird and a butterfly were arguing about who could fly higher and who had the best view of the sky. The bird insisted its flight was fast and precise, while the butterfly bragged about its beauty and grace as it glided through the clouds. Suddenly, an elephant appeared, walking calmly on the ground, and said: “Keep arguing up there, while I already have my feet firmly planted on what really matters."»

I don’t know, maybe it’s just that I’m getting older, or maybe I’ve already mastered using and managing a Mastodon instance —which, by the way, still has plenty of room for optimization and resource improvements— or maybe it’s that I’ve already built my bubble and I just don’t feel like starting over. But for now, I’d rather keep my feet on the ground.

—

2024-10-23 Update — After a chat with @juanlu and reading here and there about ATProto, I’ve decided to host my own PDS and give it a try. My initial strictly technical impressions are overwhelming—1GB of RAM and 20GB of disk space are more than enough to get it running. However, it’s tricky to make it work within a Proxmox environment while routing through nginx-proxy-manager. I’d recommend running it with its own dedicated IP.

Automating the media (hugo-medialog.go)

info@oscarmlage.com (oscarmlage) — Tue, 15 Oct 2024 17:18:37 +0200

As someone who consumes and tracks a some media items (books, series, movies, videogames, music…), I’ve always looked for ways to keep an updated record without adding too much friction to my workflow. After several iterations, I’ve created a Go script that automates this process using tools I already use daily: Obsidian and Hugo.

I’ll try to explain how this system works and how you can use it to keep track of any type of content with minimal effort.

The workflow

Obsidian is my go-to note-taking tool, where I have a YAML file for each type of content (e.g., books.yml.md, series.yml.md, etc.). In these files, I record titles, progress, ratings, and more.
Hugo is my static site generator, where I publish this tracking as part of my blog. Each time I read a book or watch a movie, my goal is to generate a markdown file in Hugo automatically from the YAML file in Obsidian.
The Script in Go takes care of this transition, moving data from Obsidian to Hugo automatically. It reads the YAML files from Obsidian and generates corresponding markdown files in Hugo. Also it uses some APIs to get more information about the item (number of episodes/pages, release date, images, author/company…)

The script in action

The script is designed to process different types of content (books, series, movies, etc.). Using a --media flag, you can specify which type of content you want to process. Additionally, I’ve added an optional --update flag that updates the frontmatter (structured data in the markdown file) without overwriting any personal content you may have added to the markdown, like notes or reviews. Example usage: go run main.go --media books --update

This will process books and only update the metadata, leaving your personal content in Hugo untouched.

Project structure

Here’s a simplified view of how the project is organized:

medialog-project/
├── internal/
│   ├── books/
│   │   └── model.go
│   │   └── controller.go
│   │   └── api_googlebooks.go
│   ├── games/
│   │   └── model.go
│   │   └── controller.go
│   │   └── api_igdb.go
│   ├── movies/
│   │   └── model.go
│   │   └── controller.go
│   │   └── api_trakt.go
│   ├── music/
│   │   └── model.go
│   │   └── controller.go
│   │   └── api_spotify.go
├── templates/
│   └── books.md.tpl
│   └── games.md.tpl
│   └── movies.md.tpl
│   └── music.md.tpl
├── utils/
│   └── config.go
│   └── markdown.go
│   └── utils.go
├── .env
├── main.go

How does it work for books?

Let’s look at a concrete example. In the books.yml.md file in Obsidian, I have a simple record like this:

- title: "Terraform: Up and Running"
  author: "Yevgeniy Brikman"
  year: 2017
  progress: 25%
  rate: 7.2
  date: 2024-10-15

The script reads this data and searches for the corresponding markdown file in Hugo. If it doesn’t exist, it creates it calling some APIs and using a template; if it does, it can update only the metadata without touching the content, so any personal notes remain intact.

Here’s a breakdown of how we handle books:

Model

The Book model represents the data structure for books. This model is responsible for parsing the YAML file from Obsidian and storing the information that will be used to generate the final markdown in Hugo.

Here’s an example of how the Book model might look in Go:

type Book struct {
    Title    string  `yaml:"title"`
    Author   string  `yaml:"author"`
    Year     int     `yaml:"year"`
    Progress string  `yaml:"progress"`
    Rate     float64 `yaml:"rate"`
    Date     string  `yaml:"date"`
}

This structure matches the fields in the YAML file in Obsidian and allows us to easily read and write the data into markdown format.

Controller

The controller is responsible for handling the logic of reading the YAML file, updating or generating the corresponding markdown, and applying the correct template. The logic flow is as follows:

Load YAML data: The controller loads the book data from the YAML file (books.yml.md) into the Book model.
Check for existing markdown: It checks if a markdown file for the book already exists in Hugo. If it does, it updates only the frontmatter fields (like progress, rate, etc.), leaving the content untouched. If it does not exist the controller calls the proper APIs to get the information.
Generate or update markdown: If no markdown exists, it generates a new markdown file using a predefined template. Otherwise, it updates the existing frontmatter while preserving user content.

Here’s a simplified view of how this process looks in code:

func ProcessBooks() {
    books := LoadBooksFromYAML()
    
    for _, book := range books {
        mdFile := fmt.Sprintf("%s/%s.md", MARKDOWN_OUTPUT_BOOKS_DIR, book.Slug)
        
        if fileExists(mdFile) {
            // Update only the frontmatter
            UpdateBookFrontmatter(mdFile, book)
        } else {
            // Get proper data from APIs
            SearchBookByTitle(book.Title, &book)
    		getBookImagesByTitle(book.Title, &book)
            // Generate a new markdown file using the template
            GenerateMarkdownFile(mdFile, book, "book_template.md")
            continue
        }
    }
}

Template

The templates are stored in Hugo’s content folder, and they define how the final markdown looks. Here’s an example of a simple template for books (book_template.md):

---
title: "{{ .Title }}"
author: "{{ .Author }}"
year: {{ .Year }}
progress: {{ .Progress }}
rate: {{ .Rate }}
date: {{ .Date }}
---

# {{ .Title }}

## Overview


## My thoughts

This template uses Go’s text/template syntax to dynamically insert book data into the frontmatter and content sections of the markdown. For example, the generated or updated markdown file in Hugo might look like this:

---
title: "Terraform: Up and Running"
author: "Yevgeniy Brikman"
year: 2017
progress: 25%
rate: 7.2
date: 2024-10-15
---

# Terraform: Up and Running

## Overview
<no value>

## My thoughts
This is where you can add your personal thoughts about the book.

In the end

This system lets me keep my medialog updated with minimal friction, as I only need to update the YAML files in Obsidian, which is already part of my daily note-taking routine.

From there, the entire process of generating content in my blog is automated. Additionally, by using the --update flag, I can ensure that any personal content added in Hugo remains untouched.

Keeping track of what we consume doesn’t have to be a tedious or manual process. With the right tools and automation, you can make it as seamless as possible. If you’re interested in implementing something similar, you can check the script repository, where you can see the full code and adapt/edit it to fit your needs.

Small tweaks in the blog

info@oscarmlage.com (oscarmlage) — Fri, 20 Sep 2024 20:45:09 +0200

I’ve finally managed to make a few small changes to this site that I’ve been wanting for a while. There were certain small details that didn’t quite convince me, and with each passing day, I felt a growing need to try and adjust them. These are minor adjustments, but they make the site feel more enjoyable to me.

I’ve removed my image/avatar from the homepage since I was never fully convinced by it.
The main menu has been switched from text to icons.
Font sizes have been adjusted to improve readability.
Margins and spacings have been refined to better fit the new changes.
The footer has been minimized, now using icons instead of text.
All content has been aligned to the center across all possible screen resolutions.

These aren’t big updates, but I really like the theme’s foundation, so I just made a few subtle tweaks to make it feel a little more personal.

Looking ahead, I’m excited to continue experimenting with design and functionality, always aiming for a cleaner interface.

Gallery

[image not loaded in rss]

Hola Hugo

The Medialog

info@oscarmlage.com (oscarmlage) — Tue, 27 Aug 2024 21:00:52 +0200

Lately, I’ve been diving - a bit more - into Hugo templates and archetypes, and I decided to create a medialog to track all the media I’m currently consuming: movies, series, books, games, music… This space helps me keep everything organized, and I’m hoping it won’t be forgotten—like some other parts of this site have been!

Creating the Medialog Layout

I created a new layout called medialog.html to define how I want my media log to be displayed. This layout includes sections for each type of media I’m tracking. To display the content, I used Hugo’s range function, iterating over my taxonomies to showcase what I’ve been watching, reading, and more.

Here’s a snippet of how the layout looks:

<main class="main wrapper">
    <h1>Medialog</h1>

    {{ if .Site.Taxonomies.tags.watching }}
    <h2>Watching</h2>
    <div class="media-grid horizontal">
        {{ range (.Site.Taxonomies.tags.watching).Pages }}
            {{ partial "medialog/watching.html" . }}
        {{ end }}
    </div>
    {{ end }}

    {{ if .Site.Taxonomies.tags.reading }}
    <h2>Reading</h2>
    <div class="media-grid vertical">
        {{ range (.Site.Taxonomies.tags.reading).Pages }}
            {{ partial "medialog/reading.html" . }}
        {{ end }}
    </div>
    {{ end }}

</main>

Adding Content with Partials

I used Hugo’s partials to keep things modular and reusable. Here’s an example of a partial that renders a media item with its rating:

<a href="{{ .Params.Link }}" title="{{ .Title }}">
  <div class="item-wrapper">
    <div class="meta-text">
        <div class="gridheader">{{ .Title }}</div>
        <div class="subheader">
          {{ $rate := .Params.Rate }}
          {{ range $i, $e := (slice 0 1 2 3 4) }}{{ if lt $i $rate }}⭐{{ end }}{{ end }}
        </div>
      </div>
      <img src="listening/_assets/{{ .Params.Image }}"
        alt="{{ .Title }}" loading="lazy" decoding="async" />
    </div>
</a>

Content structure

Each content entry in the medialog follows a simple structure. For example, a movie entry might look like this:

---
title: "Movie title"
link: https://www.imdb.com/title/ttXXX/
subtitle: 2018
year: 2018
rate: 3
image: movie-image.png
date: 2024-07-11T10:44:54Z
draft: false
tags: watching
---

Handling Layout Issues

I ran into an issue where Hugo was rendering my medialog content using default/list.html instead of my custom layout. The solution was to properly configure taxonomies in config.yaml and ensure the layout was correctly referenced in the frontmatter. I also had to move layouts/medialog.html to layouts/medialog/list.html to get everything working properly.

Conclusion

Building this medialog has been a fun and rewarding experience. It’s a simple yet effective way to track my media consumption, and I’m excited to keep it updated (hopefully this time, it won’t fall by the wayside!). If you’re interested in doing something similar, I encourage you to dive into Hugo and explore its powerful template features.

Holidays, a digital challenge

info@oscarmlage.com (oscarmlage) — Fri, 16 Aug 2024 23:13:38 +0200

Everyone I know enjoys taking vacations, having free time, spending time with family, and doing different things that the daily grind might not allow for, etc.

As much as I love disconnecting during this leisure time, due to the nature of my work, I always need to have a data plan and some gadget on hand that allows me to remotely connect to servers, if only to be able to restart a service that’s acting up.

For several seasons now, the iPad has become my travel companion for these tasks, and this year has been no different.

However, I had another, more fun challenge in mind. Between swimming and lounging, I take the opportunity to read, and my mind shifts into creative mode. More than once, I’ve thought about writing a few lines for this blog. But since it’s a static content manager that I can’t install or build on the iPad, things get a bit more complicated.

So, the reason for writing these lines is to test whether I could accomplish this fun challenge—even with a photo! Challenge unlocked.

Enjoy your leisure time.

A movie for a change

info@oscarmlage.com (oscarmlage) — Mon, 29 Jul 2024 13:35:48 +0200

Yesterday, we were so bored scrolling to find a series to start, in a total lazy mood, that we ended up choosing a movie. It’s been so long since the last time I can’t even remember.

We usually watch series because the episodes are shorter, though it’s a bit of a trap because we end up watching more than one, but mentally it feels like less of a commitment. We’ve split the movie into 2 parts, and today we’re finishing it.

Maybe it’ll become a regular thing. If it does, perhaps it’s a good idea to keep track of that kind of thing.

Struggle and Motivation

info@oscarmlage.com (oscarmlage) — Thu, 11 Jul 2024 12:05:23 +0200

I was browsing the Mastodon timeline and came across this interesting article by Rach Smith discussing a key factor in becoming a developer. I mostly agree with her perspective. It’s hard to replicate the career of any individual, but, aside from external factors, the struggle with various problems you encounter is a crucial aspect. You need to enjoy it.

In addition to that, I believe another key factor is motivation. It’s great if you enjoy the job and have the right motivation. However, even if you enjoy the work and the challenges, without motivation, the journey can become hard and tough.

I really enjoy tackling daily problems and finding suitable solutions. I love opening my computer every day to improve something. I’m constantly looking for new ideas, even when I’m not in front of the screen (while showering, walking, etc.).

But currently, I’m at a point where I open my computer and it’s like a blank screen; I’m not enjoying it anymore. The projects I’m working on are either stalled or halted, and my motivation is nearly /dev/null.

Motivation can significantly impact your performance at work. It drives you to tackle challenges, pursue new solutions, and continuously improve. When you’re motivated, you’re more likely to be proactive, creative, and productive, which can lead to greater job satisfaction and career growth.

Motivation is different for everyone; it’s essential to find your own. Whether it’s the type of work, your colleagues, the daily routine, the financial rewards, or the tasks you enjoy the most, identify what drives you. But whatever it is, make sure you find it.

That’s why I believe one of the key factors in this career (and probably many others) is motivation.

Stay hydrated, stay motivated.

Madrid, spring 2024

info@oscarmlage.com (oscarmlage) — Wed, 08 May 2024 20:50:23 +0200

If memory serves me right, this is the first family trip we’ve taken since last summer. It’s been a somewhat unusual winter, but in the end, we managed to break away from routine and enjoy a weekend in the capital with the excuse of seeing a musical we’ve been wanting to watch for a while.

Every time I visit a big city, I feel like a little kid again, marveling at the buildings, and this time was no different.

[image not loaded in rss]

Good Bye Vila Penguin

info@oscarmlage.com (oscarmlage) — Thu, 25 Apr 2024 19:39:16 +0200

Last photo of the family in front of the mirror in one of the rooms, saying definitely goodbye to 15 years of adventures. Vila Penguin was the nickname of our apartment (in tribute to Dr. Slump). It’s gone, filled with memories and a whole life packed in boxes.

Let’s go for the next level, thinking of a new nickname ;).

Microposting... obs2hugo.go

info@oscarmlage.com (oscarmlage) — Wed, 10 Apr 2024 19:39:16 +0200

The other day, I raised through Mastodon what I call «the problem of microposting» and tried to find a solution that could cover my use case minimally.

Microposting is a brief and agile way of publishing “stuff” easily and with minimal friction. Platforms like Tumblr, Twitter, or recently Mastodon have made microposting a reality that moves more dynamic and updated content than other types of publications.

When it comes to reducing friction in content generation, we have to say that the clients of these platforms are very usable and make it very easy to create a text accompanied by several photos to document any kind of situation. Even if it’s temporary content, it’s very easy and quick to generate.

Since I left Twitter (deleting all the history of the account) and joined Mastodon, I consider the content on these platforms as ephemeral. Almost everything published will lack meaning in the future without proper context, or perhaps only as a historical record to remember or relive certain feelings. (Please note that I haven’t programmed expiration on publications yet, but I’m sure I’ll end up doing it).

But there are some publications that, either for sentimental or for other reasons that are not relevant, I would like to keep in [someplace]. And that’s where the questions begin. How can I save that history? Could I “export” it to another site to keep those publications without depending on what happens to the instance or to the third-party company owning the social network? Hasn’t anyone thought of this before?

Considering that, in my case, we’re talking about exporting certain publications from Mastodon to, for example, my blog; my first approach was to create a tag (#micropost) that could have an associated feed (thanks to Mastodon) and make use of a small script to read that feed to export one by one all the entries and convert them into easily importable markdown content on this blog (Hugo). And thus, the Social section was born:

https://oscarmlage.com/microposts/

Over time, I’ve seen that the flow isn’t right, although the creation is very simple and within reach of any device (I literally carry the Mastodon client in my pocket), I have to manually run the feed reading script on a computer and also build and deploy the website for the new content to appear. All the friction that is reduced in content creation reappears in its publication.

I think it can be improved by changing the tools. And that’s what I did. I’ve created another small (well… not so much) script that I can leave running on any computer that has access to the input and the output (we’ll talk about it now). The script takes care of reading changes on disk in certain directories and acting accordingly. The input is now Obsidian, which also has a fantastic client, I also carry it in my pocket, and it also allows me to create content without any friction and even with more composition options than Mastodon. The output is Hugo and the flow is as follows:

I open the Obsidian client and create a new note in the folder assigned to microposts.
I write the content, attaching photos, videos, or any other type of content that the Obsidian client allows me. As I’m creating, the content is already synchronizing with the other Obsidian instance I have on my PC.
The script that is watching the disk alerts changes, translates them into markdown, and moves them to the microposts directory of Hugo. Also, it builds & deploys in background.

Automatically and without the need to do anything else than generate the content, we have already published it \o/.

I think I’ve managed to reduce friction both in creation and publication to a minimum, and always using my favorite content manager and my favorite documentation tool. Goal achieved. By the way, I’ve called the script obs2hugo, and you can access the source code here:

oscarmlage/obs2hugo

Please note that the script is constantly being updated, as new ideas come to me as I use it. For example, I’ve just added support for the watcher to observe several different directories and act accordingly, so I can not only manage the microposts but also manage the posts like this one you’re reading, written entirely following this new flow.

Besides having had a couple of super entertaining days with this new toy, I must admit that I’m enjoying it like a kid. I love it.

Turning Ipad Into a Remote Development Tool

info@oscarmlage.com (oscarmlage) — Tue, 20 Feb 2024 21:14:08 +0000

I’ve talked before about how much I love the form factor, versatility, portability, and battery life of the iPad. It’s by far the gadget I enjoy the most.

Even for development, even when working remotely, it’s ideal as long as you don’t rely too much on developer tools. For backend development, it fits like a glove.

Obviously, you need access to another machine with the development environments, but as long as you don’t stray too far from the terminal (mosh, tmux, vim…), you won’t need anything more than a stable internet connection.

I’ve previously mentioned how you can use a socks server via SSH in Blink to resolve requests on the destination host, so if we SSH into the development machine where we have http://localproject.lc, the iPad can access that address.

However, although configurable in Blink, it’s a somewhat tedious option as it requires a proxy.pac and custom configuration.

I wanted to mention another solution that involves using Tailscale and its SplitDNS feature. As long as you can run the Tailscale client on both machines, the one with the development environments and the iPad, you can easily access all those “local” domains. Let’s recap what we need:

Development host with Tailscale client, SSHd, and a DNS server (such as dnsmasq).
iPad with Tailscale client.

iPad

All we have to do on the iPad is install the Tailscale client, log in with our account, and wait to have the rest configured.

Development Host

On this host, in addition to SSH, we have the Tailscale client installed, which will give us a public IP via the Tailscale network. Additionally, we need to install and configure a DNS server (I emphasize dnsmasq for its ease of installation and configuration) to resolve the .lc domains to its Tailscale node public IP. For example, if the public IP of this node in Tailscale is 111.112.113.114, we configure dnsmasq as follows:

address=/.localproject.lc/111.112.113.114
address=/.localproject2.lc/111.112.113.114
[...]

In addition to having the development projects running, that would be all we have to do on the development host.

Tailscale

The last step would be to configure Tailscale. Within its Admin console, we should already see the nodes where we have the client installed; in our case described above, the development host and the iPad would appear.

Now we need to focus on the DNS option and within it on the Nameservers. There we can add new nameservers (Add nameserver) of type Custom:

And we would be all set to return to the iPad, log out and log back into the Tailscale client, and be able to access through the browser:

Conclusion

With the Tailscale solution and SplitDNS feature, turning your iPad into a remote development environment becomes remarkably straightforward. By leveraging Tailscale’s seamless networking capabilities and SplitDNS functionality, you can access your development environments securely and efficiently, without the need for complex configurations or resorting to workarounds like jailbreaking.

Whether you’re a developer on the go or simply prefer the convenience of using your iPad for development tasks, Tailscale provides a reliable solution that empowers you to code from anywhere, effortlessly bridging the gap between your iPad and your development environment.

Embracing the ordinary

info@oscarmlage.com (oscarmlage) — Wed, 07 Feb 2024 21:40:18 +0000

As I sit down to write this post in 2024, I can’t help but acknowledge the fact that my blog has remained silent for far too long. It’s not for lack of things happening, but maybe because the everyday hustle and bustle have swallowed up my creative energy (or whatever is being called nowadays).

It’s simple to miss the little joys in our daily routines. Even without big events, I’m still determined to find that each day presents opportunities to appreciate the simple pleasures and to recognize that our mere existence is a gift worthy of celebration.

In the end, stepping back from blogging reminds us of life’s ups and downs. It’s often the ordinary moments that stick with us the longest, and it’s in these times when we discover the beauty of existence. So, let’s embrace the everyday and treasure the little triumphs that give life its meaning.

At the end, this game is all about cycles of streaks… they say!.

Vim: embedded git diff

info@oscarmlage.com (oscarmlage) — Wed, 11 Oct 2023 10:30:17 +0000

Sometimes, all you want is a simple and rapid method to review all the changes made across different branches, in a format you can easily edit. This is particularly useful for quickly assessing which tests need to be added when working on a new branch.

My initial thoughts led me to consider various plugins, like fugitive or lazygit, as well as manual approaches such as copying git diff output into the buffer. But I had a hunch that there had to be a quicker way, and I was right:

:r!git diff master..my-branch --no-color
:set syntax=git

The solution lies in vim’s powerful :r command. This feature allows you to import the output of an external command directly into your vim buffer. Breaking it down, git diff generates a comparison between the master and my-branch with the --no-color flag to remove any color formatting. Then vim imports this output into the buffer.

To enhance the readability, we apply git syntax highlighting to the inserted text using :set syntax=git. This combination of vim commands offers a fast and efficient solution for evaluating changes, navigating code, and identifying the tests that need to be incorporated.

I love vim.

Boost computer CPU using a fridge

info@oscarmlage.com (oscarmlage) — Wed, 23 Aug 2023 19:26:01 +0000

I believe some experiences are too unique not to be shared, and today’s one with my computer due to the scorching heat in my city is definitely one of them. Brace yourselves for a quirky yet somewhat educational story: Using your freezer to give your laptop a 60% power boost. Frozen Apple makes your laptop roar… catchy clickbait, isn’t it?

Today was a true summer day, with temperatures soaring around 40°C outside and ranging from 30°C to 33°C in the room housing my computers. In these conditions, it seemed like my Macbook wanted a day off, as even with minimal CPU load, everything was crawling at a snail’s pace.

None of the monitoring tools - top, htop, System Monitor - could provide a logical explanation for what was happening. The load average was hovering between 25 and 30 (!!), yet no single process seemed to be the culprit.

The CPU/GPU temperatures were stable around 60°C, and the fans were running at full throttle. At these temperatures, there shouldn’t be much cause for concern but the whole system was behaving like the slowest turtle in the world. Everything pointed towards potential CPU throttling due to excessive heat.

Indeed, once I was convinced that temperature-related throttling might be the issue, there was only one quirky and amusing way to confirm it quickly: placing my laptop in the freezer. Without hesitation, I rearranged my freezer’s contents like a master of Tetris to make room for the laptop in order to achieve a frozen apple (ba dum tss!).

Just a couple of minutes in the icy environment were enough to lower the temperature and witness the return of normal performance:

Upon returning to its natural habitat, the laptop gradually warmed up, hitting 55°C, at which point the fans kicked in at full blast again. However, the temperature continued to rise, stabilizing around 60°C with the fans working at maximum capacity and throttling once again at 30%. I’d like to think that being unable to drop below 55°C, it settled into this state and everything is slow again.

So, there you have it, folks! Nothing like a trusty freezer to unleash the full potential of your Apple device delivering a seamless performance!.

Note: No Apple products were harmed in the making of this post. While #BOFHers endorses and stands by this technique, the author does not take responsibility for the misuse of the freezer with third-party devices.

[image not loaded in rss]

iPad as Dev Machine

info@oscarmlage.com (oscarmlage) — Sun, 16 Apr 2023 11:27:17 +0000

Have you ever considered using an iPad for coding? While an iPad may not be the most obvious choice for developers, it can serve as a valuable complement to your main development setup, thanks to its long battery life, portability, and superb keyboard. As a developer, I’ve found myself drawn to the idea of using an iPad for light development tasks, despite its limitations. In this blog post, I’ll share my experience of developing on an iPad, including the tools and apps I use, the pros and cons I’ve encountered, and my overall reflections on this unconventional approach to coding. Join me as I explore the possibilities and challenges of using an iPad as a coding tool.

When it comes to coding on an iPad, having the right tools and apps can make all the difference. Here are some ideas and the apps that have helped me overcome the limitations of iPadOS and enable a productive coding experience:

VPN: When coding on the go or away from home, a VPN is essential for accessing all your resources securely. I rely on the OpenVPN app for iPad to connect to my personal VPN server, but other options like Tailscale, ExpressVPN, CyberGhostVPN, Private Internet Access VPN are also available.
SSH: Since my tooling is primarily remote, all I need is a reliable terminal that supports SSH connections. Blink has been my go-to choice, offering seamless SSH connectivity on the iPad. iSH and Termius are also worth checking out.
DNS: If you, like me, rely on Docker for your development environment and need to resolve local domains, iPadOS lacks a direct way to modify the /etc/hosts file. However, you can hack it using a socks server and SSH with -D option to resolve requests on the destination host. This workaround has allowed me to resolve local domains, such as https://localproject.lc, for my Docker projects.
Editor and other tools: My coding setup includes essential tools like tmux, neovim, bash, curl, siege, lazygit, Docker, mutt and more. While these tools may require some setup and configuration in the remote host you’re using, they provide a powerful coding environment over SSH.
Mosh (optional): Last but not least, for enhanced stability and speed, Mosh (Mobile Shell) has become a must-have for my server connections. Blink also supports Mosh connections, making it a convenient option for a more reliable and faster remote coding experience.

With the right tools and apps, an iPad can be a capable companion for coding on the go, despite its limitations. Let’s dive into the pros and cons of developing on an iPad and explore the unique possibilities it offers.

When it comes to using an iPad for development, there are several advantages that make it a compelling choice for many developers. From impressive battery life to unparalleled portability, the iPad offers a unique experience that can enhance your coding workflow. Additionally, the touch screen functionality adds a new dimension to the development process, providing new possibilities for interaction. In this section, I’ll highlight some of the main pros of using an iPad for development, based on my own experiences and observations.

Battery Life: Despite not being designed for heavy development work, the iPad’s battery life is impressive. With around 8 hours of development work on a single charge, it’s more than enough for most coding sessions. (Please note that my dev sessions on the iPad are typically not more than a couple of hours).
Portability: The iPad’s portability is a standout feature, especially when compared to larger laptops like the 16-inch MacBook Pro. It’s easy to carry around and set up in different work environments, making it a convenient option for developers on the go.
User Experience: There’s something about the experience of opening an iPad and starting to work on it that’s different from a regular laptop. It’s hard to put into words, but it feels less cumbersome and more efficient, with a lack of laziness in getting started.
Touch Screen: The iPad’s touch screen adds a new dimension to the development process. While not a primary input method, I’ve found myself trying to imitate some of those gestures on my MacBook, which seems like a sign that I miss those. The occasional use of gestures for scrolling or other basic tasks can be helpful and may even influence your interactions with other devices.

However, like any device, the iPad also has its limitations when it comes to development. While it offers unique advantages, there are some challenges and trade-offs that developers may encounter. In this section, I’ll highlight some of the main cons of using an iPad for development, based on my own experiences and observations.

Limited toolset: One of the challenges of using an iPad for development is that you may not have access to all the tools and software you’re used to on a traditional laptop or desktop.
Browser limitations: The iPad’s browser may have some limitations compared to desktop browsers. For example, certain advanced features or developer tools may be unavailable or restricted in functionality. This can impact your ability to thoroughly test and debug web applications, and may require you to work around these limitations or find alternative solutions.
Adaptation to remote toolset: If you’re using an iPad for development like me, you’ll be working with remote tools and servers, which can require you to adapt to a different workflow. For example, using SSH or remote terminals to access your development environment, which can have a learning curve if you’re not already familiar with these tools. This can impact your productivity and may require additional time and effort to get accustomed to the remote toolset.
Changes in shortcuts and workflows: The iPad’s touch-based interface and different keyboard layout compared to a traditional laptop or desktop may require you to learn new shortcuts and workflows. This can impact your muscle memory and productivity, as you may need to re-learn or adapt your familiar shortcuts and workflows to the iPad’s touch-based interactions.

In conclusion, while the iPad has its limitations and may not be the ideal choice as a dedicated development machine, it can still be a valuable tool for certain scenarios and use cases.

Would I buy an iPad exclusively for development? No, based on my experience, I would opt for a more portable development machine and consider something more compact than the 16-inch MacBook Pro I own. However, if I already had an iPad, I would definitely try to equip it with the appropriate tools for development. Not for long coding sessions, but for those idle moments when I’m waiting for my kids after school, or when I’m running errands with my partner and inspiration strikes off-screen, or to break the monotony of working from home and heading to a coffee shop to finish that feature… for all those occasions, the iPad is a great option.

[image not loaded in rss]

Remote Debug in Go (nvim + delve + docker)

info@oscarmlage.com (oscarmlage) — Fri, 03 Feb 2023 19:04:27 +0000

I don’t know where to start this whole story from. As a preface, I must acknowledge that my primary experience years ago has been in Python development, utilizing tools such as pip for package management, a framework for organization, and virtualenv for environment management. Lately, I’ve added Docker to the mix as well.

Recently, a new career opportunity presented itself and I was given the opportunity to choose the tools for the job. Given the requirement for speed and high concurrency, I saw it as a perfect fit for a go-lang application. I embarked on extensive research and testing to determine the best tools to support my development workflow.

After careful consideration, testing, and analysis of various projects and codebases, I have reached a understanding of the flexibility that go language offers in terms of project organization. I faced the challenge of breaking away from my prior OOP experience and adapting to the lack of strict guidelines in go, which was both enjoyable and difficult. Through studies and observations, I have developed the ability to structure the skel to best suit the requirements of the project.

Given that my unwavering red line from the start was to work with Docker, it has been a very enjoyable challenge to make the entire stack dependent on containers. However there was a last step in the stack that was holding out: the debugging tools.

Previously I was familiar with using pdb for debugging, so my needs were relatively straightforward. I was seeking a tool to set breakpoints, inspect variables, and halt/resume execution. Initially, I considered gdb as an option, but after reviewing the documentation, I discovered that the developers recommend delve as a superior alternative. Based on this recommendation, I decided to proceed with using delve.

To use delve with a Go application in a container, you need to run delve in the container, which allows you to control the execution of your binary by listening to remote procedure call (RPC) connections. This way, you can perform actions like stopping the execution, observing variables, and stepping through the code line by line…

The binary must be executed using dlv (delve).
A communication channel needs to be established for server-client interaction.
We need a client that connects to the server and sends commands.
Ideally, we would like to have an interface within our editor to manage the process.
And don’t forget that all the developments is dockerized.

Delve, Air and Docker

The Docker setup includes two services, one for the main application and another for testing. The app and tests services in the Docker setup are distinct, with differing environment variables and thus separate databases. The entrypoints for each service are separate, with the app service running the main application and the tests service running the tests (obviously). To handle code changes, tools like fresh and air were utilized, the entrypoint is configured to run air with a specific set of parameters (.air.toml):

root = "."
cmd = "go build -o ./tmp/main main.go"
bin = "tmp/main"
include_ext = ["go", "tpl", "tmpl", "html"]

The current directory (.) is mounted as a volume in the Docker container, and air is configured to monitor changes to specific file extensions, triggering a rebuild and serving the updated code. For dlv debugging, the binary must be run under delve, which requires installing dlv in the container. The way the binary is executed may need to be adjusted accordingly (modified .air.toml):

root = "."
cmd = "go build -gcflags=all=\"-N -l\" -o ./tmp/main main.go"
bin = "tmp/main"
full_bin = "dlv exec --accept-multiclient --log --headless --continue --listen="0.0.0.0:40000" --api-version=2 ./tmp/main"
include_ext = ["go", "tpl", "tmpl", "html"]

It’s important for this approach to work to remember to include the installation of air and dlv in your container’s Dockerfile:

FROM golang:1.19-alpine

WORKDIR /code

RUN apk add build-base gcc-go musl-dev && \
    go install github.com/cosmtrek/air && \
    go install github.com/go-delve/delve/cmd/dlv@latest
[...]

It appears to have potential, however, there is a new network port that we need to factor in, so we need to change our docker-compose either and open both ports, appart from other options as SYS_PTRACE and seccomp/apparmor:unconfined:

services:
  app:
    build: .
    cap_add:
        - SYS_PTRACE
    security_opt:
        - seccomp:unconfined
        - apparmor:unconfined
    [...]
    command: ["air"]
    ports:
        - 1234:1234
        - 40000:40000
    volumes:
        - ./:/code
    [...]

Once the container has been rebuilt, we can verify that the changes are working as expected just trying to connect with dlv (client) from the host to the dlv (server) container. Of course you need to install dlv in the host too:

$ dlv connect 0.0.0.0:40000
Type 'help' for list of commands.
(dlv)

We can now add breakpoints and continue debugging from the command line interface, which is similar to using pdb in the Python world. However, it may be worth exploring further options.

Neovim

What do you think about having a visually appealing and straightforward debugging interface in an editor like neovim?. Will try!. I’ve considered two ways: dap + dap-go or vim-go on the other hand. I’ve tried both but only got something usable with vim-go, I think the dap thing is the future but it still has a lot of room for the improvement, because there are some stuff that is not fully supported.

First of all we need to install vim-go, it depends on your package manager, in my case all I had to do was to add Plug 'fatih/vim-go' to my configuration file. Once the plugin is installed there is another little trick we should handle, the substitute paths. Most likely your working directories will not match between your development environment and the container, so we’ll have to tell vim-go to rewrite those paths so that, for example, if you want to set a breakpoint in the file /home/oscar/code/sample/main.go, it knows you are referring to the file /code/main.go in the container.

:let g:go_debug_substitute_paths = [['/code', '/home/oscar/code/sample']]

Another point to consider when opening a debug session with vim-go is to indicate that it will be remote, so we will need the host and port in the same way as we have previously done with the execution of dlv from the console:

:let g:go_debug_address = '0.0.0.0:40000'

Now we are ready to start a debug session and enjoy the debugging experience:

:GoDebugConnect

If everything has gone correctly, the debugging interface will open with a new layout:

[image not loaded in rss]

Problems

The solution is not perfect, as I’ve commented with the dap cocktail (nvim-dap, nvim-dap-go, nvim-dap-ui…) I wasn’t able to substitute the paths, so in the end the I couldn’t set breakpoints because the file was not matching. I was able to resolve it with vim-go, but there are still some small issues I haven’t figured out how to solve.

For example, there are many times when after establishing the connection (:GoDebugConnect) and when trying to set the first breakpoint, it takes too long to respond and eventually gives an error:

vim-go: could not toggle breakpoint: Vim(let):E716: Key not present in Dictionary: "result.Breakpoint"

If during that response time, you manually open dlv connect 0.0.0.0:40000 in another terminal, the error disappears and it continues to work. I haven’t found an explanation for this yet.

Snowy Fun with Family

info@oscarmlage.com (oscarmlage) — Mon, 23 Jan 2023 19:57:12 +0000

This past weekend was one for the books! My wife and I took our children on their first trip to the snow and it was an absolute blast. We live about an hour away from the nearest “snow spot”, so it was a short but sweet trip.

Once we arrived, we quickly bundled up and headed outside to play in the snow. The kids were so excited to see all of the snow and they couldn’t wait to try out the sleds we had brought with us. We spent hours going down the hill, laughing and having a great time. In the afternoon, we found a familiar restaurant and decided to go for a delicious lunch. It was great to catch up with them and share in the fun of the day.

As the day came to a close and we headed back home, I couldn’t help but reflect on how much fun we had as a family. This trip reminded me of the importance of spending quality time together and cherishing the moments we have with our loved ones.

So, I encourage you to make an effort to plan fun and memorable experiences with your family and friends. It doesn’t have to be anything extravagant, it can be as simple as a day trip to the snow or a picnic in the park. The important thing is that you’re making time for each other and creating lasting memories.

Life is short, and it’s important to make the most of it by enjoying the company of the people we love. So, don’t wait any longer, plan something fun with your family and friends, you won’t regret it! And as a fable, I can tell you, the memories and laughter you’ll create will be worth more than any material thing, it’s priceless.

[image not loaded in rss]

Benchmarking with Siege

info@oscarmlage.com (oscarmlage) — Thu, 29 Dec 2022 18:28:43 +0000

If you ask me, I enjoy starting a new project, that fresh feeling during the first steps is usually becoming into a not-so-fresh thing with time. Life is so :).

In this concrete case, we’re talking about an API, I needed to research and make some benchmarking work to take the best decision possible for the stack. It needs to be as fast as we can, so we can take advantage of some tools like ab or siege to measure some kinds of requests and scenarios.

With those tools in one hand and some languages in the other (go-lang and php mainly, in fact, the benchmark would be go-lang using different libraries but I was curious about a compiled language vs the fastest interpreted one I know so I added some php code), let’s start having fun!.

All the tests were done in the same machine (macbook pro intel i9-9980hk) + docker containers + a dockerized mysql. The API endpoint makes a couple of SQL queries to return about 50 rows of data from a table, the response is being jsonized. There is no auth and no more logic steps, just an endpoint that makes a sql query and returns the data as json.

Go-Lang + Gorm + Custom Router: the custom router uses the golang stdlib "net/http" to serve GET petitions.
Go-Lang + Gorm + Echo Server.
Go-Lang + Gorm + Gin.
Laravel + DB raw: as Laravel was the slowest, decided to use raw sql instead Eloquent to balance a bit the results :P, queries were done with DB::Select().
PHP “vanilla”: some memories came to my mind using mysqli_connect(), mysqli_query(), and mysqli_fetch_array().

I’ve run siege 3 times in different scenarios and calculated the average:

100 requests, only 1 concurrent
100 requests, 2 concurrents (50x2)
100 requests, 5 concurrents (20x5)
100 requests, 10 concurrents (10x10)
1000 requests, 10 concurrents (100x10)
10000 requests, 100 concurrents (100x100)
Max requests in 30 seconds, 10 concurrents
Max requests in 30 seconds, 100 concurrents
Max requests in 30 seconds, 150 concurrents: I got some errors here, so it doesn’t matter for the graphics

And the result is quite interesting:

[image not loaded in rss]

In this benchmark Go+Gorm+Echo is the clear winner, closely followed by Go+Gorm+Gin. About PHP, dunno if I did something wrong but there is a lot of difference between vanilla PHP (the results are kinda acceptable) and Laravel, still dunno why.

I had so much fun with this “exercise”.

The Van

info@oscarmlage.com (oscarmlage) — Mon, 07 Nov 2022 10:43:36 +0000

My wife and I have been used to camping since a long time ago, just put the tent and a couple of sleeping bags in the trunk of the car and drive to somewhere with a beach. We did that since the very beginning, I have lots of good memories and stories about it.

Obviously, life changes when you have children, tried - and did - it a couple of times but in the end it’s not just “pick whatever and go” because kids need more preparation, and not only preparation but stuff (clothes, games, medicines, maybe some food either…) so in the end it means much more work and worries. In that case the easy way -if you can afford it- makes more sense: do a reservation in a hotel and keep the “adventure level” limited to a “what kind of mojito should I order today in the swimming pool”.

That is totally fine don’t get me wrong, but well, we usually need something else in our trips, little adventures, discovering new places, not to have closed schedules for everything, etc… So, after a lot of thought and doubts, two years ago (Oct'20) we decided to buy a van and do a full camperization according to our needs. We were sure that the project would help us to find the roots of those first camping trips.

I’m really proud and grateful to all the people that offered help and helped us to achieve this, taking in account I was that kind of guy that asked for help even for changing a bulb, you can imagine the amount of “try and error” stuff we had to deal with. Of course, Marta and the kids were there the whole time helping and supporting in every single problem we had to arrange, which makes the thing way easier.

And two years later, after lots of learnings, investments, efforts, worries and much more stuff I can’t tell with words… we did our first (and second) trip!. For the moment, even being in autumn and with so and so weather, it’s being a total success, children are always pleased to be on the road with that adventure feeling, “where are we going this time?”, “where are we going to sleep?”, “still a long way?”. Of course it’s not ideal all the time (#vanlife has “things”) we still have to deal with the basic services (clean and dirty water, electricity, park, etc…) but we already knew this stuff from other experiences when rented motorhomes so, in general, there is no big surprises for now.

[image not loaded in rss]

🤷 I have lots of Gb. with videos and pics along this camperization process but dunno if I’ll ever have time to edit or do something more orderly and appropriate with them.

Posts on oscarmlage

FOSDEM 2026

Organized chaos

Walking among giants

The real treasure: the people

A turning point

SRE

🤔 Why SRE?

📈 The learning curve

😰 The impostor syndrome is real

📚 Continuous learning

🚀 Looking ahead

Leaving the freelance lane

Microblogging, here first

Enduro

The last dance, summer 2025

Still waiting for the joy

Between the Apple and the Robot

Rediscovering Android

Big Screen, Smooth Motion, Endless Battery

Living in Two Worlds

Takeaways

Small summer habits

Degraded mode

Recently 2025-04

🚐 Travel

🎮 Self-time

💡 The blackout

Recently 2025-03

🏃‍♂️ Sports

🎮 Self-time

🛠️ DIY

Blog introspection

Why did you start blogging in the first place?

What platform are you using to manage your blog, and why do you use it?

Have you blogged on other platforms before?

What’s your favourite post on your blog?

Any future plans for the blog?

Sometimes

Magic of Christmas Fades

Hugo and Obsidian

Hugo

Obsidian

Flow

FIFA night

The bridges of the Matrix

DNS

Synapse

Elementweb

PostgreSQL

Docker

Heisenbridge

Other bridges

Centralized Messaging via Console

Mastodon vs. Bluesky

Obsidian Templater, full potential

Feeds problems

Digital Nomad, the concept (2024)

My Essential Digital Nomad EDC:

Adapting to the new essentials

Related posts

Bluesky, hosting a PDS

Install

Account configuration

Bridge with Mastodon

Final thoughts

Mastodon, bluesky and the blue bird

Automating the media (hugo-medialog.go)

The workflow

The script in action

Project structure

How does it work for books?

Model

Controller

Template

In the end

Small tweaks in the blog

Gallery

Related posts

The Medialog