DEV Community: Victor Dorneanu

My 2025 review

Victor Dorneanu — Mon, 05 Jan 2026 10:00:00 +0000

Introduction

Although it has been a while since my last post here, I don't want to break with the tradition of doing my annual review (make sure to check out the previous years: 2021, 2023, 2024).

Coming back to writing again feels like something I should have done months ago, but hey, it's never too late. I used to have this habit of writing, especially in the morning, but this year most of the time I didn't really feel like I wanted to write. I was also increasingly engaged in other hobbies (such as music making - more on that later), so I kind of forgot the positive effects of reflecting on my own thoughts and putting them into words.

My workspace while writing the 2025 review: laptop with org-mode and the blog post, bongos from my music journey, cycling helmet representing my new commuting habits, productivity books including 'Slow Productivity', and handwritten planning notebooks - a visual summary of the year's key themes.

As I sit down here (again in the morning), it feels very hard to remember all the things that happened this year. Whenever this happens, I sometimes wonder if all the AI/GenAI usage has already impacted my brain, making me less capable of remembering things 🫠.

Professionally, I was constantly switching between Golang (mainly working on Heureka) and Python (mostly dealing with OpenStack Barbican). Beyond that, I had the chance to not only work in a Kubernetes environment but also deploy things on my own, debug, fix issues, and deepen my Kubernetes skills. At some point, I wanted to pursue the CKS (Certified Kubernetes Security Specialist) certification, but due to lack of time, I didn't manage to do so.

Apart from work I'm pretty grateful for all the things I managed to experience and all the new people I've met. Since January, I'm playing the Bongos regularly together with Barrio Latino playing Salsa, Cumbia, and Bolero. Not only this: I also managed to get more serious about House music production after purchasing my first groovebox. I also have to think of the great time my family and I had in Peloponnese, Greece. I enjoyed the food, the olive oil, the people and of course the ☀️.

Now let's first start with the goals I had for this year.

Goals for 2025

Looking back at the goals I set for myself in 2024, it's time to reflect a little bit on these:

Initial Goals for 2025

Kubernetes exploration

K8s remains a knowledge gap I'm more than determined to address. I'll again follow a "slow productivity" approach:

Start with small-scale experiments using k3s/k3d
Work towards deploying my own little cluster, either on a VPS or locally
Build practical experience through hands-on projects

And I still need to finish Kubernetes in Action which is really a great book if you want to learn about Kubernetes.

Golang deep dive

With my recent transition towards more Software Engineering-focused tasks, I'm planning to strengthen my Golang expertise. There are 2 specific areas I'd like to know more about:

Generics: This remains somewhat of a black box that I need to illuminate more
Concurrency: Beyond basic understanding, I want to explore and implement common patterns that can be applied across different problems

Security tooling

The GitHub repository security checker is still on my radar. With the rise of LLMs, I believe much of the foundational work (authentication, API interactions) can be implemented easily. The key focus will be on defining comprehensive security and compliance checks that provide real value to the users.

Music

My percussion journey continues with a focus on Congas. I've already invested in some "Compact Congas" (Giovanni Hidalgo model) that fit perfectly in my space. I believe Congas offer more "flexibility" than Bongos for song accompaniment (and solos!), and I'm particularly excited to explore Salsa music, though I'm keeping my options open for other styles.

The acoustic guitar hasn't been forgotten - I still pick it up regularly. However, I'm considering taking formal lessons to improve, especially in finger-style playing. But who knows if I'll ever get the chance to do this at all 🤷

Reflection on 2025 Goals

To be honest, I must admit that I really made impressive progress only in the music area. But let's start with the technical topics first.

Kubernetes

Nowadays, Kubernetes has become the leading orchestration platform. While at Cashlink I used to set up a completely new environment (using EKS) from scratch (which was rather a simple configuration), at SAP I already found complex clusters that required me to learn new things. I learned a lot by just having a service/application (Heureka) and being forced to take care of the full deployment. I definitely learned a lot about Helm charts, and I definitely made my mistakes along the way. Along this journey, I also discovered kubel, which became my main tool for interacting with the various clusters (from Emacs of course). I'm still lacking knowledge in some more advanced topics, which is why I initially planned to at least pursue the CKS. Due to time constraints, I didn't have the time or mental capacity to address this.

Golang

I came to SAP partly because I wanted to dive deeper into Golang. Last year (at least for the second half) I went into gopher-mode for quite a long time. During that time, I realized I lacked deep knowledge in Generics and concurrency. Looking back at this year, I think I've learned a lot more about concurrency than Generics. I even started to document some best practices but at some point I gave it up (mostly because these days, with the use of LLMs, you already have access to lots of information - what's the point of having these kinds of resources available on personal blogs/sites?).

What made this year particularly interesting was getting to architect and develop a completely new service in the area of HSM (Hardware Security Module) devices. This was fascinating territory - dealing with cryptographic hardware, PKCS#11 interfaces, and the inherent complexities of multi-tenancy in security-critical environments. The challenge wasn't just about understanding the PKCS#11 standard, but making the whole system work reliably under concurrent load while maintaining strict security boundaries between tenants.

Python & OpenStack

On the Python side, I spent considerable time extending OpenStack Barbican's crypto plugin ecosystem, specifically developing a new plugin that further expands the available PKCS#11 capabilities. It's one thing to read about cryptographic standards, but implementing them in production-grade software really forces you to understand the nuances. You can check out my contributions to the SAP Barbican fork if you're curious about the technical details.

What struck me most this year was how Python and Go serve such different purposes in our infrastructure. While Go excels at building robust, concurrent services that need to handle high loads and complex orchestration, Python shines in the OpenStack ecosystem where flexibility and rapid iteration matter more than raw performance.

Security Tooling

Back in 2024, I mentioned wanting to build a GitHub repository security checker - a tool that would audit repositories for security and compliance issues. This year, I finally started working on this idea, which evolved into Reposhield.

I kicked off the project in April, and true to my "slow productivity" approach, I spent considerable time on the architectural foundation rather than rushing into feature implementation. The project follows Hexagonal Architecture principles with a clean separation of concerns.

The current state is what I'd call "architecturally complete but functionally incomplete." I've established:

Core domain models (Finding, ScanResult, Severity levels)
A well-defined Scanner interface for extensibility
GitHub API abstraction layer with proper rate limiting
Configuration management through environment variables
Mock implementations for testing (using mockery)
GitHub Action integration structure
Documentation outlining the complete architecture

What's missing? The actual scanner implementations 🙈. I've designed the system to support multiple scanners (branch protection, secret detection, MFA enforcement, workflow security, etc.), but I haven't implemented them yet.

Music

Last year I was very excited about buying my new pair of Congas. Although I was practicing a lot, I soon realized it's not that much fun to play alone (same applies, I guess, for every instrument). Music is meant to bind people, to create some sort of community, to transfer a message. That's why soon (I guess it was January or so) I started looking for bands/musicians on berlinmusiker.de, especially in the area of Latin music (I was mostly interested in Salsa).

I was indeed very excited and soon I found myself rehearsing with the rest of the band. Although I thought they were looking for some conguero, I then ended up playing again the bongos. This was/is not per se bad as I re-discovered this instrument and found out new ways to play it. In retrospect, however, I wish I would have played more congas! I haven't used the pair of congas I bought for a while, mostly because I don't have time to practice bongos AND congas. And if that wasn't enough: Also this year I've found myself making more and more electronic music using my MC-101.

I think I'm pretty grateful for finding these lovely people and playing together with them. Meanwhile the overall band size grew to 10-13 people and we already had several concerts this year. Make sure to check out Barrio Latino Band on Instagram.

Looking back at this musical journey, I feel incredibly grateful for being able to play in a band and managing to have concerts with a full ensemble after just a few months of rehearsing together. The experience taught me so much about music arrangement - how different instruments need to complement each other, when to step back and let others shine, and when to drive the rhythm forward.

Productivity

Compared to my last year's statement:

After years of experimenting with various productivity systems, 2024 was the year where things finally clicked into place. Countless hours of listening to Cal Newport's podcast on slow productivity helped me internalize key concepts like multi-scale planning, time blocking, and deep work. This evolution in my approach has fundamentally changed how I structure my days and manage my projects.

... this year I have no revelation to write about. I guess I've incorporated those practices well while keeping the balance between digital and analogue tools. I'm still using paper to actually plan my day:

Daily planning with time-blocking: Visual representation of scheduled time slots (boxed blocks) for deep work, rest, physical activity, and creative pursuits.

I was, of course, tempted to add some AI sauce everywhere in order to optimize all the things™️, but I'm glad I haven't done so. I'm still using ORG mode files to structure projects and keep track of notes, tasks, meeting notes, etc. I use my (analogue, paper-based) notebook to plan my day and capture spontaneous ideas and meeting notes.

One thing I stopped doing was meticulously tracking my time in ORG agenda. I found myself feeling blocked every time I wanted to keep track of my activities since it implied creating a new task, refiling it to the right ORG subtree, clocking in, etc. I'm also not keeping track of project tasks in ORG mode anymore, as I'm currently working on three projects max. Most of the time, I use GitHub issues for this purpose.

Overall, I think the year started with good intentions: I've done my multi-scale planning, I've had my quarters filled in with goals, and of course I'd written down my year's goals. However, I feel I neglected focusing on just a few projects at a time (and also finishing them). Instead, I was more in an on-demand mode where I couldn't have a clear picture of what I was heading toward.

Habits

Reading

In terms of tooling, not much has changed since last year. I'm still using Goodreads as a source for book inspiration, and my Pocketbook Inkpad 3 still serves me best. Here is my reading list for 2025:

Jäger, Hirten, Kritiker
Tyranny of the Minority
Brave New World
Slow Productivity
Baustellen der Nation
Kleine Freiheit Garten
Brief Answers to the Big Questions
Nexus
Becoming Supernatural
The Anxious Generation
The Righteous Mind
The Stoic Mindset: Living the Ten Principles of Stoicism
The Little Book of Stoicism

I feel that for this year I've slightly neglected reading and started doing something else as my default activity for the evenings. Whereas the previous years I was trying to read daily now I tend to make music rather than reading something. I think this is OK and I'm also trying to tell myself it's OK for not reading for whole weeks.

Despite feeling "distracted" by music making, looking at my reading list above, I realize I still managed to read quite a lot this year! Thirteen books covering such diverse topics - from stoicism and philosophy to politics, science, and productivity. I hope to keep this pace and continue deep-diving into new topics that challenge my thinking and expand my worldview.

💡 I've already shared detailed thoughts on some of these books in my quarterly book summary post: October-December 2024. More book summaries for 2025 will follow.

Sports

I've started the year with the initial goal of doing sports at least twice a week. For me, cycling/commuting to work doesn't necessarily count as a sports activity, although it surely has its benefits. I guess for most of the time I didn't have the right discipline (when should I train? during lunch break? on which days?) and routine.

Overall I'm happy I'm back on track, and I can definitely feel the changes already (I can do more pull-ups, my spine has become more straight, I feel more energized). Most importantly, I'm proud that I finally managed to incorporate sports into my day-to-day life and make it an essential part of my routine.

Cycling

Since I got a new bike this year, I was more than motivated to cycle not only from home to the office but also to use it for general commuting instead of public transportation. This shift made cycling a natural part of my daily routine rather than just a form of exercise. The convenience and enjoyment of having a reliable bike transformed how I move around the city.

Strength Training

For strength training specifically, I aimed to train twice a week with sessions adapted to my location: quick 20-minute workouts when training in the office versus more comprehensive 40-minute sessions when I had access to a proper gym. Looking at my actual Garmin data, this flexible approach helped me maintain consistency throughout the year.

Meditation

At the end of last year, I purchased a one-year subscription to the Waking Up App, which was not quite cheap (around $100 for a year). I thought that paying that much money would definitely keep me motivated to meditate regularly. Small spoiler: It actually did, and I really liked the sessions, which all had a different focus.

I also came across this stoic meditation pack from William B. Irvine, which sparked my interest in more stoic literature. I think this is also the reason I've read so many books on stoicism this year.

As an "alternative" to meditation, I've started doing regular breathing exercises again (something I'd also completely neglected for a long time). While practicing again, I came across the Breathe with Sandy sessions, which turned out to be the most enjoyable and diverse breathing exercises I've ever experienced.

Software I Use

I'd like to continue with the same scheme I've started last year and describe the tools/services I use on a day-to-day basis.

Daily drivers

Claude (Code / Desktop)

Well, I need to be honest on this: I cannot imagine professional (but also private) life without Claude. It's literally everywhere serving me as a digital assistant. Whether I need to understand a huge code base, analyze multiple PDFs, do a quick web search, write unit tests....Claude has you covered. Ever since I started using Claude Code, I feel that the whole tooling and workflow has become even more integrated into my personal workflow.

Claude Code's MCP screenshot server enables seamless visual debugging workflows for Hugo blog development

Simply paste a screenshot showing a CSS layout issue, and Claude Code instantly analyzes the problem, understands the context, and provides comprehensive solutions

Emacs

No surprises here. It still does its job at almost every task and is the perfect companion to Claude. At some point this year, I again refactored my whole dotemacs to use https://github.com/jamescherti/minimal-emacs.d as a basis.

The claude-code.el package brings Claude's capabilities directly into Emacs

Services

Claude Pro

For more than a year, I've been using Claude Pro (whereas sometimes I'm hitting the limit multiple times a day 🙈). I didn't purchase Max 'cause I still think that's a lot of money for a service. Overall, I'm still very satisfied (with both: Claude Desktop and Claude Code, which obviously serve different purposes).

Overdrive / Libbyapp

I still have my account and use it quite regularly.

Libby's curated collection 'Die besten Bücher 2024' showcasing top German books available for digital borrowing

Goodreads

Check out my profile.

My Goodreads profile showing the 2024 reading challenge progress, favorite books collection, active bookshelves, and recent reading activity

Blinkist

I use it quite rarely but I still find it useful to get like a sneak peek whats inside a book. It's still a great format to listen to content while commuting for example. Check out https://www.blinkist.com/ (they're Berlin based 😎).

Blinkist's trending section showcasing popular books and comprehensive category system

Goals for 2026

I don't quite know what will happen in 2026 given the overall geopolitical instability around the world. Also, AI has already had quite a big impact on the industry so it's not really foreseeable what exactly will happen.

Looking forward to 2026, I think I already have some list of things I'd like to achieve:

Kubernetes

This is definitely one of my weakest points. I definitely need to get more hands-on on more advanced topics. I still haven't finished Kubernetes in Action which is definitely a really good and practicable book. I still hope to set some time aside to setup a local cluster and maybe host some services.

Music

I'd like to focus even more on live performance. That's also the reason I've purchased a SP404 MK2 which I guess will be a quite good companion to my MC-101. It's one thing to play a track (with all the layers: drums, bass line, synths, FX etc.) live compared to playing multiple tracks. For the latter, one needs like a structure and good preparation for the live set.

Of course I will definitely continue to play percussion and try to get better at congas. It has still been my biggest dream to incorporate percussion into a live DJ like performance. Hopefully I can do both at the same time.

Books / Topics

I guess I'll continue my Stoicism journey by going even deeper into the available resources (and/or maybe go to the source and read Marcus Aurelius' Meditations). As this year I had to deal a lot with software architecture, also for the next year I foresee more and more work in this field where services will have to be designed from scratch or refactored.

Knowing more about Leadership is something I had on my agenda for this year. I definitely want to improve the way I communicate to people (to my colleagues, to my managers, to my family). Staying calm and mindful when all around so many things happen is indeed challenging.

Looking Back, Moving Forward

2025 has been a year of finding balance - between technology and creativity, between digital tools and analog practices, between ambitious goals and realistic progress. While I didn't achieve all my technical objectives, the unexpected depth I found in music and the joy of live performance have added richness to my life that no Kubernetes certification could match.

The integration of Claude into my workflow has fundamentally changed how I approach both coding and writing, while the return to paper-based planning has grounded me in a more intentional approach to my days. These seemingly contradictory trends - embracing AI while valuing analog tools - actually complement each other beautifully.

As I look toward 2026, I'm excited about continuing this journey of growth and discovery. Whether it's finally mastering Kubernetes, performing live with electronic music and percussion, or diving deeper into stoic philosophy, the path ahead feels full of possibility.

Here's to another year of learning, creating, and finding joy in both the planned and the unexpected.

Add Pagefind Search to Hugo

Victor Dorneanu — Thu, 10 Apr 2025 09:11:24 +0000

Introduction

Every PKMS/BASB needs a search functionality. Ever since I've created brainfck to host my own collection of thoughts/ideas/resources (aka Zettelkasten) I wanted to be able to actually search within my collection of org-roam based notes. Meanwhile for all my sites I own (this blog, my CV/portfolio, brainfck and defersec) I use hugo. All of them didn't have proper search capabilities. That's why I was looking for a proper way to include search functionalities without any major effort.

Hugo, indeed, has some open-source and commercial search options you can choose from. I have used this fuse.js integration in the past but I wasn't happy with it. It didn't index well, I couldn't find all my content. Of course, I was thinking having Algolia DocSearch do the magic but one has to apply for it. Also, not all of my sites are about technical documentation. So I had to find another alternative. Digging deeper I came across Pagefind.

Here is a screenshot how it currently looks like:

Pagefind

Pagefind is a lightweight, static search solution designed specifically for static sites like those built with Hugo. It works by generating a search index during your site's build process, creating a client-side search experience that doesn't require any server infrastructure.

The indexing works by crawling your static HTML files after they're built, extracting content and metadata. Pagefind creates a compressed search index that's both fast and efficient, typically resulting in index sizes of about 1/1000th of your original content size. This means your search functionality remains quick even on larger sites.

When examining a typical Pagefind implementation in a Hugo site, the folder structure looks something like this:

tree public/pagefind
public/pagefind
├── fragment
│   ├── en_02aee83.pf_fragment
...
│   ├── en_2538bf9.pf_fragment
│   ├── en_2550e62.pf_fragment
│   ├── en_2582c6f.pf_fragment
│   ├── en_ffbbc35.pf_index
│   └── en_ffeab69.pf_index
├── pagefind-entry.json
├── pagefind-highlight.js
├── pagefind-modular-ui.css
├── pagefind-modular-ui.js
├── pagefind-ui.css
├── pagefind-ui.js
├── pagefind.en_19e6da436f.pf_meta
├── pagefind.en_1c7f38a66e.pf_meta
├── pagefind.en_1f95755b6e.pf_meta
├── pagefind.en_2a7661ff21.pf_meta
├── pagefind.en_4fdfe13af9.pf_meta
├── pagefind.en_5049ae833f.pf_meta
├── pagefind.en_603dab85b4.pf_meta
├── pagefind.en_6663d2c9c9.pf_meta
├── pagefind.en_7411b4b912.pf_meta
├── pagefind.en_791636c92e.pf_meta
├── pagefind.en_93f1fd4c5c.pf_meta
├── pagefind.en_94bcd0c843.pf_meta
├── pagefind.en_a8061c44f1.pf_meta
├── pagefind.en_a96223e65e.pf_meta
├── pagefind.en_b526d7e391.pf_meta
├── pagefind.en_b6e37679e1.pf_meta
├── pagefind.en_b7a63d2937.pf_meta
├── pagefind.en_c039de83fe.pf_meta
├── pagefind.en_d9c4de17e6.pf_meta
├── pagefind.en_deac3933f1.pf_meta
├── pagefind.en_eb3680ac82.pf_meta
├── pagefind.en_fab96f64ed.pf_meta
├── pagefind.js
├── wasm.en.pagefind
└── wasm.unknown.pagefind

3 directories, 3087 files

Configuration

You also have some configuration options. In my case:

# Pagefind configuration

# Basic options (using Pagefind 1.0 naming)
site: public
output_subdir: pagefind

# Add date-based metadata for sorting
indexing_options:
  # Add date as metadata for all pages
  - metadata_date_field: date
    metadata_date_format: iso

  # Global metadata fields for all pages
  - metadata_fields:
      # Primary metadata sources
      - {
          tag: "meta[property='og:title']",
          as: "title",
          content_attr: "content",
          optional: true,
        }
      - { selector: ".post-title", as: "title", optional: true }
      - { selector: "h1", as: "title", optional: true }

      # Date and other metadata
      - {
          tag: "meta[property='og:type']",
          as: "type",
          content_attr: "content",
          optional: true,
        }
      - {
          tag: "meta[name='date']",
          as: "date",
          content_attr: "content",
          optional: true,
        }
      - {
          tag: "meta[property='article:published_time']",
          as: "published",
          content_attr: "content",
          optional: true,
        }
      - {
          selector: "time",
          as: "date",
          content_attr: "datetime",
          optional: true,
        }

# Added languages
language:
  code: en
  stemming: true

# Search options
search_options:
  ignore_missing_metadata_fields: true
  boost_exact_matches: true
  boost_title: 5.0

This configuration file sets up Pagefind with optimal settings for a personal knowledge base. The key options include:

Basic setup: Specifies the source directory (public) and where to output the search files (pagefind subdirectory)
Date-based metadata: Adds date fields for each page, enabling chronological sorting of search results
Metadata extraction: Configures multiple fallback methods to extract page titles and dates from different HTML elements and meta tags
Search optimization: Boosts exact matches and increases the weight of title matches by 5x, ensuring the most relevant results appear first

Hugo integration

Search page

---
title: "Search"
---

Search template

The search page implementation works through several key components:

Loading Pagefind scripts: The template loads the necessary CSS and JavaScript files that Pagefind generated during the build process.
Search parameter handling: The implementation supports direct linking to search results using URL parameters. When someone visits /search?q=zettelkasten, the page automatically populates the search box with "zettelkasten" and triggers the search.
URL updating: As the user types in the search box, the URL is dynamically updated with the current query using the browser's History API (pushState). This creates a seamless experience where users can bookmark or share specific search results.

{{ define "main" }}
<main class="center mv4 content-width ph3">
  <div class="f3 fw6 heading-color heading-font">{{ .Title }}</div>
  <div class="lh-copy mt4">
    <p>Search across all content.</p>

    <!-- Load Pagefind scripts -->
    <link href="/pagefind/pagefind-ui.css" rel="stylesheet" />
    <script src="/pagefind/pagefind-ui.js"></script>

    <!-- Create the search container with your site's styling -->
    <div id="search" class="w-100 mb4"></div>

    <script>
      // Set configuration for pagefind
      window.pagefindConfig = {
        bundlePath: "/pagefind/",
        processTerm: (term) => {
          // Simple processing to remove undefined text from search results
          return term.replace(/undefined/g, "");
        },
      };

      // Function to get URL parameters
      function getUrlParameter(name) {
        name = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]");
        const regex = new RegExp("[\\?&]" + name + "=([^&#]*)");
        const results = regex.exec(location.search);
        return results === null ? "" : decodeURIComponent(results[1].replace(/\+/g, " "));
      }

      // Initialize the search UI when the DOM is loaded
      document.addEventListener("DOMContentLoaded", function () {
        // Get the search query from URL parameter 'q' if it exists
        const initialQuery = getUrlParameter("q");

        const searchUI = new PagefindUI({
          element: "#search",
          showSubResults: true,
          showImages: false,
          sort: {
            // Enable sorting by date (newest first) and relevance
            options: [
              { key: "date", label: "Date (Newest First)", order: "desc" },
              { key: "default", label: "Relevance" },
            ],
            // Use date as the default sorting method
            default: "date",
          },
          translations: {
            placeholder: "Search your notes...",
            zero_results: "No results found",
            many_results: "Found {results} results",
            sort_by: "Sort by:",
          },
        });

        // Set up a listener to watch for changes in the search input
        setTimeout(() => {
          // Find the search input after PagefindUI has initialized
          const searchInput = document.querySelector(
            ".pagefind-ui__search-input",
          );
          const searchForm = document.querySelector(".pagefind-ui__form");

          if (searchInput) {
            // Update URL when the search input changes
            searchInput.addEventListener("input", function () {
              updateSearchUrl(this.value);
            });

            // Also capture form submission (when user presses Enter)
            if (searchForm) {
              searchForm.addEventListener("submit", function (e) {
                // Don't prevent default as we want the search to execute
                updateSearchUrl(searchInput.value);
              });
            }
          }

          // Helper function to update the URL with the search query
          function updateSearchUrl(query) {
            const url = new URL(window.location);

            if (query && query.trim() !== "") {
              url.searchParams.set("q", query);
            } else {
              url.searchParams.delete("q");
            }

            window.history.pushState({}, "", url);
          }
        }, 500); // Short delay to ensure PagefindUI has initialized

        // If there's an initial query, set it and trigger the search
        if (initialQuery) {
          // Use a small timeout to ensure PagefindUI is fully initialized
          setTimeout(() => {
            searchUI.triggerSearch(initialQuery);
          }, 100);
        }
      });
    </script>
  </div>
</main>
{{ end }}

CSS

/* Simple pagefind overrides to match site styling */
:root {
  --pagefind-ui-scale: 1;
  --pagefind-ui-primary: #3e5622;
  --pagefind-ui-text: #333;
  --pagefind-ui-background: #fff;
  --pagefind-ui-border: #ddd;
  --pagefind-ui-border-radius: 4px;
}

/* Search input styling */
.pagefind-ui__search-input {
  padding: 0.5rem !important;
  width: 100% !important;
  border: 1px solid #ddd !important;
  border-radius: 0.25rem !important;
  font-size: 1rem !important;
  /* Remove the search icon */
  background-image: none !important;
  padding-right: 16px !important;
  padding-left: 16px !important;
}

/* Adjust clear button position */
.pagefind-ui__search-clear {
  right: 16px !important;
}

/* Result title styling */
.pagefind-ui__result-title {
  font-weight: 600 !important;
}

.pagefind-ui__result-link {
  color: #3e5622 !important;
  text-decoration: none !important;
}

/* Highlight search terms */
.pagefind-ui__result-excerpt mark {
  background-color: rgba(255, 255, 0, 0.4) !important;
  color: inherit !important;
}

/* Load more button styling */
.pagefind-ui__button {
  background-color: #3e5622 !important;
  color: white !important;
  border: none !important;
  border-radius: 0.25rem !important;
  padding: 0.5rem 1rem !important;
  cursor: pointer !important;
}

/* Simple fix for undefined text */
.pagefind-ui__result-excerpt:contains('undefined'),
.pagefind-ui__result-title:contains('undefined') {
  visibility: hidden;
}

Netlify deployment

Deploying your Pagefind-enabled Hugo site on Netlify is straightforward with this configuration:

[build]
  publish = "public"
  command = "hugo && npx pagefind --site public --output-subdir pagefind"

[build.environment]
  HUGO_VERSION = "0.145.0"  # Replace with your current Hugo version
  NODE_VERSION = "18"       # Ensure we have a recent Node version for Pagefind

# Cache control for Pagefind files
[[headers]]
  for = "/pagefind/*"
  [headers.values]
    Cache-Control = "public, max-age=604800"

The configuration does three critical things:

Build command: It extends the standard Hugo build process by adding Pagefind indexing as a second step. This ensures your search index is generated after Hugo creates all the HTML files.
Environment setup: It specifies the required Hugo and Node.js versions.
Cache configuration: It adds cache headers for all Pagefind files, setting a one-week cache period. This improves performance for returning visitors, as browsers won't need to download the search index again on every visit.

For local development this might be also useful:

{
  "name": "brainfck-roam",
  "version": "1.0.0",
  "description": "Your org-roam notes on Hugo",
  "scripts": {
    "build": "hugo && npx pagefind --site public --output-subdir pagefind",
    "dev": "hugo server -b http://127.0.0.1:1315/ --disableFastRender --port 1315 --noHTTPCache --logLevel debug --gc",
    "search-index": "npx pagefind --site public --output-subdir pagefind",
    "full-dev": "npm run build && npm run dev"
  },
  "dependencies": {
    "pagefind": "^1.0.0"
  }
}

The package.json file provides several convenient npm scripts that streamline your workflow:

npm run dev
- Starts a local Hugo server with debug logging and cache disabled.
npm run search-index
- Runs only the Pagefind indexing on your current build output. This is helpful when you want to rebuild just the search index without regenerating the entire site.
npm run build
- Performs the complete production build process—generating the Hugo site and then creating the Pagefind search index afterward.
npm run full-dev
- A comprehensive development command that builds the complete site with search index and then starts the development server. This is ideal when you need to test search functionality locally.

Resources

Hugo Search tools
Pagefind | Pagefind — Static low-bandwidth search at scale
Adding local search to Hugo with Pagefind – jverkamp.com - This is where I got the idea with the q parameter (e.g. /search?q=string)
Search with Pagefind - michael-le.dev

Book Summaries: January - March 2025

Victor Dorneanu — Wed, 02 Apr 2025 00:00:00 +0000

Continuing with my tradition of quarterly book summaries, here are my reflections on the books I’ve read between January and March this year.

📚 Tyranny of the Minority

👉 Tyranny of the Minority by Steven Levitsky & Daniel Ziblatt

At the beginning the title seemed very strange to me since my first thought was: “How can a minority overrule the majority?” As the authors put it:

Majorities must also be constrained in a second area: the rules of democracy itself. Elected governments must not be able to use their temporary majorities to entrench themselves in power by changing the rules of the game in ways that weaken their opponents or undermine fair competition.

In a “liberal” democracy you need both: protect minority rights but allow the majority to rule:

And so the form of democracy that emerged in the West between the late eighteenth and the twentieth centuries, which today we call “liberal” democracy , is based on two pillars: collective self-rule (majority rule) and civil liberties (minority rights). Although liberal democracy cannot exist without free and fair elections, not everything can or should be up for grabs in elections.

“Tyranny of the Minority” is the analysis of the political system in the USA and describes how the minority rule seems to have led to a breaking point in the American democracy. The authors argue that the US constitution (which is one the of the oldest one, and designed in a pre-democratic era) allows minorities to thwart majorities and sometimes even govern them. Institutions that empower these minorities can become instruments of minority rule, which is especially dangerous when these minorities are extremist or antidemocratic.

Several specific counter-majoritarian institutions are highlighted as contributing to this problem:

The Electoral College can distort the popular vote, allowing a candidate with fewer votes to win the presidency. This is exacerbated by the winner-take-all system in most states and a small-state bias that favors Republicans
The US Senate dramatically overrepresents citizens of less populated states , meaning a Senate majority can represent a small fraction of the U.S. population
Furthermore, the filibuster allows a partisan minority in the Senate to permanently block legislation backed by large majorities
The Supreme Court, with lifetime appointments, can be nominated by presidents who lost the popular vote and confirmed by Senate majorities representing a minority of Americans. This can lead to a court that thwarts the will of the majority for generations

The authors suggest the following democratic reforms :

Uphold the right to vote
Ensure election outcomes reflect majority preferences
Empower governing majorities

👉 Check out my notes.

📚 Brave New World

👉 Brave New World by Aldous Huxley

Continuing the “totalitarian path” I also read “Brave New World” which was written in 1932, before Orwell’s 1984 which was published in 1949. Both are considered two of the most influential dystopian novels of the 20th century, each presenting different aspects of totalitarian features:

1984: brutal surveillance that maintains control through violence, propaganda, and psychological manipulation
Brave New World: portrays a seemingly pleasant society controlled through pleasure, genetic engineering, and conditioning

Both books give political warnings and complementary concerns about the future of human society and freedom. Reading these two influential 20th-century dystopian novels as complementary warnings provides a more complete picture of the potential threats to human freedom. Orwell feared those who would ban books; Huxley feared there would be no reason to ban books because no one would want to read them. Orwell feared a population controlled by pain; Huxley feared a population controlled by pleasure and distraction.

I found myself particularly struck by how Huxley anticipated the use of sophisticated biological technology to control populations. His vision of humans engineered from conception to fit predetermined social roles feels disturbingly plausible in an era of advancing genetic technology. The novel’s exploration of how pleasure and constant distraction can serve as effective means of control also resonates with our current attention economy.

So, read for yourself, I really liked it!

👉 Check out my notes.

📚 Jäger, Hirten, Kritiker

👉 Jäger, Hirten, Kritiker by Richard David Precht

The author was recommended to me from a friend (this is my first book by Precht), and while I didn’t particularly like his writing style, overall I got interesting new insights from the book. Given that this book was written in 2018 (when AI wasn’t yet available to the masses, and authoritarian regimes hadn’t partnered with technocrats in democratic countries), I was struck to realize that what Precht was foreseeing seems to be becoming reality.

One of the main ideas is that the concept of work (as we’ve defined it until now) will change:

Many jobs will disappear because of automation (and of course AI)
But humans have also become dependent on technology to the point they cannot live without it anymore:

People have forgotten how to drive cars, read maps, and navigate the world on their own. They no longer need to remember anything because electronic devices remind us of everything, and they store less and less knowledge about the world because devices take over this function for us. Most people have reverted to toddlers in their knowledge about the world, their dependence on (technical) care, and their lack of courage to leave the house without assistive devices (or soon, a chip in their head). They communicate through stone-age pictograms, and infantilely divide the world into likes and dislikes.

People want to be independent, yet we’re increasingly becoming “ prosumers ” ( producing consumers ):

What used to be trained occupations are now handled by robots. And much of what skilled workers once did, customers now do themselves on their flat screens. The development toward the prosumer, the producing consumer, predates digitalization. Remember how supermarkets replaced grocery retailers in Germany since the 1960s. The discounter was not only cheaper because it was larger, but also because customers now served themselves, thereby saving personnel. The same applies to coffee and ticket machines in the eighties and nineties and to the self-assembly skills of IKEA buyers. The principle of the working customer in the digital age is nothing but the consistent continuation of this self-service: booking trips, checking in at the airport, ordering clothes and books, executing transfers, and so on.

Without noticing it, people blindly trust solutions from Palo Alto meant to make their lives easier, however:

Most people have reverted to toddlers in their knowledge about the world, their dependence on (technical) care, and their lack of courage to leave the house without assistive devices (or soon, a chip in their head). They communicate through stone-age pictograms, and infantilely divide the world into likes and dislikes.

Technocrats also want to optimize our lives, but to what degree?

Our craftsmanship is dying out, our linguistic expression is being reduced, our memory, outsourced to memory functions, is declining, our imagination consists of prefabricated images, our creativity follows exclusively technical patterns, our curiosity gives way to convenience, our patience to permanent impatience; we can no longer endure the state of non-entertainment. If this is what the superman looks like—who would want to be one?

So, if computers take over our jobs, what is the solution? The author (among others) suggests Universal Basic Income :

When advocating for the UBI, the unconditional basic income that every citizen should receive regardless of their need, the first reflexive question that comes up is: Who is going to pay for it? The question—so automated that apparently no one asks why it is immediately posed—is strange. Why shouldn’t the UBI be financeable? After all, we live in the richest Germany that has ever existed. And productivity is increasing rapidly through digitalization. Computers and robots don’t cost social security contributions, don’t draw pensions, holiday or maternity pay. They don’t sleep but work effortlessly day and night.

I’ll definitely check out his other books.

👉 Check out my notes.

📚 Slow Productivity

👉 Slow Productivity by Cal Newport

If you read my blog posts regularly and have talked to me in person, you might already know I’m a big fan of Cal Newport. I also used to listen to his podcast regularly, so I got in-touch with the term “slow productivity” before he even published the book. He has always been a promoter of “doing less (shallow) work and instead doing more deep work.”

He defines “slow productivity” as follows:

SLOW PRODUCTIVITY A philosophy for organizing knowledge work efforts in a sustainable and meaningful manner, based on the following three principles:

Do fewer things.

Work at a natural pace.

Obsess over quality.

What I’ve found interesting was Newport’s mention of Carl Honoré’s book “In Praise of Slowness” which seemed to have coined the “ slow movement ”:

As the journalist Carl Honoré documents in his 2004 book, In Praise of Slowness, these second-wave movements include Slow Cities, which also started in Italy (where it’s called Cittaslow), and focuses on making cities more pedestrian-centric, supportive of local business, and, in a general sense, more neighborly. They also include Slow Medicine, which promotes the holistic care of people as opposed to focusing only on disease, and Slow Schooling, which attempts to free elementary school students from the pressures of high-stakes testing and competitive tracking. More recently, the Slow Media movement has emerged to promote more sustainable and higher-quality alternatives to digital clickbait, and the term Slow Cinema is increasingly used to describe realistic, largely nonnarrative movies that reward extended attention with deeper insight into the human condition. “The slow movement was first seen as an idea for a few people who liked to eat and drink well,” explained the mayor of Petrini’s hometown of Bra. “But now it has become a much broader cultural discussion about the benefits of doing things in a more human, less frenetic manner.”

So the goal of “slow productivity” is to create a more human and sustainable approach to work:

My goal is to offer a more humane and sustainable way to integrate professional efforts into a life well lived. To embrace slow productivity, in other words, is to reorient your work to be a source of meaning instead of overwhelm, while still maintaining the ability to produce valuable output.

In order to achieve this, the author recommends 3 principles:

Principle #1: Do fewer things

The author argues here that factory work is completely different from knowledge work:

In a factory, pushing employees to work longer shifts might be directly more profitable. In knowledge work, by contrast, pushing employees into larger workloads can decrease both the quantity and quality of what they produce.

The knowledge sector sets “productivity” = busyness, which is fundamentally misguided.

Principle #2: Work at a natural pace

Newport gives some background how our working patterns have changed in the past:

This side-by-side comparison underscores the degree to which our experience of work has transformed during the recent past of our species. Our shift from hunting and gathering to agriculture—the Neolithic Revolution—only really picked up speed somewhere around twelve thousand years ago. By the time of the Roman Empire, foraging had almost completely disappeared from the human story. This reorientation toward agriculture threw most of humanity into a state similar to that of the rice-farming Agta, grappling with something new: the continuous monotony of unvarying work, all day long, day after day.

He also mentions we’re constantly grinding without relief:

The second principle of slow productivity argues that these famous scientists were onto something. Our exhausting tendency to grind without relief, hour after hour, day after day, month after month, is more arbitrary than we recognize. It’s true that many of us have bosses or clients making demands, but they don’t always dictate the details of our daily schedules—it’s often our own anxieties that play the role of the fiercest taskmaster. We suffer from overly ambitious timelines and poorly managed workloads due to a fundamental uneasiness with ever stepping back from the numbing exhaustion of jittery busyness.

He also suggests working in cycles (which is a more natural approach):

Work in Cycles The software development company Basecamp is known for experimenting with innovative management practices. This is perhaps not surprising given that its cofounder and current CEO, Jason Fried, once published a book titled It Doesn’t Have to Be Crazy at Work. One of Basecamp’s more striking policies is the consolidation of work into “cycles.” Each such cycle lasts from six to eight weeks. During those weeks, teams focus on clear and urgent goals. Crucially, each cycle is then followed by a two-week “cooldown” period in which employees can recharge while fixing small issues and deciding what to tackle next. “It’s sometimes tempting to simply extend the cycles into the cooldown period to fit in more work,” explains the Basecamp employee handbook. “But the goal is to resist this temptation.”

- Principle #3: Obsess over quality

The author shares examples of how obsessing over quality can provide leverage for greater control over one’s schedule, and how this doesn’t necessarily require becoming a superstar but rather developing rare and valuable skills:

Both Jewel and Paul Jarvis discovered a similar lesson in their careers. The marketplace doesn’t care about your personal interest in slowing down. If you want more control over your schedule, you need something to offer in return. More often than not, your best source of leverage will be your own abilities. What makes Jarvis’s story so heartening is its demonstration that these benefits of “obsessing” over quality don’t necessarily require that you dedicate your entire life to the blinkered pursuit of superstardom. Jarvis didn’t sell fifteen million records; he instead became, over time, good at core skills that were both rare and valuable in the particular field in which he worked. But this was enough, when leveraged properly, to enable significantly more simplicity in his professional life. We’ve become so used to the idea that the only reward for getting better is moving toward higher income and increased responsibilities that we forget that the fruits of pursuing quality can also be harvested in the form of a more sustainable lifestyle.

The author provides a strategy for balancing obsession and perfectionism: give yourself enough time to create something great but not unlimited time, and focus on making progress rather than perfection:

Your goal is instead reduced to knocking the metaphorical ball back over the net with enough force for the game to proceed. Here we find as good a general strategy for balancing obsession and perfectionism as I’ve seen: Give yourself enough time to produce something great, but not unlimited time. Focus on creating something good enough to catch the attention of those whose taste you care about, but relieve yourself of the need to forge a masterpiece. Progress is what matters. Not perfection.

👉 Check out my notes.

Le Fin

As always: You can find my readings on Goodreads and my current to-be-read list of booksher.

Book Summaries: October - December 2024

Victor Dorneanu — Thu, 16 Jan 2025 00:00:00 +0000

Continuing with my tradition of quarterly book summaries, here are my reflections on the books I’ve read between October and December last year.

Biographies

📚 Elon Musk

👉 Elon Musk by Walter Isaacson

I must admit I’m definitely not a fan of Elon Musk and had some curiosity to learn more about the person behind the public façade. I wanted to learn more about all the aspects that shaped him and his mindset. As I learned, his childhood and his relationship to his father have had a profound impact on his thinking and behavioral tendencies.

Overall, I was fascinated by Musk’s intelectual breadth which spans multiple domains. He decided to major in physics because, like his father, he was drawn to engineering. He also decided to learn about business because he didn’t want to work for others:

“I was concerned that if I didn’t study business, I would be forced to work for someone who did,” he says. “My goal was to engineer products by having a feel for the physics and never have to work for a boss with a business degree.”

It was exactly this combination of technical depth and business knowledge that would serve as a fundament for his future ventures. As for his visions he had very concrete expectations:

He had conceived by then a life vision that he would repeat like a mantra. “I thought about the things that will truly affect humanity,” he says. “I came up with three: the internet, sustainable energy, and space travel.” In the summer of 1995, it became clear to him that the first of these, the internet, was not going to wait for him to finish graduate school. The web had just been opened up for commercial use, and that August the browser startup Netscape went public, soaring within a day to a market value of $2.9 billion.

Given our planet’s burning challanges (climate crisis, poverty, low education, war) I still question his Mars colonization plans which are driven by his will to save humanity and our species once there will be no life possible anymore on Mother Earth. The biography not only revelead controversial aspects about his visions but also about his leadership style and work ethics:

Musk responded with a very self-aware email. “I am by nature obsessive-compulsive,” he wrote Fricker. “What matters to me is winning, and not in a small way. God knows why… it’s probably rooted in some very disturbing psychoanalytical black hole or neural short circuit.”

While he is undoubtly a visionaire and leaded to the success of multiple multi-billion companies, I still find his management practices problematic: From arbitrary dismissals to creating unsustainable work environments.

📓 Read my notes

Politics

📚 How Democracies Die

👉 How Democracies Die by Steven Levitsky, Daniel Ziblatt (read in German)

Unless you have been living under a rock for the last years, you certainly have noticed the rising authoritarian tendencies worldwide. While this book’s focus is the United States’ constitutional framework, it has provided me with with good analysis of democratic decline globally and important insights how democratic systems can be systemcally undermined.

One of the most important revelation to me was the fact that most totalitarian leaders (Hitler, Mussolini, Trump, Erdogan, Orban, Chavez, Fujimori) throuhout history more or less followed the same pattern to gain power. As the authors note (translated from German using LLM):

This story has played out in various forms around the world over the past century. A series of political outsiders, from Adolf Hitler in Germany to Getúlio Vargas in Brazil, Alberto Fujimori in Peru, and Hugo Chávez in Venezuela, all came to power the same way: from within, through elections or alliances with powerful political figures. Each time, elites believed that including the outsider in government would contain them and restore mainstream politicians’ power. This belief proved deceptive. A fatal mixture of ambition, fear, and miscalculation led them to make the same fateful mistake: they knowingly handed over the keys of power to an aspiring autocrat.

What also resonated with me of the crucial role of institutional safeguards in democratic systems. As the book mentiones also political parties have a responsibility in preserving democracy:

While mass response to extremist temptations is important, what matters more is whether political elites, and especially parties, serve as filters. Simply put, parties are the guardians of democracy.

Perhaps most disturbing is how autocratic forces often use democratic institutions and rules to gain power while simultaneously undermining democratic values. They often call for “real” or “more” democracy while at the same time working to dismantle it.

📚 Animal Farm

👉 Animal Farm by George Orwell (read in German)

My first George Orwell reading was 1984 making “Animal Farm” (its chronological predecessor) particularly interesting as it reveals the evolutionof Orwell’s thoughts on authoritarian systems. Without knowing Orwell’s personal background and political influences that shaped his perspective (on comunism and failed socialist ideals) one cannot truly appreciate his work.

The book’s central message is perhaps best captured in its famous principle:

“All animals are equal, but some animals are more equal than others”

(German: “ALLE TIERE SIND GLEICH, ABER MANCHE TIERE SIND GLEICHER ALS ANDERE” )

This simple statement encapsulates the entire tragedy of how egalitarian ideals can be corrupted by those in power (in this case, represented by the pigs which gradually take over control of the farm). What makes this book particularly relevant today is its brilliant illustration of how manipulation, fear, propaganda and ideology can facilitate the establishment of authoritarian systems. Orwell did a good job to show (through farm animals) how revolutionary ideals can be gradually misinterpreted and misused to serve the interests of a new elite. As our world becomes more and more dominated by both autocrats and technocrats, the warnings embedded in the book feel more present than ever.

📓 Read my notes (German)

Climate

📚 The Ministry of the Future

👉 The Ministry of the Future by Kim Stanley Robinson

I’ve listened to “The Ministry of the Future” through an audiobook which, in retrospect, might not have been the optimal choice for absorbing the depth and complexity of this work. I think I’ll purchase a physical copy or the e-book version of this book as it deserves a more deliberate pace. The audiobook doesn’t really allow you to revisit key passages, make notes and reflect on certain aspects.

What sets this book apart is its quite realistic approach to climate science fiction. Far from dystopian extremes and far-fetched solutions it offers a quite realistic scenario of how humanity might struggle with the all the challenges of the climate crisis. The main idea of the book, a global governance institution particularly resonated to me as it demonstrates the need for global actions instead of letting individual nations handle climate actions in isolation. These actions usually have unforeseeable effects on other regions weather conditions which definitely might lead to conflict between countries.

Apart from that there were two economic concepts that seem crucial solving global problems. First, the role of corporate funding in environmental projects and secondly the idea of a carbon coin, a global financial instrument designed to fund climate crisis initiatives. This creates investment opportunities for corporations while maintaining focus on environment goals. And of course, the ROI (return of investment) will be way lower than usual rates.

As I’ve mentioned already I’m planning to revisit this work in either e-book or physical format. The book has several detail layers that require a more traditional reading approach allowing me to engage with the complex ideas in a more deeper manner.

📚 History of Bees

👉 The History of Bees by Maja Lunde

I came to this book through my wife’s recommendation and despite not being a regular novel reader I became quite interested about the potential consequences of a global bee extinction. Like “The Ministry of the Future” this work presents a realistic scenario of how environmental crisis could reshape human society, but focusses specially on the critical role of bees in our ecosystem.

Through the book you’ll get to read stories from different epochs that initially seem distinct but at the end reveal their interconnections. Through these parallel stories, the author illustrates the historial, present and potential future significance of apiculture(beekeeping).

If you study bees you’ll get to understand their important for our food systems. Almost without human intervention natural pollination of trees (through bees) takes place which is crucial for fruit production. This again is vital for continuous harvests and therefore for food security. As you delve into the book’s chapters it becomes clear how these small insects play a vital role in maintaining our already fragile ecological balance.

The use of multiple timelines and connected stories effectively highlights the scientific importance of bees (for agriculture) but also the potential costs (for humans) of their potential loss.

Food Science

📚 Salt Fat Acid Heat

👉 Salt Fat Acid Heat by Samin Nosrat (read in German)

I think that in another life I might have been a cook 🙈 - at least that’s how I explain my passion for cooking and culinary arts. While I explored different techniques from slow cooking to steam preparation, it is Samin Nosrat’s “Salt Fact Acid Heat” that slowly transforms my approach to cooking.

What’s so cool about this book is the way it deconstructs the fundamental elements we often take for granted in cooking. Salt, oil, fat are such common ingredients that we don’t really think about their actual purpose in our dishes. Nosrat breaks down (in a semi-scientific approach) the chemical interactions between these elements and various ingredients. This (technical) depth adds a new dimension to understanding how and why certain cooking techniques work the way they do.

Along the technical explanations Nosrat also shares personal anecdotes and tips making complex cooking techniques accessible and memorable. Personally I struggled for a long time to remember all the ingredients one needs to make a good sauce. The books has a comprehensive section on sauce-making (which oil depending on the what type of food you want to prepare etc.) and definitely helped me created balanced flavours. After all it’s not a rocket science but it feels this way when you don’t know the basics.

At the end of the book you’ll find a recipe collection which also serves as a pratical demonstration of the principles discussed in the book. These recipes are not only just some steps you should follow, but more like practical lessons in applying (Nosrat’s) science of cooking.

📓 Read my notes (German)

Business & Productivity

📚 The Effective Executive

👉 The Effective Executive by Peter F. Drucker

Drucker’s “The Effective Executive” was originally published in 1966 during his tenure as a management professor at the New York University. At least for me this book proved to be a dissapointment: I cannot recommend reading this book as there are plenty of more valuable works on management and productivity.

The book’s approach sounds kind of odd to me especially after engaging (through books and podcasts) with Cal Newport’s modern frameworks around deep work, “slow productivity”, multi-scale planning and time blocking. Till now these methodologies have been quite effective in my own work. While Drucker is often considered a management thinking pioneer, this particular book (I haven’t read any others yet) offers little practical value for someone working as a knowledge worker. Perhaps in 1966 and the decades after this book has been revolutionary. However, I’d recommend looking to more current works that better reflect today’s work environment and challenges.

My 2024 review

Victor Dorneanu — Thu, 19 Dec 2024 09:00:00 +0000

Introduction

As another year comes to an end, it's time for my annual review (check out 2021, 2023) - a tradition where I reflect on the past twelve months, examining what I've learned, how I've grown, and whether I've managed to stick to my goals. These reviews serve as a personal chronicle but also a way to share experiences that might resonate with others on similar journeys.

2024 has been a year of significant transitions and new beginnings. Perhaps the most noteworthy change came in my professional life, where I stepped into a more software engineering-focused role. This transition brought an exciting opportunity to contribute to a large open-source project - something that has opened new horizons for learning and collaboration.

In an effort to share knowledge and best practices, I launched defersec.com, a platform dedicated to DevSecOps principles with a particular focus on the Golang ecosystem. This project has allowed me to combine my passion for security with practical implementation guidance. Along this journey, I've had the chance to deepen my expertise in infrastructure as code, particularly with Terraform, while also exploring the world of Kubernetes.

Beyond the technical realm, this year brought musical adventures I hadn't anticipated. Learning to play the bongos evolved into taking Afro-Cuban Rumba classes for congas - a journey that has added new rhythms and joy to my life.

Looking back, 2024 has been remarkably fulfilling - a year characterized by growth, learning, and shared experiences with wonderful people. As we dive into the details of this year's journey, I'll explore how various aspects of my life have evolved, from productivity systems to daily habits, and from technical skills to creative pursuits.

Goals

As another year comes to an end, it's time to look back at the goals I set for 2024 and think about what lies ahead. This reflection helps me understand not just what I've achieved, but also how my interests and priorities have evolved throughout the year.

2024 Goals Recap

Projects

Back in 2023 i wrote:

Play with HTMX and Golang

I'd definitely love to do something front-end related and therefore I'd like to play a little bit with htmx. But first I need an idea for a small application. This way I plan to code again in Golang (this year I didn't manage to code anything useful).

Security of Github repositories

While dealing with Github and the security settings of repositories, I wanted to have a small tool at hand which will check for different settings (for each repository in an organization) and report (via Slack, E-Mail) if some settings are not compliant.

Finish "Documentation as Code" series

This year I've started writing about several documentation techniques (as code) in my Documentation as Code series. I definitely want to add at least D2Lang to it.

Some goals remained aspirational. The tool for auditing GitHub repository security settings is still on the drawing board. I've been thinking whether to develop it as a standalone application or integrate it into existing frameworks like Steampipe.

Info Notice:

👉 Steampipe already has some Github integrations

My "Documentation as Code" series took an unexpected turn. While I initially was a Plantuml advocate, I found myself gravitating more and more towards Mermaid charts (also after having to write some ADRs where, of course, I've added some diagrams). Its seamless integration with GitHub - automatic rendering in Markdown documents 😎 - proved to be a killer feature.

Music

Back in 2023 my thoughts were:

Besides playing the Djembe this year I've started learning how to play the Bongos. With the help of ChatGPT I was able to read notes again and therefore play some easy to more advanced rhythms on the Bongos. Next year I'd like to keep practicing and get more insights into Latin rhythms (Salsa, Bachata, Merengue, Mambo, Rumba etc.)

I have played an acoustic guitar for a while, although not with the same proficiency as I have with hand drums. For motivation, I would like to learn to play the electric guitar and make progress in live looping.

This year marked a significant milestone in my musical journey. After starting with Bongos last year, I dove deeper into Latin percussion by taking Rumba classes on Congas. The world of digital music also opened up to me: I've experimented with live looping and learned my way around Reaper, a cross-platform DAW (Digital Audio Workstation). A particular highlight was discovering Koala Sampler, which completely transformed my approach to live looping and sampling.

Goals for 2025

Technical Projects

Looking ahead, I've identified several key areas for technical growth:

Kubernetes exploration

K8s remains a knowledge gap I'm more than determined to address. I'll again follow a "slow productivity" approach:

Start with small-scale experiments using k3s/k3d
Work towards deploying my own little cluster, either on a VPS or locally
Build practical experience through hands-on projects

And I still need to finish Kubernetes in Action which is really a great about if you want to learn about Kubernetes.

Golang deep dive

With my recent transition towards more Software Engineering-focused tasks, I'm planning to strengthen my Golang expertise. There are 2 specific areas I'd like to know more about:

Generics: This remains somewhat of a black box that I need to illuminate more
Concurrency: Beyond basic understanding, I want to explore and implement common patterns that can be applied across different problems

Security tooling

Productivity

After years of experimenting with various productivity systems, 2024 was the year where things finally clicked into place. Countless hours of listening to Cal Newport's podcast on slow productivity helped me internalize key concepts like multi-scale planning, time blocking, and deep work. This evolution in my approach has fundamentally changed how I structure my days and manage my projects.

👉 Activity tracking with Garmin

👉 Step tracking throughout the year

Analog Tools Still a Thing

The return to my bullet journal has been transformative. While digital tools have their place, there's something uniquely effective about pen and paper for certain tasks. Just the simple physical act of writing helps me process information differently and creates a stronger connection to my plans and ideas.

Time Blocking in Practice

One of the most significant changes has been implementing regular time blocking. This practice has helped me:

Visualize my daily resources more effectively
Be more realistic about what can be accomplished
Mentally prepare for the day ahead before diving into tasks

The Power of Paper

Despite our digital age, collecting ideas, notes, and TODOs using pen and paper remains unbeatable for several reasons:

Meeting notes can be quickly written down easily and fast
Spontaneous ideas can be captured immediately
No need to open a laptop for quick captures
The tactile experience helps with memory and processing

Digital Organization with ORG Mode

While embracing analog tools, I've also refined my digital organization using ORG mode in Emacs. The system has evolved to become more structured and efficient.

* PROJ Project 1
  * Tasks
    * TODO Do this and that
  * Resources
* PROJ Project 2
  * Tasks
    * TODO Do something else
  * Resources

Code Snippet 1:
Project structure in ORG mode

This structure provides a clear separation between active tasks and reference materials, making it easier to focus on what needs to be done while keeping relevant resources readily accessible.

Habits

2024 marked a significant shift in how I approach habit tracking and personal development. While previous years were characterized by meticulous tracking using Loop Habit Tracker, this year I found myself gravitating towards a more intuitive approach.

Sports

The year started with ambitious goals - I aimed to engage in sports twice weekly and incorporate 20-minute daily exercise sessions. Reality, however, had different plans. The transition from a 30-hour to a 40-hour work week significantly impacted my exercise routine.

👉 Garmin Forerunner 55 - Small and very handy

Reading

My reading habit remains strong, though I've moved away from strict tracking. Goodreads continues to serve as my primary platform for keeping track of books, while the Libby App remains invaluable for accessing e-books and audiobooks.

👉 Managing library loans through Libby

Software I Use

Inspired by Software Tools I use, I thought I'll also start mentioning my tools I use daily for work and personally. This year I've continued to refine my digital toolkit, focusing on tools that enhance productivity while maintaining simplicity and efficiency in my workflows.

Daily Drivers

Emacs

Yes, of course. I've decided to go down the Emacs rabbit-hole and have thoroughly "Emacsified" my workflows. While I'm fully aware of spending perhaps too much time tweaking my configuration, the result is a system that perfectly aligns with my needs and working style. A significant milestone this year was transitioning to a fully vanilla setup, giving me complete control over my configuration.

Alfred

Being on a Mac, I found myself returning to Alfred. Its snippet management and clipboard functionality have become indispensable parts of my daily workflow.

Claude AI

Claude has evolved into my virtual assistant for practically everything:

Coding assistance
Text summarization
Recipe collection
General writing assistance

👉 Organize topic specific conversations into projects

👉 Claude AI artifacts for different projects

As a premium user, I work directly with the interface rather than the API. While I occasionally use Ollama (integrated into Emacs via gptel), Claude remains my primary AI assistant.

Syncthing

As an ORG mode power user, synchronizing my files between devices is crucial. Syncthing elegantly handles this task, enabling seamless sync between:

Multiple laptops
Android smartphone
Various ORG mode files and notes

It's particularly useful for processing smartphone-collected notes and links on my laptop later.

Sports

Garmin Forerunner 55

👉 Small and very handy sports watch that perfectly meets my needs

GymRun

This app's integration with my Garmin watch has transformed my workout experience:

Create custom routines/workouts
Start workouts directly from the watch
Train without smartphone dependency
Eliminate decision fatigue before workouts

👉 GymRun app on the Garmin watch

👉 GymRun workout overview on Android

Services

Overdrive / Libbyapp

An invaluable resource that I can't praise enough:

Integration with local library membership
Access to vast e-book and audiobook collections
Magazine and newspaper availability
Waitlist system for popular titles

👉 Managing loans through Libby

Goodreads

The kind of social media we need more of:

Book discovery platform
Reading progress tracking
Community reviews and recommendations

Applications

F-Droid
- An open source app store which contains applications, many of which are not available on the Play Store
- Unlike Google Play Store, F-Droid does not track user activity or collect data
AntennaPod
- It's open source
- This is my main driver for listening to podcasts
- It has a very intuitive UI

👉 AntennaPod favorite podcasts

👉 AntennaPod listening statistics

PipePipe
- Allows you to access Youtube videos
- You can play videos in the background (@Google: When do you finally acknowledge people don't want to see silly ads?)
- But the killer feature is still: download videos
- I often do this to learn new Conga/Bongos patterns
- It's way easier to learn this way rather than coming back again and again to Youtube

👉 Video download functionality in PipePipe

ABMT Music Trainer
- This app allows you to play local music/video files and create cue points, loops
- This way you can easily jump to a certain point in the file
- Very useful for jumping to specific portions of a video if you want to learn something
- I use it often to break down specific parts of a percussion pattern and play them individually

👉 Creating cue points in ABMT Music Trainer

Infinity (reddit client)
- If you use reddit a lot this app offers you the most seamless experience
- You can customize your feed with filters, themes and more to tailor your reading experience
- No ads!
- What I like most is the "Hide Read Posts" which allows you to easily check new posts (no infinite scrolling anymore)

Devices

Yubikey 5 NFC

While not software per se, this tool is central to my digital security:

Primary use as a smartcard for encryption/decryption and signing
- Encrypt/Decrypt ORG mode files
- Sign git commits
- Store authentication keys (e.g. for SSH)
GPG agent proxying capability
- Access to emails on remote machines
- No need to copy GPG keys to remote systems

Looking Back, Moving Forward

The evolution in my approach to productivity and habits reflects a broader theme this year - finding balance between structure and flexibility. Moving away from rigid tracking towards more intuitive systems hasn't meant losing focus; rather, it has allowed these habits to naturally integrate into daily life.

My musical journey with percussion has added an entirely new dimension to my life, proving that growth doesn't always have to be technical or career-focused. The rhythm and joy of playing congas and bongos has become a welcome counterpoint to the digital world.

Looking ahead to 2025, I'm excited about the possibilities that lie ahead - from deepening my Kubernetes knowledge to mastering new rhythms on the congas. But perhaps more importantly, I'm grateful for the community of people who have been part of this journey, sharing knowledge, experiences, and moments of joy along the way.

As always, these reviews serve not just as personal milestones, but as reminders of how we grow through both the challenges we face and the opportunities we embrace. Here's to another year of learning, creating, and growing together.

Mastering Golang Debugging in Emacs

Victor Dorneanu — Fri, 29 Nov 2024 10:48:53 +0000

Introduction

Since I've started developing in Golang I didn't really use the debugger. Instead I was naively adding fmt.Print statements everywhere to validate my code 🙈. While print statements and logs might be also your first debugging instinct, they often fall short when dealing with large and complex code base, with sophisticated runtime behaviour and (of course!) complex concurrency issues that seem impossible to reproduce.

After starting working on more complex projects (like this one: https://github.com/cloudoperators/heureka) I had to force myself to have a deeper look at delve (the Golang debugger) and see what Emacs offers for interacting with it. While the Go ecosystem offers excellent debugging tools, integrating them into a comfortable development workflow can be challenging.

In this post I'll elaborate the powerful combination of Emacs, Delve, and dape. Together, these tools create a debugging experience that mimics (and often surpasses) traditional IDEs, while preserving the flexibility and extensibility that Emacs is famous for.

This is what you can expect:

Set up and configure Delve with dape
Debug both standard applications and Ginkgo tests (this is what I'm using at the moment 🤷)
Optimize your debugging workflow with Emacs specific customizations

Setting Up the Development Environment

In this post I assume you already have some Emacs experience and now how to configure packages and write small Elisp snippets. I personally use straight.el as a package manager, minimal-emacs.d as a minimal vanilla Emacs configuration (along with my own custommizations), dape as the debug adapter client and eglot as my LSP client.

Required Emacs Packages

For Emacs 29+ users, eglot is built-in. Check out configuring eglot for gopls and some more advanced gopls settings. We'll first add dape:

(use-package dape
  :straight t
  :config
  ;; Pulse source line (performance hit)
  (add-hook 'dape-display-source-hook 'pulse-momentary-highlight-one-line)

  ;; To not display info and/or buffers on startup
  ;; (remove-hook 'dape-start-hook 'dape-info)
  (remove-hook 'dape-start-hook 'dape-repl))

And go-mode:

(use-package go-mode
  :straight t
  :mode "\\.go\\'"
  :hook ((before-save . gofmt-before-save))
  :bind (:map go-mode-map
              ("M-?" . godoc-at-point)
              ("M-." . xref-find-definitions)
              ("M-_" . xref-find-references)
              ;; ("M-*" . pop-tag-mark) ;; Jump back after godef-jump
              ("C-c m r" . go-run))
  :custom
  (gofmt-command "goimports"))

Installing Required Go Tools

Install Delve and gopls, the LSP server:

# Install Delve
go install github.com/go-delve/delve/cmd/dlv@latest

# Install gopls
go install golang.org/x/tools/gopls@latest

Additionally I have a bunch of other tools which I use from time to time:

go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
go install github.com/onsi/ginkgo/v2/ginkgo@latest

go install -v golang.org/x/tools/cmd/godoc@latest
go install -v golang.org/x/tools/cmd/goimports@latest
go install -v github.com/stamblerre/gocode@latest
go install -v golang.org/x/tools/cmd/gorename@latest
go install -v golang.org/x/tools/cmd/guru@latest
go install -v github.com/cweill/gotests/...@latest

go install -v github.com/davidrjenni/reftools/cmd/fillstruct@latest
go install -v github.com/fatih/gomodifytags@latest
go install -v github.com/godoctor/godoctor@latest
go install -v github.com/haya14busa/gopkgs/cmd/gopkgs@latest
go install -v github.com/josharian/impl@latest
go install -v github.com/rogpeppe/godef@latest

Then you need to configure the corresponding Emacs packages:

(use-package ginkgo
  :straight (:type git :host github :repo "garslo/ginkgo-mode")
  :init
  (setq ginkgo-use-pwd-as-test-dir t
        ginkgo-use-default-keys t))

(use-package gotest
  :straight t
  :after go-mode
  :bind (:map go-mode-map
              ("C-c t f" . go-test-current-file)
              ("C-c t t" . go-test-current-test)
              ("C-c t j" . go-test-current-project)
              ("C-c t b" . go-test-current-benchmark)
              ("C-c t c" . go-test-current-coverage)
              ("C-c t x" . go-run)))

(use-package go-guru
  :straight t
  :hook
  (go-mode . go-guru-hl-identifier-mode))

(use-package go-projectile
  :straight t
  :after (projectile go-mode))

(use-package flycheck-golangci-lint
  :straight t
  :hook
  (go-mode . flycheck-golangci-lint-setup))

(use-package go-eldoc
  :straight t
  :hook
  (go-mode . go-eldoc-setup))

(use-package go-tag
  :straight t
  :bind (:map go-mode-map
              ("C-c t a" . go-tag-add)
              ("C-c t r" . go-tag-remove))
  :init (setq go-tag-args (list "-transform" "camelcase")))

(use-package go-fill-struct
  :straight t)

(use-package go-impl
  :straight t)

(use-package go-playground
  :straight t)

Dape Configuration

There is no particular reason why I use dape instead of dap. When I was still using MinEmacs it was part of it and I just got used to it. As the documentation states:

Dape does not support launch.json files, if per project configuration is needed use dir-locals and dape-command.

Dape enhances ergonomics within the minibuffer by allowing users to modify or add PLIST entries to an existing configuration using options.

No magic, no special variables like ${workspaceFolder}. Instead, functions and variables are resolved before starting a new session.

Tries to envision how debug adapter configurations would be implemented in Emacs if vscode never existed.

If you ever worked with VSCode you already know that it uses a launch.json to store different debugging profiles:

{
    "name": "Launch file",
    "type": "go",
    "request": "launch",
    "mode": "auto",
    "program": "${file}"
}

You have different fields/properties which according to this page you can tweak in your debugging configuration:

Property	Description
name	Name for your configuration that appears in the drop down in the Debug viewlet
type	Always set to "go". This is used by VS Code to figure out which extension should be used for debugging your code
request	Either of `launch` or `attach`. Use `attach` when you want to attach to an already running process
mode	For launch requests, either of `auto`, `debug`, `remote`, `test`, `exec`. For attach requests, use either `local` or `remote`
program	Absolute path to the package or file to debug when in `debug` & `test` mode, or to the pre-built binary file to debug in `exec` mode
env	Environment variables to use when debugging. Example: `{ "ENVNAME": "ENVVALUE" }`
envFile	Absolute path to a file containing environment variable definitions
args	Array of command line arguments that will be passed to the program being debugged
showLog	Boolean indicating if logs from delve should be printed in the debug console
logOutput	Comma separated list of delve components for debug output
buildFlags	Build flags to be passed to the Go compiler
remotePath	Absolute path to the file being debugged on the remote machine
processId	ID of the process that needs debugging (for `attach` request with `local` mode)

Sample Application

Now let's put our knowledge into practice by debugging a real application implementing a REST API.

Project Structure

Our example is a REST API for task management with the following structure:

taskapi/
├── go.mod
├── go.sum
├── main.go
├── task_store.go
└── task_test.go

Core Components

Let's have a look at the core components.

The Task represents our core domain model:

import (
    "fmt"
)

type Task struct {
    ID          int    `json:"id"`
    Title       string `json:"title"`
    Description string `json:"description"`
    Done        bool   `json:"done"`
}

The TaskStore handles our in-memory data operations:

type TaskStore struct {
    tasks  map[int]Task
    nextID int
}

func NewTaskStore() *TaskStore {
    return &TaskStore{
        tasks:  make(map[int]Task),
        nextID: 1,
    }
}

REST API

The API exposes following endpoints:

POST /task/create - Creates a new task
GET /task/get?id=<id> - Retrieves a task by ID

// CreateTask stores a given Task internally
func (ts *TaskStore) CreateTask(task Task) Task {
    task.ID = ts.nextID
    ts.tasks[task.ID] = task
    ts.nextID++
    return task
}

// GetTask retrieves a Task by ID
func (ts *TaskStore) GetTask(id int) (Task, error) {
    task, exists := ts.tasks[id]
    if !exists {
        return Task{}, fmt.Errorf("task with id %d not found", id)
    }
    return task, nil
}

// UpdateTask updates task ID with a new Task object
func (ts *TaskStore) UpdateTask(id int, task Task) error {
    if _, exists := ts.tasks[id]; !exists {
        return fmt.Errorf("task with id %d not found", id)
    }
    task.ID = id
    ts.tasks[id] = task
    return nil
}

Server

Here's the server implementation:

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

// Server implements a web application for managing tasks
type Server struct {
    store *TaskStore
}

func (s *Server) handleCreateTask(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
    var task Task
    if err := json.NewDecoder(r.Body).Decode(&task); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    createdTask := s.store.CreateTask(task)
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(createdTask)
}

func (s *Server) handleGetTask(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
    id := 0
    fmt.Sscanf(r.URL.Query().Get("id"), "%d", &id)

    task, err := s.store.GetTask(id)
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(task)
}

Let's look at our main function:

package main

import (
    "log"
    "net/http"
)

func main() {
    store := NewTaskStore()
    server := &Server{store: store}
    http.HandleFunc("/task/create", server.handleCreateTask)
    http.HandleFunc("/task/get", server.handleGetTask)

    log.Printf("Starting server on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Build application

Let's start the server:

go build -o taskapi *.go
./taskapi
2024/11/14 07:03:48 Starting server on :8080

Now from a different terminal create a new task:

curl -X POST -s http://localhost:8080/task/create \
-H "Content-Type: application/json" \
-d '{"title":"Learn Debugging","description":"Master Emacs debugging with dape","done":false}'

Response:

{"id":3,"title":"Learn Debugging","description":"Master Emacs debugging with dape","done":false}

Let's see if we can fetch it:

curl -X GET -s "http://localhost:8080/task/get?id=1"

Response:

{"id":1,"title":"Learn Debugging","description":"Master Emacs debugging with dape","done":false}

Unit tests

Below are some unit tests (written in Ginkgo) for the TaskStore:

package main
import (
    "bytes"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    "testing"
)

func TestTasks(t *testing.T) {
    RegisterFailHandler(Fail)
    RunSpecs(t, "Task API Suite")
}

var _ = Describe("Task API", func() {
    var (
        store  *TaskStore
        server *Server
    )
    BeforeEach(func() {
        store = NewTaskStore()
        server = &Server{store: store}
    })

    Describe("POST /task/create", func() {
        Context("when creating a new task", func() {
            It("should create and return a task with an ID", func() {
                task := Task{
                    Title:       "Test Task",
                    Description: "Test Description",
                    Done:        false,
                }

                payload, err := json.Marshal(task)
                Expect(err).NotTo(HaveOccurred())

                req := httptest.NewRequest(http.MethodPost, "/task/create",
                    bytes.NewBuffer(payload))
                w := httptest.NewRecorder()

                server.handleCreateTask(w, req)

                Expect(w.Code).To(Equal(http.StatusOK))

                var response Task
                err = json.NewDecoder(w.Body).Decode(&response)
                Expect(err).NotTo(HaveOccurred())
                Expect(response.ID).To(Equal(1))
                Expect(response.Title).To(Equal("Test Task"))
            })

            It("should handle invalid JSON payload", func() {
                req := httptest.NewRequest(http.MethodPost, "/task/create",
                    bytes.NewBufferString("invalid json"))
                w := httptest.NewRecorder()

                server.handleCreateTask(w, req)

                Expect(w.Code).To(Equal(http.StatusBadRequest))
            })
        })
    })

    Describe("GET /task/get", func() {
        Context("when fetching an existing task", func() {
            var createdTask Task

            BeforeEach(func() {
                task := Task{
                    Title:       "Test Task",
                    Description: "Test Description",
                    Done:        false,
                }
                createdTask = store.CreateTask(task)
            })

            It("should return the correct task", func() {
                req := httptest.NewRequest(http.MethodGet, "/task/get?id=1", nil)
                w := httptest.NewRecorder()

                server.handleGetTask(w, req)

                Expect(w.Code).To(Equal(http.StatusOK))

                var response Task
                err := json.NewDecoder(w.Body).Decode(&response)
                Expect(err).NotTo(HaveOccurred())
                Expect(response).To(Equal(createdTask))
            })
        })

        Context("when fetching a non-existent task", func() {
            It("should return a 404 error", func() {
                req := httptest.NewRequest(http.MethodGet, "/task/get?id=999", nil)
                w := httptest.NewRecorder()

                server.handleGetTask(w, req)

                Expect(w.Code).To(Equal(http.StatusNotFound))
            })
        })

        Context("when using invalid task ID", func() {
            It("should handle non-numeric ID gracefully", func() {
                req := httptest.NewRequest(http.MethodGet, "/task/get?id=invalid", nil)
                w := httptest.NewRecorder()

                server.handleGetTask(w, req)

                Expect(w.Code).To(Equal(http.StatusNotFound))
            })
        })
    })
})

In Emacs I would then call ginkgo-run-this-container as shown in this screenshot:

Basic Debugging with Delve and Dape

In order to debug our Task API we have following approaches:

we can launch the application directly and debug it
we can attach to a running process
we can attach to a running debugging session

Here are the options for different request types:

request	mode	required	optional
launch	debug	program	dlvCwd, env, backend, args, cwd, buildFlags, output, noDebug
	test	program	dlvCwd, env, backend, args, cwd, buildFlags, output, noDebug
	exec	program	dlvCwd, env, backend, args, cwd, noDebug
	core	program, corefilePath	dlvCwd, env
	replay	traceDirPath	dlvCwd, env
attach	local	processId	backend
	remote

Profile 1: Launch application

Here's our first debugging profile for .dir-locals.el:

;; Profile 1: Launch application and start DAP server
(go-debug-taskapi
  modes (go-mode go-ts-mode)
  command "dlv"
  command-args ("dap" "--listen" "127.0.0.1:55878")
  command-cwd default-directory
  host "127.0.0.1"
  port 55878
  :request "launch"
  :mode "debug"
  :type "go"
  :showLog "true"
  :program ".")

💡 You may want to use a different value for command-cwd. In my case I wanted to start the debugger in a directory which currently is not a project. default-directory is a variable which holds the working directory for the current buffer you're currently in.

Start debugging:

Run dape-info to show debugging information

Create breakpoint using dape-breakpoint-toggle:

After starting the debugger with this profile, you should see in the dape-repl buffer:

Available Dape commands: debug, next, continue, pause, step, out, up, down, restart, kill, disconnect, quit
Empty input will rerun last command.

DAP server listening at: 127.0.0.1:55878
debugserver-@(#)PROGRAM:LLDB  PROJECT:lldb-1600.0.36.3
 for arm64.
Got a connection, launched process __debug_bin3666561508 (pid = 43984).
Type 'dlv help' for list of commands.

Note that we didn't specify any binary/file to debug (we had :program "." in .dir-locals.el). delve will automatically build the binary before it launches the application:

go build -gcflags=all="-N -l" .

Profile 2: Attach to an external debugger

Let's add a profile for connecting to an existing debugging session:

;; Profile 2: Attach to external debugger
(go-attach-taskapi
 modes (go-mode go-ts-mode)
 command "dlv"
 command-cwd default-directory
 host "127.0.0.1"   ;; can also be skipped
 port 55878
 :request "attach"  ;; this will run "dlv attach ..."
 :mode "remote"     ;; connect to a running debugger session
 :type "go"
 :showLog "true")

Now let's start the debugger on the CLI:

$ go build -gcflags=all="-N -l" -o taskapi .
$ dlv debug taskapi --listen=localhost:55878 --headless
API server listening at: 127.0.0.1:55878
debugserver-@(#)PROGRAM:LLDB  PROJECT:lldb-1600.0.36.3
 for arm64.
Got a connection, launched process __debug_bin794004190 (pid = 23979).

Now within Emacs you can launch dape and select the go-attach-taskapi profile:

Profile 3: Attach to a running process

In this scenario the application is already running but you want to attach the debugger to it. First launch the application:

$ ./taskapi
2024/11/20 06:34:29 Starting server on :8080

Find out its process ID (PID):

ps -A | grep -m1 taskapi | awk '{print $1}'

Let's add another debug profile:

;; Profile 3: Attach to running process (by PID)
(go-attach-pid
 modes (go-mode go-ts-mode)
 command "dlv"
 command-args ("dap" "--listen" "127.0.0.1:55878" "--log")
 command-cwd default-directory
 host "127.0.0.1"
 port 55878
 :request "attach"
 :mode "local"      ;; Attach to a running process local to the server
 :type "go"
 :processId (+get-process-id-by-name "taskapi")
 :showLog "true")

We'll need a helper function:

;; Add helpful function
(eval . (progn
          (defun +get-process-id-by-name (process-name)
            "Return the process ID of a process specified by PROCESS-NAME. Works on Unix-like systems (Linux, MacOS)."
            (interactive)
            (let ((pid nil))
              (cond
               ((memq system-type '(gnu/linux darwin))
                (setq pid (shell-command-to-string
                           (format "pgrep -f %s"
                                   (shell-quote-argument process-name)))))
               (t
                (error "Unsupported system type: %s" system-type)))

              ;; Clean up the output and return first PID
              (when (and pid (not (string-empty-p pid)))
                (car (split-string pid "\n" t)))))))

Now I start the debugger:

If I now send a POST request like this one:

curl -X POST -s http://localhost:8080/task/create \
-H "Content-Type: application/json" \
-d '{"title":"Learn Debugging","description":"Master Emacs debugging with dape","done":false}'

The debugger should automatically halt at the set breakpoint:

Debugging Ginkgo Tests

Being able to debug tests in Golang is crucial. For running ginkgo tests I use ginkgo-mode which has several features:

And as an output I get:

Running Suite: Task API Suite - /home/victor/repos/priv/blog/static/code/2024/emacs-golang-debugging
======================================================================================================
Random Seed: 1732600680

Will run 1 of 5 specs
•SSSS

Ran 1 of 5 Specs in 0.001 seconds
SUCCESS! -- 1 Passed | 0 Failed | 0 Pending | 4 Skipped
PASS

Ginkgo ran 1 suite in 1.481440083s
Test Suite Passed

Dape Configuration for Ginkgo

This is the basic configuration for debugging Ginkgo tests:

;; Profile 4: Debug Ginkgo tests
(go-test-ginkgo
 modes (go-mode go-ts-mode)
 command "dlv"
 command-args ("dap" "--listen" "127.0.0.1:55878" "--log")
 command-cwd default-directory
 host "127.0.0.1"
 port 55878
 :request "launch"
 :mode "test"      ;; Debug tests
 :type "go"
 :args ["-ginkgo.v" "-ginkgo.focus" "should create and return a task with an ID"]
 :program ".")

If I chose the go-test-ginkgo debug profile I should be able to debug the tests:

Now the configuration is quite static and therefore you cannot preselect the unit test / container. We need to somehow make the parameter -ginkgo.focus dynamic:

(defun my/dape-debug-ginkgo-focus (focus-string)
  "Start debugging Ginkgo tests with a specific focus string."
  (interactive "sEnter focus string: ")
  (make-local-variable 'dape-configs)  ; Make buffer-local copy of dape-configs
  (setq dape-configs
        (list
         `(debug-focused-test
           modes (go-mode)
           command "dlv"
           command-args ("dap" "--listen" "127.0.0.1:55878")
           command-cwd default-directory
           port 55878
           :request "launch"
           :name "Debug Focused Test"
           :mode "test"
           :program "."
           :args ["-ginkgo.v" "-ginkgo.focus" ,focus-string]))))

Afterwards If I have a look at the dape-configs variable I should see this value:

Value:
((debug-focused-test modes
                     (go-mode)
                     command "dlv" command-args
                     ("dap" "--listen" "127.0.0.1:55878")
                     command-cwd default-directory port 55878 :request "launch" :name "Debug Focused Test" :mode "test" :program "." :args
                     ["-ginkgo.v" "-ginkgo.focus" "when using invalid*"]))

After starting the debugger (with the debug-focused-test profile) in the dape-repl buffer I get:

Welcome to Dape REPL!
Available Dape commands: debug, next, continue, pause, step, out, up, down, restart, kill, disconnect, quit
Empty input will rerun last command.

DAP server listening at: 127.0.0.1:55878
debugserver-@(#)PROGRAM:LLDB  PROJECT:lldb-1600.0.39.3
 for arm64.
Got a connection, launched process /home/victor/repos/priv/blog/static/code/2024/emacs-golang-debugging/__debug_bin2799839715 (pid = 31882).
Type 'dlv help' for list of commands.
Running Suite: Task API Suite - /home/victor/repos/priv/blog/static/code/2024/emacs-golang-debugging
======================================================================================================
Random Seed: 1732685749

❶ Will run 1 of 5 specs
SSSS
------------------------------
❷ Task API GET /task/get when using invalid task ID should handle non-numeric ID gracefully
/home/victor/repos/priv/blog/static/code/2024/emacs-golang-debugging/task_store_test.go:108

💡Notice that just "1 of 5 specs" (❶) were ran, meaning that ginkgo only focussed on the container we have specified (❷).

Best Practices and Tips

Throughout my debugging experience, I have come to appreciate several best practices:

Use version control for debugging configurations
Maintain debug configurations in .dir-locals.el
Use meaningful names for configurations
Create project-specific debugging helper functions
Make customizations locally (buffer-specific)

Resources and References

Book summaries: May - September 2024

Victor Dorneanu — Wed, 16 Oct 2024 04:59:29 +0000

Keeping with the theme I’ve started a few months ago, here are my own book summaries for the books I’ve read between May and September this year.

Social Sciences and Psychology

📚 Lost Connections

👉 Lost Connections - Uncovering the Real Causes of Depression and the Unexpected Solutions by Johann Hari

After reading The Lonely Century last year, which opened my eyes to the increasing isolation in our lives, I was kind of motivated to read more on that topic. That’s how I’ve found out about Lost Connections which is an exploration of _depression_and its root causes.

The book introduces the concept of “disconnection” as a primary cause of depression. Hari outlines seven types of disconnection. He talks about disconnection from meaningful work,other people, meaningful values, childhood trauma, status and respect, the natural world_and from a _hopeful or secure future.

What I found particularly insightful was Hari’s exploration of ways to “reconnect.” These strategies offer paths to a more meaningful and enjoyable life, emphasizing our connections to others and reminding us that “humans are nature” already. This perspective adds a new dimension to my understanding of focus and attention, placing them within a broader context of human well-being and social connection.

👉 Read my notes

📚 Stolen Focus

👉 Stolen Focus - Why You Can’t Pay Attention - and How to Think Deeply Again by Johann Hari

After the impactful experience of reading Lost Connections I felt compelled to delve into another of Hari’s works. While “Lost Connections” explored depression and our daily micro-interactions with people and nature, “ Stolen Focus ” takes a more scientific, empirical approach to investigating various aspects of attention.

One concept that immediately struck me was James Willson ’s layered model of attention:

Spotlight attention (first layer):
Starlight attention (second layer):
Daylight attention (third layer):

As I continued reading, I was amazed by Hari’s comprehensive approach to the attention crisis. He doesn’t just point to the usual suspects like increasing screen time and social media usage. Instead, he adds a more nuanced picture of our changing relationship with information and mental states. Therefore here are some aspects which lead to the deterioration of our ability to focus and pay attention:

The decline of book reading
The loss of mind-wandering
The state of constant skimming

These insights have made me reconsider not just how I manage my attention, but how I conceptualize it. It’s clear that reclaiming our focus isn’t just about reducing screen time or blocking distractions – it’s about fundamentally restructuring how we engage with information and allow our minds to work.

👉 Read my notes

History and Anthropology

📚 Sapiens

👉 Sapiens - A Brief History of Humankind by Yuval Noah Harari

After becoming a Harari fan through “21 Lessons for the 21st Century” I was eager to dive into “ Sapiens ”. I consumed both books as audiobooks, each one quite long. While the audio format was convenient, I found myself wishing for a physical or e-book copy to take notes. The depth and breadth of Harari’s books make me think I’ll likely revisit these books in the future for a more in-depth study.

In a nutshell “Sapiens” is about how Homo sapiens came to dominate the planet. Harari talks about the story of our species’ rise, from outcompeting other human species (like Neanderthals) to our impact on the animal kingdom, including the extinction of many species through hunting. This narrative is a very interesting look at our species' historical impact on the planet.

Despite some criticism (I’ve had some serious discussions with my mother, who strongly dislikes Harari), I believe the author does an excellent job explaining the evolution of fundamental human developments like writing and reading. He delves into the motivations behind these advancements, providing insights into why and how they occurred.

What I particularly appreciate about “Sapiens” is its interdisciplinary approach (I guess this applies to all of his books). Harari touches on various aspects of human development, including religion, economy, sociology, and politics. This comprehensive view offers readers a deeper understanding of the society we currently live in, explaining the origins of our laws and different political systems.

A key takeaway from the book, which resonates with thoughts I’ve encountered in other sources, is Harari’s explanation of what distinguishes Homo sapiens from other species:

Our ability to collaborate collectively towards a common goal.
Our capacity for abstract thought and storytelling, which has been the foundation for countless innovations. As Harari points out, everything ever built started as someone’s imagination - an idea also explored by Sir Ken Robinson in “Imagine If”
The development of language (both written and spoken), which allowed us to exchange information (across borders and generations).

These unique aspects have allowed our species to create complex societies, develop_advanced technologies_, and ultimately shape the world as we know it today. I highly recommend “Sapiens” to anyone interested in gaining a deeper understanding of human history. While it may challenge some preconceptions, it offers a thought-provoking journey through the history of our species that I found both enlightening and engaging.

Sociology and Current Affairs

📚 Triggerpunkte (Trigger Points)

👉 Triggerpunkte - Konsens und Konflikt in der Gegenwartsgesellschaft

In the context of Europe’s (and beyond) current political landscape, marked by a noticeable right-wing shift, “ Triggerpunkte ” offers a insightful analysis of_societal tensions_ in Germany. As someone who doesn’t consider himself politically active, I found myself increasingly concerned about the polarized and extreme nature of political discourse in Germany. The rise of the AfD to a level of influence that seemed unthinkable just a few years ago exemplifies this shift.

“Triggerpunkte” presents the findings of a team of sociologists (Steffen Mau, Thomas Lux, Linus Westheuser) who conducted empirical research across Germany. What struck me about their approach was the diversity of theirsubject groups:

Participants came from various “political classes”
They represented different professions (teachers, handymen, business people, etc.)
The study included people from both East and West Germany

The researchers posed questions on controversed issues such as immigration,climate change, LGBTQ+ inclusion, and income inequality in Germany. By measuring emotional responses, they identified topics with high conflict potential across different groups. They also explored correlations between people’s arguments and factors like educational background, political affiliation, income, age, and origin.

This book had a profound impact on me. It helped me understand the frustrations many people have with the current German government, their fears about the_impact_ of climate change countermeasures, and why some perceive immigrants as a significant threat. These insights are crucial for anyone trying to comprehend the current political dynamics in Germany.

One of the most reassuringfindingsfrom the study, in my opinion, was that overall, German society maintains:

A positive stance towards welcoming immigration policies
Support for better climate protection
A generally non-homophobic attitude

However, the study also revealed a small group of individuals(Polarisierungsunternehmer), some with political interests, propagate extreme arguments. These actors attempt to influence mass media perception through fake news and whataboutism, aiming to create more cleavages within the society. The authors’ discussion of thesecleavages was particularly enlightening.

Reading “Triggerpunkte” has given me a more nuanced understanding of the complex social and political landscape in contemporary Germany. It’s a crucial read for anyone seeking to understand the underlying factors driving current political trends, not just in Germany but potentially in other countries facing similar challenges.

👉 Read my notes

Health and Psychology

📚 When the Body Says No

👉 When the Body Says No: The Cost of Hidden Stress (by Gabor Mate)

My journey to Gabor Maté’s work began with an interview I stumbled upon between Maté and Guy Rose, host of “London Real”. I was immediately captivated by Maté’s clear and profound explanations on various aspects of trauma, which prompted me to delve into his book, “When the Body Says No”.

At the core of Maté’s argument is the inseparability of body, soul, and mind - a holistic view that challenges conventional medical approaches. Throughout the book, Maté presents case studies from his medical practice, illustrating how physical pains often have roots in (childhood) trauma that manifest as chronic stress within patients.

One of the most enlightening aspects of the book is Maté’s exploration of_stress_, drawing on the work of Hans Selye. Maté uses Selye’s definition to provide a comprehensive understanding of stress and its various facets:

In searching for a word to capture the meaning of the physical changes he observed in his experiments, Selye “stumbled upon the term stress, which had long been used in common English, and particularly in engineering, to denote the effects of a force acting against a resistance.” He gives the example of changes induced in a stretched rubber band or in a steel spring under pressure. These changes may be noted with the naked eye or may be evident only on microscopic examination.

Selye’s analogies illustrate an important point: excessive stress occurs when the demands made on an organism exceed that organism’s reasonable capacities to fulfill them. The rubber band snaps, the spring becomes deformed. The stress response can be set off by physical damage, either by infection or injury. It can also be triggered by emotional trauma or just by the threat of such trauma, even if purely imaginary. Physiological stress responses can be evoked when the threat is outside conscious awareness or even when the individual may believe himself to be stressed in a “good” way.

This definition of stress provides a crucial framework for understanding how emotional and psychological experiences can manifest in physical symptoms. It underscores Maté’s central thesis that our mental and emotional states have profound impacts on our physical health.

Maté’s work challenges us to consider the long-term health implications of our emotional experiences and the importance of addressing psychological well-being as a key component of overall health.

Bye Bye Cashlink!

Victor Dorneanu — Thu, 11 Jul 2024 07:12:32 +0000

In the midst of the Corona pandemic back in 2021, I joined the team at Cashlink, a company focused on tokenization and digital securities. With little understanding of these concepts, I embarked on this new journey as a Senior Security Engineer within the TECH team. Promised a greenfield environment, I stepped into the unknown, excited yet uncertain about what I was expected to to.

As I look back on almost three years of knowledge sharing at Cashlink, I realize just how much I’ve learned. Embracing one of Cashlink’s core values, I consistently strived to challenge the status quo. Throughout this journey, I’ve gained a deep understanding of what DevSecOps truly is about, with a particular focus on the operational side.

Having said this, I’m looking forward to my newest challenge, where I’ll switch focus to the Dev part in DevSecOps and delve deeper into software engineering, but still within the Security context. I also anticipate doing more coding, particularly in Golang, which kind of makes me happy. I remain grateful for all that I’ve experienced and learned at Cashlink and hope to see you all soon again, whether in Frankfurt, Cluj, or Berlin!

What I’ve learned

As I was implementing security in the greenfield area, I had the chance to strengthen my knowledge in specific areas but also deep-dive into new ones.

AWS
IAM (as a concept)
K8s
Smart Contract Security

Shoutout to

Cashlink Team
- A 💗 thanks to everyone I had the opportunity to meet, for all the conversations we shared, and the lively kicker sessions we enjoyed in Frankfurt. Last but not least, thank you for welcoming me in Cluj, where I had the chance to say “goodbye” in person to (almost) all of you!
Verena
- Thank you for your kindness and patience in just listening and guiding me through some difficult times in my life. See you soon in Berlin!
Dragos
- You might not be able to read this as you’re on your trip on the Via Transilvanica. I hope you’ll finish your tour and come back full of energy. Also thanks for our coffee sessions, our discussions and sometimes for some good advice whenever something didn’t go smooth. Let’s do that 🏰 thing again, once we turn 50! 🤎
Mariano
- You were right! Our first discussion back in Frankfurt was about working in full-remote and the fact I still need a community / colleagues around me. You remembered that when we met in Cluj this year! I really enjoyed our discussoin around nutrition, sports and life in general. Take care and see you end of August 😋
Aron
- Thanks for your patience and for the fact you were the one to teach me K8s! Let’s keep in touch and conquer the world with Golang, Terraform and Kubernetes. I also wish you all the best with your climbing career 🧗
Maik
- Let’s go to Aventura, right? I guess we both won’t forget that evening. I wish you all the best becoming a 🇧🇬 and let’s do the Moldova trip soon again.
Anca
- I admire you for your discipline and perseverance! I hope to see you someday at the Olympics 🏃
George
- “Who’s Rosa?” 🤣 I really enjoyed our discussion lately in Cluj! I hope you’ll find your place and get rich soon 😎
Rafael
- I’m glad I’ve convinced you to buy a La Pavoni. You definitely have reached nerd level 500 with all the mods and customizations 😎. I’m still looking forward meeting your home roaster.
Yubikey Gang
- Without mentioning any names, y’all know: It was RDCSLY fun spending time with you 🫶

Book summaries: January - April 2024

Victor Dorneanu — Sun, 05 May 2024 18:03:02 +0000

Inspired by Eli Bendersky's book reviews, here are my summaries for the books I've read
between January and April 2024.

📚 Think Again: The Power of Knowing What You Don't Know by Adam Grant

I've received this book shortly after reading The Scout Mindset where I learned about the soldier vs scout mindset where the later one can be shortly described in one quote:

“Your strength as a scout is in your ability… to think in shades of gray instead of black and white.”

Think again is more about different types of thinking (the preacher, the prosecutor, the politian and the scientist) and their main characteristics. I also learned that a debate is more like a dance where the choreography between the partners has not been negotiated yet. Each one has his own steps in mind but professional debators know how to "end up in rhythm" with their partners. Adam Grant also gives concrete advice how to learn to develop the habit of thinking again and revising your own beliefs.

👉 Read my notes
📚 The Startup CTO's Handbook: Essential skills and best practices for high performing engineering teams by Zach Goldberg

This is a comprehensive guide for CTOs and technical leaders in startup companies. It covers a wide range of essential topics for these people including technical leadership, team building, technology choices, infrastructure, technical debt. It also gives advice how to master the startup growth, have a fast hiring process, how to retain talent and how to scale technology infrastructure to meet increasing demands.

Although I didn't know what to expect, for my taste it was too high-level. However, I liked the chapter about the technical debt and its seven types. I also first learned about DX (Developer Experience) which refers to tools & processes to make it easy to "have highly reliable and reproducible environments and dependency chains".

👉 Read my notes
📚 Company Of One: Why Staying Small Is the Next Big Thing for Business by Paul Jarvis

I remember Cal Newport once mentioned this book in one of his episodes (this is how I got to read this book). In "Company of One," the capitalistic credo of (continuous) growth is questioned. Instead, "companies of one" should intentionally stay small. The main focus here is not the competitor's growth but rather focusing on customer relationships and their own success. According to Paul Jarvis, if you're focusing on growth, growth will happen. If you, however, want long-term customers and sales, you should focus on your few customers and their needs. There is absolutely no need for infinite growth just for the sake of getting bigger.

👉 Read my notes
📚 The Minimalist Entrepreneur: How Great Founders Do More with Less by Sahil Lavingia

If you know Gumroad then you probably also know about Sahil Lavingia who got by this essay. Compared to the previous books on entrepreneurship, this focused more on the community for which you want to build products. Sahil emphasized the crucial part of identifying your ideal customers and building solutions for their needs. Once you figured out your potential customers, it's time to find out if they're willing to pay for your solutions:

"A business is a way to solve problems for people your care about - and get paid for it."

The author also suggests you first become a creator and then an entrepreneuer. This way you should make sure your creativity is unleashed in order to create the best solutions for your business.

👉 Read my notes
📚 Lost Connections: Uncovering the Real Causes of Depression - and the Unexpected Solutions by Johann Hari

After having heard a lot about depression, its chemical root causes, the effects on humans in Andrew Huberman's podcast I was more than determined to read this book. Himself having to deal with depression, Johann Hari takes a journey to find out more about the mental illness that caused him to take pills (a la Prozac) and soon to find out they weren't a long-term solution. What if depression was not solely caused by some "imbalance of serotonin" in your brain? What if depression was merely a mix of environmental factors, childhood traumata, and predisposition (genes) to some behavioral patterns?

Hari comes up with 9 causes for depression: Disconnection from 1) meaningful work, 2) from other people, 3) from meaningful values, 4) childhood traume, 5) from status and respect, 6) from the natural world, 7) from a hopeful and secure future and finally 9) role of genes and brain changes. To quote the author, we all need to reconnect again:

You aren’t a machine with broken parts. You are an animal whose needs are not being met. You need to have a community. You need to have meaningful values, not the junk values you’ve been pumped full of all your life, telling you happiness comes through money and buying objects. You need to have meaningful work. You need the natural world. You need to feel you are respected. You need a secure future. You need connections to all these things. You need to release any shame you might feel for having been mistreated.

👉 Read my notes
📚 Sapiens: A Brief History of Humankind by Yuval Noah Harari

During the pandemic, a friend of mine recommended Harari to me and last year I read 21 Lessons for the 21st Century by the same author. His thoughts immediately resonated with me so I (chronologically backwards) started to read his other masterpieces.

From time to time, there has been some criticism about Harari and his criticism of today's humankind. Nevertheless, I think the book is an excellent journey of how homo sapiens managed to dominate the world, organize in groups, come up with financial, economic, and political systems. For me, it has been an extraordinary time travel which made me understand our world's mechanics.
📚 Stolen Focus: Why You Can't Pay Attention - and How to Think Deeply Again by Johann Hari

Ever since I've read about the Attention Economy (first in Digital Minimalism) I knew there is a whole (social media) industry whose main purpose is to monetize our time spent on their platforms. The more time we spend, the more ads can be shown, the more money can be generated.

But this is just one reason we cannot focus anymore. Among the increased amount of information our brain has to deal with every day, technology that uses insights from behavioral psychology to capture your attention, the collapse of sustained reading (books!) the Hari makes an interesting point:

So we aren’t just facing a crisis of lost spotlight focus – we are facing a crisis of lost mind-wandering.

Not only have we lost our ability to focus for a longer period of time, but we also no longer allow our minds to wander, which is crucial.

[...] rapidly switching between tasks, and I realised that in our current
culture, most of the time we’re not focusing, but we’re not mind-wandering
either. We’re constantly skimming, in an unsatisfying whirr.

👉 Read my notes

Some other small books:

📚 Domain-Driven Design Quickly by Floyd Marinescu

From Doom to Vanilla Emacs

Victor Dorneanu — Thu, 22 Feb 2024 18:58:33 +0000

Why vanilla?

Let's start with the most obvious question: What's wrong with Doom Emacs? Short answer: There is nothing wrong with Doom Emacs. I still use it and I still recommend it for beginners. Some years ago I started with Spacemacs and moved to Doom which, in my humble opinion, is far faster and more stable. So if you're a novice and just entered the "church of Emacs" I strongly recommend you do NOT start with vanilla. I recommend Doom because:

it comes with batteries included
I like how you can exclude packages from your configuration
you don't have to get into heavy Elisp
there is a whole group of being taking care of bugs and making sure each release works properly

That said, I still wanted to go "vanilla," at least give it a try. My first attempt failed, mainly because I was trying to use someone's config without really understanding how it works. I also had some "hard requirements" for my configuration:

evil mode

I've used vim for more than 10 years and memorized vim like keybindings like my own pocket. Sometimes I find Emacs like keybindings to be more practical, though. That's why I wanted to have both.
literate config (using ORG mode)

I still don't consider myself efficient in writing Elisp code. For this reason, I wanted my configuration to be written in ORG mode (like most of my stuff available online) whose parts can be written (or tangled) to files (e.g. .el files) using org-babel.
modular

I wanted to group similar functionalities in the same ORG file. That's why I have a programming.org file which includes configuration for the programming languages I'm using. At the same time I wanted to easily disable parts of configuration by deleting the corresponding section or commenting it out (org-toggle-comment).

Of course, Org mode would then have its own file org.org 😎

Go vanilla

If you really decide to continue this journey, I'd like to share some tipps/workflow to make your process more smoothly.

Ever since I've started my Emacs journey it seemed like the wholy grail to have your own (vanilla!) configuration without any hard dependencies on frameworks like Doom or Spacemacs. There are plenty of dotemacs configurations ouf there which can serve as a great source of inspiration.

In my case, it was specifically this one which caught my attention: https://config.phundrak.com/emacs/. It had almost everything I needed, it was using evil mode and the whole configuration is written in ORG mode. Bingo!

Literate config

As a matter of preference I don't like Elisp based Emacs configurations. I find ORG mode and literate config to be more easy to read and understand what's going on.

You can have a basic structure in your ORG mode file, define sections, and use the outline functionality to jump to each section. You can then tangle the ORG file to generate the .el files to be loaded by Emacs. Having spent countless hours (and days) tweaking my configuration, reading others and trying to understand custom Elisp functions, I think I've reached a level where I exactly know which part of my config is responsible for some misbehavior. Other than that, I've found a structure that fits my needs and the way I want my configuration to be structured.

Basic structure

Your configuration should have a basic structure. You can either use a single file for the whole configuration or multiple ones. I prefer multiple ones because you can tangle each one individually and thus make the whole process faster. This is what I have inside my Emacs folder in my dotfiles:

emacs
├── basic-config.org
├── custom-elisp.org
├── index.org
├── keybinding-managers.org
├── keybindings.org
├── Makefile
├── package-manager.org
├── packages
│   ├── applications.org
│   ├── autocompletion.org
│   ├── editing.org
│   ├── helpful.org
│   ├── org.org
│   ├── programming.org
│   └── visual-config.org
└── tangle_script.sh

Basic structure of my Emacs configuration files

This structure is more or less copied from Phundrak's one which served as a really good starting point. Of course I stripped down each file to my needs.

The point is that each file would host a different set of customizations relevant to specific functionalities. If I want to change some keybindings I'd then go to keybindings.org and modify stuff. If I want to tweak the autocompletion for lsp-mode I'd then go to autocompletion.org.

Tangling

In Emacs and Org mode, tangling refers to the process of extracting code snippets from an ORG file and writing them to separate source code files. It usually allows you to maintain code and documentation in the same file while keeping them in sync. In my case I use it to generate Elisp code out of my ORG files.

👉 My ORG mode config

Automation

I like to automate most of the workflows and therefore I use a Makefile and some bash script for tangling all files:

# Phony target to tangle all org files
.PHONY: tangle
tangle:
    find . -name "*.org" -exec sh -c 'echo "[!] Tangling {}"; ./tangle_script.sh "{}"' \;

Makefile for my Emacs configuration

And this is the script I use to tangle one individual file:

#!/bin/bash

emacs -q --batch --eval "(require 'ob-tangle)" \
  --eval "(setq org-confirm-babel-evaluate nil)" \
  --eval "(org-babel-tangle-file \"$1\")"

The tangle script which takes an ORG file as an argument

Manually

I would like my overall configuration (at ~/.config/emacs) to be updated immediately whenever I change something in the Org mode files. Therefore I use .dir-locals.el to define this behaviour for all ORG mode files

;;; Directory Local Variables            -*- no-byte-compile: t -*-
;;; For more information see (info "(emacs) Directory Variables")

((org-mode . ((org-confirm-babel-evaluate . nil)
              (eval .
                    (progn
                      ;; Tangle whole file after being saved
                      (add-hook 'after-save-hook 'org-babel-tangle)
                      )))))

.dir-locals.el

First I don't want to be asked every time if I want to evaluate the source code blocks (that's why org-confirm-babel-evaluate is set to nil ). Secondly I want to automatically tangle the file whenever the file gets saved (org-babel-tangle in the after-save-hook).

This way every time I save one file, the Elisp code will be automatically be tangled to the corresponding file.

Inspirations

Sometimes I don't know exactly how to configure a package or which options I should be using. Instead of searching the web for the examples last year I came up with an idea: I started collecting interesting/useful dotfiles~/~dotemacs collections in a single place. You can find the repository at github.com/dorneanu/dotemacs. So what I usually do is to search inside the folder where I've cloned all repositories for specific keywords. For this purpose I use rg.el and some custom function:

(setq dotemacs-directory "/cs/priv/repos/dotemacs")
(rg-define-search my/rg-dotemacs
  :query ask
  :format regexp
  :files "everything"
  :dir dotemacs-directory
  :confirm prefix)

From the rg section in my dotemacs config

👉 Searching with rg

Conclusion

Checkout my dotfiles (which I manage using chezmoi) if you need some inspiration. If you have other tips on how to further improve my workflow or the overall structure, please drop me an email.

My 2023 review

Victor Dorneanu — Tue, 02 Jan 2024 21:23:30 +0000

I feel somewhat ashamed for not doing a review last year. However, this year I have set aside some time to reflect on the highlights of this year, what I have learned, the habits I have changed, and the habits I have stucked to. The following is my review for 2023, divided into several sections.

Books

This year I've finally reactivated my Goodreads profile primarily for getting book recommendations. Although I have my own TODO list for reading, which continues to grow each year, I'm always curious to see what others have read addtionally after finishing one book.

As always you can find my list of read books at brainfck.org/books where also this year I've added tags to the books and restructured the Hugo template to list them as well.

Instead of trying to summarize each book here are my 2023 recommendations for you:

#politics
- 📖 The Road to Unfreedom (by Timothy Snyder)
  
  I've read this book mainly because I wanted to know more about Eastern Europe politics and the on-going war in Ucraine. In his book Synder examines the historical and geopolitical aspects that have shaped the world recently, especially highlighting the actions of Russia and its impact on global politics. The book gives the readers insights into the strategies used by influential figures (philosophers, politicians etc.) to undermine democratic values, manipulate public opinion which all gave birth to authoritarianism and the erosion of democracy.
   
  Although this book offers a deep analysis of the Soviet and Russian politics, I think Snyder focussed to much on Russia's actions solely which could be interpreted as the primary influences of global authoritarianism, the war in Ucraine and fake-news.
   
  👉 My own notes (in Romanian)
   
#society
- 📖 Mother of Invention: How Good Ideas Get Ignored in an Economy Built for Men
  
  I've chosen this book to be in the top list because it somehow opened my eyes for all the gender biases and inequalities that already have existed in our society and in the economic world. The author has plenty of (historical) examples how women's ideas and contributions often are ignored and undervalues, despite their potential to drive innovation and progress. Also interesting: Job roles nowadays dominated mainly by men were some decades ago preserved for female workers (e.g. computer programming)
   
  As already mentioned by others, this book serves as a call to action, forcing society to address the structural and systemic biases that block women's participation and idea recognition in the economy.
   
  👉 My own notes (in German)
   
- 📖 The Lonely Century: How to Restore Human Connection in a World That's Pulling Apart
  
  The issue of loneliness and social disconnection is something I've been observing for years. Despite our inter-connected world with instant messaging at our finger tips and a constant influx of events all over the world, I think we (as human beings) are suffering from real human connections. Also this book serves as a wake-up call to address the isolation we're currently facing and provides strong arguments for building strong, more connected communities.
   
  👉 My book summary: The Lonely Century / My own notes (in Romanian)
   
- 📖 21 Lessons for the 21st Century
  
  I have still not processed all thoughts and ideas presented in this book. But if you decide to read this book, be prepared for a captivating journey into different topics such as technology, politics and religion. The book also focusses on the intersection of AI and humanity. Yuval Noah Harari explains the profound implications of AI, raising important questions about its impact on society and our individual lives. He explores the potential disruptions caused by automation and the potential challanges AI poses to human labor and employment. In this context the author emphasizes the importance of protecting human values (and forces) in an increasingly automated world.\
   
  After reading this book I was more than determined to find out more about the author's other publications (e.g. Sapiens: A Brief History of Humankind).
   
#health
- 📖 Exercised: Why Something We Never Evolved to Do Is Healthy and Rewarding
  
  In this book I've learned a lot about the role of exercise in our lives. The author challenges the conventional wisdom on exercise, emphasizing the importance of natural movement over high-effort exercises. He argues that our bodies are designed for normal, seasonal physical activity and that prioritizing activities like walking, running, dancing can have a profound impact on our health and well-being. Lieberman encourages people to rethink their relationship to exercise and fitness and therefore embrace the benefits of moving naturally, sitting less and engaging in full-body movements.
   
  👉 My own notes
   
#biography

The more books I read, the more I realize my affinity for reading (auto-)biographies. This way I can delve into the lives of remarkable individuals who had a profound impact on our world. It is through their accomplishments (and wisdom!) that I continue to cultivate my understanding of our shared human history. Here's my recommendation for 2023:
 
- 📖 Thirst: A Story of Redemption, Compassion, and a Mission to Bring Clean Water to the World
  
  This book kept my mind busy for a while, primarily due to one key reason: The undeniable connection between willpower and motivation. In "Thirst" Scott Harrison shares his personal transformation from a nightclub promoter to the founder of the nonprofit organization "Charity: Water" which aims to provide clean and safe drinking water to communities in need around the world. Along the way, Scott confronts personal challenges and navigates the complexities of the nonprofit world, sharing valuable lessons on resilience, empathy, and the power of collective action.
   
  Once you have finished reading the book, be sure to visit charitywater.org/thirst to access the additional digital content, including videos and pictures, that the author has prepared for you. It is truly remarkable and adds an extra layer of depth to the reading experience.

Productivity

I usually don't keep track of productivity tools and workflows, as everyone's needs are unique with regards to project / time / resources management. However, I'd like to share some "tools" that have changed the way I work and deal with new initiatives/projects.

Multi-Scale Planning

As a long time listener of Cal Newport's podcast of course I had the chance to learn more about his productivity hacks and tipps. Even more than his brilliant advice in Deep Work I've found Multi-Scale Planning to be a true game changer.

While I cannot cover all details (maybe I'll do so in a future post), the main idea is to do planning at multiple time scales such as quarterly/monthly, weekly and daily. Each scale has a different level of details as you move from one scale to another.

This approach to time management (because this is what it's about, right?) allowed me to plan in advance but also be flexible whenever something deviated from the initial plan. This way I was able to come up with some initiatives/projects for the next quarter/month and define small chunks of work I could do on a weekly/daily level.

👉 Planning using ORG mode

It is a very visual system that works well in a digital and analog world. No matter which fancy productivity tool you prefer, in the end it's all about the workflow and processes you implement in order to make consistent progress and contribute to your personal and professional growth.

👉 Weekly planning using an analogue planner

Track focus time

I've found deep work (as a state of mind) to be very dificult to achieve. Initially I thought I could train this skill while meditating. It did help to some degree but the true deep work killer gadget turned out to be ... my watch. I used my watch to setup a countdown (e.g. 1 hour) which always reminded I should be focussing whenever I've felt I was mind-wandering.

👉 Track focus time using a watch

Often I thought I was focussing for at least 30 minutes when in reality it was only 10 minutes. For me it was a strong indicator my mind was trying to fool me into jumping to other tasks, force me to procrastinate.

👉 Time tracker running

Train your visual focus

This is nothing new but still an advice ignored by many. We all know multi-tasking is bad for our attention (and therefore productivity) and to many context switches (switching between different tasks, jump to different windows on your PC) can significantly diminish your ability to focus on one thing.

Some months ago I was listening to Andrew Huberman's podcast on How to Focus to Change Your Brain where, simply put, he linked our ability to focus to visual focus.

He emphasizes that mental focus is closely tied to where and how we focus our eyes. Our visual system can either be unfocused or laser-focused, and this directly impacts our mental focus.

What's interesting and vitally important to understanding how to access neuroplasticity is
that you can use your visual focus, and you can increase your visual focus as a way of
increasing your mental focus focus abilities more broadly.

-- How to Focus to Change Your Brain (Youtube)

So, Huberman suggests that by sharpening visual focus, we can directly influence neuroplasticity which is our ability (or the brain's one) to adapt and learn new information. What's even more important is what exactly you focus on:

And the behavioral practices that are anchored in visual focus are going to be the ones that are going to allow you to develop great depth, and duration of focus. So let's think about visual focus for a second. When we focus on something visually, we have two options, we can either look at a very small region of space, with a lot of detail, and a lot of precision. Or we can dilate our gaze, and we can see big pieces of visual space with very little detail. It's a trade off, we can't look at everything at high resolution. This is why we have these the pupil more or less relates to the phobia of the eye, which is the area in which we have the most receptors, the highest density of receptors that perceive light. And so our acuity is much better in the center of our visual field than our periphery.
-- How to Focus to Change Your Brain (Youtube)

In a practical way Huberman advises practicing visual focus at the specific distance of one hand, like reading a book or looking at a screen. This means that reading books and therefore engaging your brain into cognitive tasks will definitely have an impact on your capacity to focus on a certain thing for longer periods of time.

At the same time (and this is my own interpretation) I think that keeping your eyes focused on a small region on the screen without further distractions (cat pics, gifs, 10 browser tabs opened) will have the same efect. Obviously I would not have writen this without making my own observations before.

What happened: The more I stick to one window on my laptop without having to switch between apps (e.g. open browser, open mail client) the more focussed I feel. Even if I have to do shallow work I try to remain in the same context/window. Just to give some examples:

I need to add more tasks to a project
- I just call my capturing system (org-capture in Emacs) to quickly write down a note
I need to lookup sth on the web
- From within Emacs I have multiple options:
  - Fire up Google search (using xwidget-webkit)
  - I can use built-in lookup mechanisms for searching
I need to check my mails
- I just open mu4e
I need to ask the AI lords
- I open chatgpt-shell

Some other screenshots:

👉 Lookup options in Emacs

👉 Different search engines in Emacs

👉 Open Google search from within Emacs while writing this article

👉 Use ChatGPT inside Emacs without jumping to an extra window

👉 Use multiple xwidget-webkit instances to read from multiple sources

Habits

This is where I track important activities in order to achieve personal goals but also to keep me motivated. I still use the Loop Habit Tracker on my smartphone.

Sports

2 years ago I've felt somehow embarassed about my sports related activities. That's why my overall goal was to do more sports, no matter what:

👉 Sports

I not only increased my sport activities noticeably, but I also managed to workout regularly (notice the line on Fridays where I usually go for bouldering).

👉 Bouldering in Berlin

Also this year I've surfed for the very first time.

👉 Surfing in Portugal

Reading

Overall I think this year I've read a lot, sometimes multiple books per month. Instead of buying books, I've extensively used the Libby App where you can also rent audio books from your local library. As I've mentioned before, I've also re-activated my Goodreads account where I usually keep track of books I'm currently reading.

👉 Reading

💡: Don't forget to check out my full bookshelf for 2023.

Goals

First of all a quick recap of my goals for 2022:

Learning

2 years ago I wrote I'd like to deep-dive more into TypeScript. I still didn't do anything complex in TS but from time to time I still use it (in combination with AWS CDK, like I did for the AWS custom resources project). I also don't expect this to change as for backend I'd still go for Golang (and work-wise I'm "forced" to use Python for small things).

Besides TypeScript I wanted to learn some Vue.JS. Back then I wrote:

I want to be able to build modern frontend applications and use new technologies beyond HTML, CSS and JavaScript :)

I did do some frontend but using different technologies: For implementing gocial I've mainly used Alpine.js and Tailwind CSS. I still have a course to do on Udemy (regarding Vue.JS) but I also need to find time to do it 🙈.

Among frontend stuff, I was more than motivated to finally learn more about Web3 (especially Ethereum). I did some coding in Solidity and also read Mastering Ethereum: Building Smart Contracts and DApps. Additionally I also learned more about Smart Contract Security (I hope to release my notes next year).
Reading

My reading list for 2022 was:
I managed to read Building Microservices(2nd edition), Mastering Ethereum and I definitely learned something about C4.

The rest is still on my TODO list.
Projects

Of course there were some ideas and projects I wanted to work on:
- finish access-key-rotator and release first version
- clean up my Zettelkasten
- start working on my book
  - about Golang and Security :)
Well, I did some clean-up on brainfck.org but this happens on a regular basis. access-key-rotator hasn't been changed since a while and I also did not manage to start working on the book about Golang and Security.

For 2024

For the up-coming year I'd like to focuss on several things. Continuing in the same scheme
I did for my past goals:

Learning
- Music
  
  Besides playing the Djembe this year I've started learning how to play the Bongos. With the help of ChatGPT I was able to read notes again and therefore play some easy to more advanced rhythms on the Bongos. Next year I'd like to keep practicing and get more insights into Latin rhythms (Salsa, Bachata, Merengue, Mambo, Rumba etc.)
  
  I have played an acoustic guitar for a while, although not with the same proficiency as I have with hand drums. For motivation, I would like to learn to play the electric guitar and make progress in live looping.

👉 Live looping with a pedal looper

Projects
- Play with HTMX and Golang
  
  I'd definitely love to do something front-end related and therefore I'd like to play a little bit with htmx. But first I need an idea for a small application. This way I plan to code again in Golang (this year I didn't manage to code anything useful).
- Security of Github repositories
  
  While dealing with Github and the security settings of repositories, I wanted to have a small tool at hand which will check for different settings (for each repository in an organization) and report (via Slack, E-Mail) if some settings are not
  compliant.
- Finish "Documentation as Code" series
  
  This year I've started writing about several documentation techniques (as code) in my Documentation as Code series. I definitely want to add at least D2Lang to it.

Documentation as Code for Cloud - C4 Model & Structurizr

Victor Dorneanu — Thu, 02 Nov 2023 19:02:33 +0000

Introduction

In the last post, I've used PlantUML to draw things like groups, accounts, and clusters. However, I didn't focus on how different parts inside the business layer interact (usually components related to the main application/system relevant for your business). Now, we'll use a DSL to show these interactions between components, services, and systems. I'll use the C4 model to show the same system in different ways based on who we're showing it to. It allows us to adjust how much detail we include.

👉 To learn how this diagram was created, continue reading 👇

C4 Model

The C4 model was developed by Simon Brown as a means of providing a visual map of system components across four levels of abstraction, as suggested by its title. Each level of abstraction in the C4 model suits different audiences, from the non-technical management level to detailed developer perspectives, each level of abstraction is tailored to meet its observer's understanding. To maintain consistency when describing the system design, the C4 model uniformly applies the same terminology and abstractions across all its levels, effectively implementing ubiquitous language principles from Domain-Driven Design (DDD).

👉 The 4 perspectives in the C4 model

Abstractions

The C4 model uses abstractions to form an hierarchy of well-defined diagrams (at different levels). Currently these abstractions are available:

Person
- Represents human users interacting with the system (e.g., Administrator, End User, Customer).
System
- A top-level view showing different people interacting with different software systems. (e.g., E-commerce Platform, Payment Gateway, our self-destructing email service 😎).
Container
- Involves zooming into an individual system to reveal containers within. Examples include server-side applications, client-side applications, databases, etc.
- not to be confused with Docker containers
Component
- Dives deeper into an individual container to expose its components, like classes, interfaces or objects in your code.

Diagram types

Level 1: Context diagram

Shows how your system fits into the larger system environment (system landscape). It basically shows interactions between users and systems:

e.g. A payment system interacting with an user and a banking system

👉 Context diagram

Level 2: Container diagram

Higher level view within a system itself. Shows software "containers" like web servers, standalone apps, or databases. (e.g., An API server, a database, and a client app in a single system)

👉 Container diagram

Level 3: Component diagram

Shows internal parts of a container. Mostly used with complex software. (e.g., Controllers, services, repositories inside of a web application)

👉 Component diagram

Level 4: Code diagram

A detailed view of the code level. For systems with little internal complexity, it can be skipped. (e.g., UML class diagrams)

👉 Code diagram

Structurizr DSL

Structurizr is used for describing and visualizing architecture using the C4 model. One of the main selling points is the fact you can define an entire (IT) architecture model using text. A typical model consists of:

relationships between abstractions
different views

Let's have a look at a simple example:

workspace {

    model {
        user = person "User"

        webApp = softwareSystem "Web Application" {
            tags "System"
        }

        database = softwareSystem "Database" {
            tags "Database"
        }

        team = person "Development Team"

        user -> webApp "Uses"
    }

    views {
        container webApp {
            include *
            autoLayout
        }

        styles {
            element "Database" {
                color "#0000ff"
            }
        }
    }
}

Code Snippet 1: Structurizr DSL: Basic structure

What do we have?

*Entities*:
- "User": a person who uses the "Web Application".
- "Web Application": a software system tagged as "System".
- "Database": another software system tagged as "Database".
- "Development Team": a person representing the team that develops the "Web Application".
Relationships:
- The "User" uses the "Web Application".
Container View:
- Focused on "Web Application".
- Includes all elements in the model.
- Uses automatic layout.
Styles:
- The "Database" elements are colored in blue ("#0000ff").

Before we move on, let's briefly discuss the installation steps.

Installation

I'd suggest you use the Docker image for a safe playground:

docker run -it --rm -p 1337:8080 -v ./:/usr/local/structurizr structurizr/lite

This will fetch the structurizr/lite Docker image from Dockerhub, start the container, mount the current working directory to /usr/local/structurizr and setup a port forwarding from localhost:1337 to <docker container>:8000.

Info Notice:

👉 I've setup a GitHub repository with the code I'll be using in the next sections. Feel free to clone from here.

Short recap

If you recall my initial post the entire aim was to document a hypothetical self-destructing e-mail service. In my 2nd blog post (about PlantUML) I've generated following sequence diagram:

👉 Full PlantUML Code

In the following I'll try to implement exactly this workflow using C4 and Structurizr DSL.

ripmail

👉 Checkout the code at https://github.com/dorneanu/ripmail.

Model

Let's start with the basic construct:

workspace {  ❶
  name "Self-Destructing Email Service"
  description "The sofware architecture of the self-destructing email service"

  model {    ❷
    //  ...
  }

  views {    ➌
    // System Landscape
 ❺ systemlandscape "SystemLandscape" {
      include *
      # autoLayout
    }

    // Themes
    // You can combine multiple themes!
 ❻ theme https://static.structurizr.com/themes/amazon-web-services-2023.01.31/theme.json

    styles { ❹
      element "Person" {
        color #ffffff
        fontSize 22
        shape Person
      }
      element "Sender" {
        color #ffffff
        background #8FB5FE
        shape Person
      }
      element "Recipient" {
        color #ffffff
        background #E97451
        shape Person
      }
    }
  }
}

Code Snippet 2: Basic Structurizr construct

So, what do we have?

❶ workspace
- Defines the workspace for a self-destructing email service.
❷ model
- This has to be implemented but basically it's a
- Placeholder section where you'd define the elements (software systems, people, containers) and their relations.
➌ views
- A System Landscape view ❺ that includes all elements defined in the model.
- The specified theme ❻ comes from an external JSON file, allowing broad customization of the look-and-feel.
- Three styles are defined for different types of elements labeled as Person, Sender, and Recipient. These characters are all represented by the Person shape.

Let's focus more on the model:


...

  model {
 ❶ sender = person "Sender" "Sender creates self-destructing email" {
      tags "Sender"
    }
 ❷ recipient = person "Recipient" "Recipient receives self-destructing email" {
      tags "Recipient"
    }

 ➌ group "Self-Destructing Email Service" {
      // Logging keeps track of several events
 ❹   logging = softwaresystem "Logging System" "Logs several events related to mail generation" {
        tags "Service API"
      }
 ❺   storage = softwaresystem "Storage System" "Stores encrypted mail content" {
        tags "Database"
        storageBackend = container "Storage Backend"
      }

 ❻   notification = softwaresystem "Notification System" "Sends notification to recipient to view email" {
        tags "System"

        // --- Notification Service
        notificationService = group "Notification Service" {
          notificationAPI = container "Notification API" {
            tags "NotificationService" "Service API"
          }
        }
      }

   ...

Code Snippet 3: Adding actors and different systems

We have following elements and groups:

❶ Sender: Person who creates the self-destructing email.
❷ Recipient: Person who receives the self-destructing email.
➌ Self-Destructing Email Service: Represents the overall service/system being described.

Additionally we have these systems inside the group:

❹ Logging System: Keeps track of events related to mail creation.
❺ Storage System: Stored encrypted email content. Includes a Storage Backend container.
❻ Notification System: Sends notification to recipient. Contains a Notification Service group with a Notification API container.

Main backend system

Now the backend system responsible for the business logic:

...

      // Backend system responsible for the business logic
❶    backend = softwaresystem "Backend System" "Contains logic how self-destructing mails should be created and dispatched to the recipient." {
        tags "BackendSystem"
❷       webapplication = container "Web Application"

        // Services/
        // --- Authentication Service
➌      authService = group "Authentication Service" {
❹        authAPI = container "Auth Service API" {
            tags "AuthService" "Service API"
          }
❺        authDB = container "Auth Service Database" {
            tags "AuthService" "Database"
❻          authAPI -> this "Checks if credentials match"
          }
        }


        // --- Email Composition Service
❼      mailCompositionService = group "Email Composition Service" {
❽        mailCompositionAPI = container "Email Composition API" {
            tags "EmailCompositionService" "Service API"
          }
❾        mailDB = container "Email Composition Database" {
            tags "Emailcompositionservice" "Database"
❿          mailCompositionAPI -> this "Stores metadata of mails"
          }

        }

        // --- Email Composition Service
⓫      viewEmailService = group "View Email Service" {
⓬          viewEmailFrontend = container "Email View Frontend" {
            tags "ViewEmailService"
          }
        }

...

Code Snippet 4: Main backend system and ther underlying services

The Backend System is the core system, with business logic, for creating/dispatching self-destructing mails.
of following containers and services:

❷ Web Application: The frontend component within the backend system for creating mails.
➌ Authentication Service: Group handling user credential verification.
- ❹ Auth Service API: Provides interface for authentication service.
- ❺ Auth Service Database: Stores user credential data.
- ❻ Auth Service API->Auth Service Database: Indicates API checks credentials against this database.
❼ Email Composition Service: Group handling creation/storage of emails.
- ❽ Email Composition API: Interface for the email composition service.
- ❾ Email Composition Database: Stores meta-information of emails.
- ❿ Email Composition API -> Email Composition Database: Indicates API stores mail metadata in this database.
⓫ View Email Service: Group handling email display.
- ⓬ Email View Frontend: The frontend component withing the backend system for viewing emails.

Relationships

And finally the relationships between different components:

...
        // Store mail data and encrypted content
        mailCompositionAPI -> storage "Store mail metadata and content"

        // Notify recipient
        mailCompositionAPI -> notificationAPI "Notify recipient"
        notificationAPI -> mailcompositionAPI "Recipient notified"

        // Log events
        notificationAPI -> logging "Log Email sent event"

        // Sender creates new email
        sender -> webapplication "Create new mail"
        webapplication -> authAPI "Authenticate user"
        webapplication -> mailCompositionAPI "Create mails"
        notification -> recipient "Send out notification"
        backend -> logging "Create events"

        // Recipient receives new mail
        recipient -> webapplication "View self-destructing mail"
        webapplication -> viewEmailFrontend "View email"
        viewEmailFrontend -> mailDB
        viewEmailFrontend -> storage
...

Code Snippet 5: Relationships between different components

From	To	Description
Mail Composition API	Storage	Store mail metadata and encrypted content
Mail Composition API	Notification API	Notify recipient
Notification API	Mail Composition API	Recipient notified
Notification API	Logging	Log Email sent event
Sender	Web Application	Create new mail
Web Application	Auth API	Authenticate user
Web Application	Mail Composition API	Create mails
Notification	Recipient	Send out notification
Backend System	Logging	Create events
Recipient	Web Application	View self-destructing mail
Web Application	View Email Frontend	View email
View Email Frontend	MailDB	Fetches email data for visualization
View Email Frontend	Storage	Fetches email details for visualization

Deployments

Deployment components are required for the deployment diagrams. These illustrate how software systems are deployed onto infrastructure elements in an environment. They also enable you to visualize how containers within a system map onto the infrastructure.

This kind of diagrams are very important as they provide important information regarding system runtime environment such as scaling, redundancy, network topology, and communication protocols. They are crucial to understanding the physical aspects and deployment context of a system.

workspace {

  model {
  //  ...
  live = deploymentEnvironment "Live" { ❶
    // AWS
    deploymentNode "Amazon Web Services" { ❷
        tags "Amazon Web Services - Cloud"

          // Which region
    ➌     deploymentNode "eu-central-1" {
            tags "Amazon Web Services - Region"
            ...
          }
    }
  }
  }

  views {
  // ...
  }
}

Code Snippet 6: The live deployment environment

We're still defining the model. Now we have defined a deploymentEnvironment live ❶ which should be deployed into the AWS Cloud ❷, namely in eu-central-1 ➌. In this region we'll have different organizational units (OUs):

OU: Tech

This will host the EKS cluster as well as the API Gateway which serves as the main entrypoint for API calls.
OU: Security

This is where alert & monitoring will take place. Also here relevant data to the mail will be stored within S3 buckets. Finally we use IAM capabilities to make sure authentication and authorization works properly.
OU: DevOps

The CI/CD build pipeline and infrastructure provisioning will take place here. The software artefacts will be built here and deployed into the accounts
inside "OU: Tech".

...

       // Which region
       deploymentNode "eu-central-1" {
         tags "Amazon Web Services - Region"

         // ------------------------------------------------
         // Organizational Unit: DevOps
         // ------------------------------------------------
         deploymentNode "OU-DevOps" {...}

         // ------------------------------------------------
         // Organizational Unit: Tech
         // ------------------------------------------------
         ou_tech = deploymentNode "OU-Tech" {...}


         // ------------------------------------------------
         // Organizational Unit: Security
         // ------------------------------------------------
         deploymentNode "OU-Security" {...}
       }

...

Code Snippet 7: Outline main organizational units (OUs)

OU: DevOps

But one thing at a time:

      // --------------------------------------------
      // Organizational Unit: DevOps
      // --------------------------------------------
      deploymentNode "OU-DevOps" {
❶      tags "Amazon Web Services - AWS Organizations Organizational Unit"

❷        deploymentNode "acc-devops-prod" {
➌          tags "Amazon Web Services - AWS Organizations Account"

❹          vpc_management = deploymentNode "VPC (management)" {
❺            tags "Amazon Web Services - VPC Virtual private cloud VPC"

❻            gitlab_server = infrastructureNode "Gitlab Server" {
❼              tags "Amazon Web Services - EC2"
            }

          }
        }
      }

Code Snippet 8: Deployment components for the OU DevOps

The DevOps OU deployment components are:

Organizational Unit (OU-DevOps): Represents a unit in the organization.
- ❶ Tagged as an Amazon Web Services (AWS) Organizations Organizational Unit.
❷ acc-devops-prod: Represents an account within the OU-DevOps unit.
- ➌ Tagged as an AWS Organizations Account.
❹ VPC (vpc_management): A Virtual Private Cloud (VPC) within the acc-devops-prod account.
- ❺ Tagged as an AWS VPC Virtual private cloud VPC.
❻ Gitlab Server (gitlab_server): Infrastructure node within the VPC.
- ❼ Tagged as AWS EC2.

OU: Security

     // ---------------------------------------------
     // Organizational Unit: Security
     // ---------------------------------------------
❶    deploymentNode "OU-Security" {
❷      tags "Amazon Web Services - AWS Organizations Organizational Unit"

➌      deploymentNode "acc-security-logging" {
❹        tags "Amazon Web Services - AWS Organizations Account"

❺        s3_logging = infrastructureNode "S3 Bucket" {
❻          tags "Amazon Web Services - Simple Storage Service"
         }

❼        infrastructureNode "CloudWatch Logs" {
❽          tags "Amazon Web Services - CloudWatch Logs"
         }
       }

❾      deploymentNode "acc-security-monitoring" {
❿        tags "Amazon Web Services - AWS Organizations Account"

⓫        infrastructureNode "CloudWatch" {
⓬          tags "Amazon Web Services - CloudWatch Alarm"
         }
       }
     }

Code Snippet 9: Deployment components for the OU Security

The Security OU deployment components are:

Organizational Unit (OU-Security): Represents a security unit in the organization.
- ❶ Tagged as an AWS Organizations Organizational Unit.
➌ acc-security-logging: Represents an account within the OU-Security unit for logging purposes.
- ❹ Tagged as an AWS Organizations Account.
- ❺ Contains an "S3 Bucket" infrastructure node.
  - ❻ Tagged as AWS Simple Storage Service.
- ❼ Contains a "CloudWatch Logs" infrastructure node.
  - ❽ Tagged as AWS CloudWatch Logs.
❾ acc-security-monitoring: Represents another account within the OU-Security unit for monitoring purposes.
- ❿ Tagged as an AWS Organizations Account.
- ⓫ Contains a "CloudWatch" infrastructure node.
  - ⓬ Tagged as AWS CloudWatch Alarm.

OU: TECH

Now the most complicated one:

     // --------------------------------------------
     // Organizational Unit: Tech
     // --------------------------------------------
❶    ou_tech = deploymentNode "OU-Tech" {
       tags "Amazon Web Services - AWS Organizations Organizational Unit"

❷      deploymentNode "acc-tech-prod" {
         tags "Amazon Web Services - AWS Organizations Account"

         // EKS control plane
➌        eks_vpc = deploymentNode "EKS VPC" {
           tags = "Amazon Web Services - VPC Virtual private cloud VPC"

❹          eks_control_plane = infrastructureNode "EKS Control Plane" {
             tags = "Amazon Web Services - EKS Cloud"
           }
         }

         // ECR
❺        ecr = infrastructureNode "ECR" {
           tags "Amazon Web Services - Elastic Container Registry"
           description "Private ECR registry"
         }

         // EKS cluster
❻        workload_vpc = deploymentNode "Workload VPC" {...}

         // DynamoDB instances
❼        dbs = group "Databases" {...}

         // S3 (Storage System)
❽        s3_storage = infrastructureNode "S3 Bucket (storage)" {
           tags "Amazon Web Services - Simple Storage Service"
         }

       }
     }

Code Snippet 10: Deployment components for the OU Tech

This will result in following components hierarchy:

❶ Organizational Unit (OU-Tech): Represents a technology unit within the organization.
❷ acc-tech-prod: Represents a production account within the "OU-Tech" unit.
- EKS control plane deployed within an EKS VPC.
  - ➌ EKS VPC: VPC where the EKS control plane is deployed,
  - ❹ EKS Control Plane: infrastructure node within EKS VPC.
- ❺ ECR: Infrastructure node for the Elastic Container Registry with private ECR registry.
- ❻ Workload VPC: Deployment node holding different workloads.
- ❼ Databases group holds DynamoDB instances.
- ❽ S3 Bucket (storage): Infrastructure node for the storage system.

Let's have a look what's inside the workload VPC:

  // EKS cluster
  workload_vpc = deploymentNode "Workload VPC" {
    tags = "Amazon Web Services - VPC Virtual private cloud VPC"

    // AZ 1
❶   deploymentNode "Availability Zone 1" {
      tags = "Amazon Web Services - Region"

❷     deploymentNode "Subnet 1" {
        tags = "Amazon Web Services - VPC VPN Gateway"

➌       eks_node_group1 = deploymentNode "EKS Managed Node Group" {
          tags = "Amazon Web Services - EKS Cloud"

❹         eks_node_group1_pod1 = deploymentNode "Pod 1" {
            tags = "Kubernetes - pod"
❺           pod1_authAPI = containerInstance authAPI
          }

❻         eks_node_group1_pod2 = deploymentNode "Pod 2" {
            tags = "Kubernetes - pod"
❼           pod2_mailCompositionAPI = containerInstance mailcompositionAPI
❽           pod2_notificationAPI = containerInstance notificationAPI

          }

        }
      }

    }

    // AZ 2
❾   deploymentNode "Availability Zone 2" {
      tags = "Amazon Web Services - Region"

❿     deploymentNode "Subnet 1" {
        tags = "Amazon Web Services - VPC VPN Gateway"

⓫       eks_node_group2 = infrastructureNode "EKS Managed Node Group" {
          tags = "Amazon Web Services - EKS Cloud"
        }

      }
    }
  }

Code Snippet 11: Components of the workload VPC

The workload VPC consists of 2 availability zones:

❶ Availability Zone 1: A separate deployment node categorized as an AWS Region.
- ❷ Subnet 1: Deployment node within Availability Zone 1.
- ➌ EKS Managed Node Group: Node group for managing EKS resources.
- ❹ Pod 1: Deployment node within the EKS Managed Node Group.
  - ❺ Houses instance of authAPI container.
- ❻ Pod 2: Another deployment node within the EKS Managed Node Group.
  - ❼ Houses instance of mailcompositionAPI container.
  - ❽ Houses instance of notificationAPI container.
❾ Availability Zone 2: Another separate deployment node categorized as an AWS Region.
- ❿ Subnet 1: Deployment node within Availability Zone 2.
- ⓫ EKS Managed Node Group: Infrastructure node for managing EKS resources.

Let's also have a look how we can use containerInstance for the databases:

     // DynamoDB instances
❶  dbs = group "Databases" {
       deploymentNode "DB VPC" {
         tags = "Amazon Web Services - VPC Virtual private cloud VPC"

❷      deploymentNode "DynamoDB (Auth)" {
           tags "Amazon Web Services - DynamoDB"

➌        liveUserDB = containerInstance authDB
         }

❹      deploymentNode "DynamoDB (Mails)" {
           tags "Amazon Web Services - DynamoDB"

❺        liveMailDB = containerInstance mailDB
         }
       }
     }

Code Snippet 12: Components of the DB VPC

This will create:

❶ Databases: A group of databases within a DB VPC deployment node.
❷ DynamoDB (Auth): DynamoDB instance for authentication.
- ➌ Contains a live instance of authDB.
❹ DynamoDB (Mails): DynamoDB instance for mail metadata.
- ❺ Contains a live instance of mailDB.

Views

Views in Structurizr are used to create visual diagrams of your software architecture model. They provide a way to communicate the different aspects of your system to various stakeholders. Views can be thought of as 'camera angles' on your architecture model, each designed to present a certain perspective of the system.

System Landscape

The System Landscape view in Structurizr is the highest level view of a software system's architecture. It shows all users, software systems and external systems or services in scope. It informs about the overall system context and interaction among systems and users.

    // System Landscape
    systemlandscape "SystemLandscape" {
      include *
    }

Code Snippet 13: The System Landscape where every component (*) is included in the diagram

👉 System Landscape

Deployment Live

The Deployment View in Structurizr is a type of view that visualizes the mapping of software building blocks (like Containers or Components) to infrastructure elements, including servers, containers or cloud services. It gives a clear indication of how and where the software system runs in different environments (like development, staging, production).

    // Deployment live
    deployment backend live "LiveDeployment"  {
      include *
      description "An example live deployment for the self-destructing email service"
    }

Code Snippet 14: The deployment view for live

👉 Deployment View

Containers

In Structurizr, a Container represents an executable unit (application, data store, microservice, etc.) that encapsulates a portion of your software system. Containers run inside software systems and have interfaces that let them interact with other containers and/or software systems. The Container view shows the internal layout of a software system, specifying contained components and their interactions. This level of abstraction is valuable for developers and others dealing with system implementation and operation.

    // Backend
    container backend "Containers_All" {
      include *
      # autolayout
    }

Code Snippet 15: The container view for all resources

👉 Containers (global)

And now for specific services:

Notification Service

    container backend "Containers_NotificationService" {
      include ->notificationService->
      autolayout
    }

Code Snippet 16: Container view for the notification service

👉 Container view for the notification service

Mail Composition Service

    container backend "Containers_MailCompositionService" {
      include ->mailCompositionService->
      autolayout
    }

Code Snippet 17: Container view for the email composition service

👉 Container view for the Mail Composition Service

Authentication Service

    container backend "Containers_AuthenticationService" {
      include ->authService->
      autolayout
    }

Code Snippet 18: Container view for the authentication service

👉 Container view for the Authentication Service

Extra features

With the online version of Structurizr you get access to diffeerent exporting features:

PlantUML: Export your model as PlantUML diagrams.
C4-PlantUML: Export your model as C4-PlantUML diagrams.
Mermaid: Generate Mermaid diagrams from your model.
DOT: Export containers and components as DOT graph description language.
ilograph: Export the model and the views for ilograph.com

Among these I've found ilograph to be the most interactive one.

Ilograph

Once you've exported your workspace in ilograph format, follow these steps:

Create a new ilograph diagram
Paste in the exported ilograph code

And this is what you get:

👉 ilograph with code

👉 ilograph without code

👉 Here's the ilograph code.
👉 Check out other architecture diagrams made with ilograph.

Resources

The resources I've consumed for generating the content and diagrams for this blog post:

Tools:

2023-10-05 ◦ IcePanel.io

A visual modelling tool for C4
2023-10-05 ◦ C4-PlantUML

C4-PlantUML combines the benefits of PlantUML and the C4 model for providing a simple way of describing and communicate software architectures

Articles:

2023-10-08 ◦ Software Diagrams - C4 Models with Structurizr
2023-07-10 ◦ Structurizr - Practicalli Engineering Playbook
2022-10-31 ◦ C4 model for system architecture design
2022-10-10 ◦ C4 Models: Architecture From Simple To Complex

Structurizr:

2023-10-07 ◦ Structurizr - Help - Themes

Videos:

2023-07-10 ◦ C4 Models as Code • Simon Brown • YOW! 2022 - YouTube

Outlook

In the next post I'll deep-dive into the D2 language which also has a huge set of features. Stay tuned.