Sergi's writing

Disclaimer: I am not a mathematician, and it has been a long time since I studied statistics and probability, so I'm probably botching or misusing some terms.

Every time I get into some miniatures wargame like Marvel Crisis Protocol</a> or Dropfleet Commander</a>, one of the first things I do is checking if there exists some dice roll simulator for that game. I use that to get a better feel of how some rules translate to probabilities of success in the game.

If the game is very niche or very new, that utility doesn't exist yet, so sometimes I build my own thing in Python. If I get very excited about the game, I even make a web app to share with the community. An example of that is Arcanestats</a> for Warcaster Neo-Mechanika</a>.

I used to build these simulators using Python's fractions</a> and crunching the numbers myself, until I discovered Dice Stats</a>. This library is great! You might think "hey, this thing is unmaintained, it hasn't had a commit since 2020!" Well, no, it's just done. It does what it needs to do, and it's bug free — AFAIK</abbr>. So why would they be pushing more commits? It even has a Read the Docs</a> page!

The documentation is enough to get you started, but I am going to share some code from Arcanestats as a real example. Warcaster Neo-Mechanika uses custom 6-sided dice, where each side has a number of successes, called strikes. There are two types of dice, and the number of strikes is different for each. An Action die has 3 sides with 0 strikes, 2 sides with 1 strike, and 1 side with 2 strikes. A Power die has 1 side with 0 strikes, 4 sides with 1 strike, and 1 side with 2 strikes. As you can see, Power dice are better than Action dice, as they have more strikes on average. With Dice Stats, these dice can be modeled as:

from</span> fractions</span> import</span> Fraction</span></span>
from</span> dice_stats</span> import</span> Dice</span></span>
</span>
ACTION_DIE</span> =</span> Dice({</span>0</span>: Fraction(</span>3</span>,</span> 6</span>),</span> 1</span>: Fraction(</span>2</span>,</span> 6</span>),</span> 2</span>: Fraction(</span>1</span>,</span> 6</span>)})</span></span>
POWER_DIE</span> =</span> Dice({</span>0</span>: Fraction(</span>1</span>,</span> 6</span>),</span> 1</span>: Fraction(</span>4</span>,</span> 6</span>),</span> 2</span>: Fraction(</span>1</span>,</span> 6</span>)})</span></span></code></pre>
On a single roll</span>, you can roll a few Action dice and a few Power dice together. To calculate the outcome of that, you
can write a function like this:</p>
from</span> typing</span> import</span> NamedTuple</span></span>
</span>
Roll</span> =</span> NamedTuple(</span>"Roll"</span>, [(</span>"action"</span>,</span> int</span>), (</span>"power"</span>,</span> int</span>)])</span></span>
</span>
</span>
def</span> get_dice</span>(roll: Roll) -> Dice:</span></span>
    return</span> ACTION_DIE</span> *</span> roll.action</span> +</span> POWER_DIE</span> *</span> roll.power</span></span></code></pre>
The outcome is an instance of Dice</code>, because a Dice</code> is like a mapping of each outcome — in this case, number of
strikes —
and their probability.</p>
Let's see something more complex: the whole attack sequence. In the game, when one model attacks another model,
the attacker player rolls a set of attack dice, and the defender player rolls a set of defense dice. Each player rolls a
combination of Action
and Power dice. The amount of dice depends on the models' attack/defense stats, game circumstances like being in cover,
etc. Then, we calculate the difference between the two rolls — strikes on attack minus strikes on defense. If the
result is 0 or negative, the attack completely misses. Otherwise, we need to calculate how much damage the defender
takes.</p>
To calculate the damage, the attacker rolls a new set of dice — now the amount of dice depends on how deadly the
weapon is, how many strikes were rolled on the attack roll, and other factors. The defender does not roll dice this
time. Instead, each model has an armor value. A model with "armor N" takes 1 damage point for each N strikes on the
damage roll. For example, if the result or the roll is 5 strikes, and the defender has armor 2, the defender takes 2
damage points. If it was 6 strikes, it would take 3 damage points. Now, imagine that we want to calculate what's the
distribution of damage that a defender will take against multiple attacks — in other words, what's the chance that
it will take 0 damage, or 1 damage, or 2 damage, etc. Let's see this in code:</p>
from</span> typing</span> import</span> Dict, List, Tuple</span></span>
</span>
</span>
def</span> prob_attack</span>(</span></span>
        attacks: List[Tuple[Roll, Roll]], defense_roll: Roll, armor:</span> int</span></span>
) -> Dice:</span></span>
    damages</span> =</span> []</span></span>
    defense_dice</span> =</span> get_dice(defense_roll)</span></span>
    for</span> attack_roll, damage_roll</span> in</span> attacks:</span></span>
        attack_dice</span> =</span> get_dice(attack_roll)</span></span>
        hits</span> =</span> (attack_dice</span> -</span> defense_dice).max(Dice.from_empty())</span></span>
        if not</span> hits:</span></span>
            continue</span></span>
</span>
        damage_dice</span> =</span> Dice.sum(</span></span>
            Dice.from_empty()</span> @</span> c</span></span>
            if</span> v</span> ==</span> 0</span></span>
            else</span> get_dice(Roll(action</span>=</span>damage_roll.action, power</span>=</span>damage_roll.power</span> +</span> v))</span></span>
                 @</span> c</span></span>
            for</span> v, c</span> in</span> hits.items()</span></span>
        )</span></span>
</span>
        damages.append(damage_dice</span> /</span> armor</span> //</span> 1</span>)</span></span>
</span>
    if not</span> damages:</span></span>
        damages</span> =</span> [Dice.from_empty()]</span></span>
</span>
    return</span> sum</span>(damages)</span></span></code></pre>
The multiple attacks are represented as a List[Tuple[Roll, Roll]]</code>, where each attack is a tuple with an
attack Roll</code> and a damage Roll</code>. Remember that a Roll</code> is not a sample result of rolling dice, it's the amount of
dice rolled</a>.
A defender will roll the same number of defense dice against all the attacks, so we only need one Roll</code> for that.</p>
Computing the distribution of the defense dice is a simple attack_dice = get_dice(attack_roll)</code>, using the function
shown before.</p>
Computing the distribution of the difference between attack dice and defense dice is
hits = (attack_dice - defense_dice).max(Dice.from_empty())</code>.
It's important to calculate this distribution because, when calculating damage, the attacker rolls an extra power
dice for each strike on the difference between attack and defense dice.
You can see that when we iterate on each possible outcome of the attack/defense roll with for v, c in hits.items()</code>, we modify the original damage roll to add v</code> to it:
Roll(action=damage_roll.action, power=damage_roll.power + v)</code>.</p>
Probably you got a bit confused with the @</code> operator, which the
library overloads</a>,
and it's basically a nice looking replacement for the 
Dice.as_total_chance</code></a>
method. We are doing this because the outcome of the damage roll is conditioned by the probability of rolling that amount of strikes on the attack/defense roll.</p>
Well, that's all I wanted to say. I think this is an awesome library and wanted to share it with you.</p>
Happy rolling!</p>

I tried to opt-out of airlines selling my data to the government, and I am not sure if it worked 2025-12-06T00:00:00+00:00 A few weeks ago, somebody posted on my Mastodon feed</a> a link to an old article from 404 Media</a> called How to Opt-Out of Airlines Selling Your Travel Data to the Government</a> (I'm sorry kind stranger, I probably boosted your message but forgot to bookmark it to give you credit here). The article explains that there is a data broker — the Airlines Reporting Corporation (ARC) — that sells flight data to multiple parts of the Department of Homeland Security (DHS) and a host of other government agencies. I was curious, decided to follow the process described in the post, and e-mailed privacy@arccorp.com</a> with the subject "Data deletion" and the body: Hi, I wish to delete my personal data held by ARC. Thanks, Sergi </blockquote> I got the following reply the next day, which was surprisingly fast: We have received your recent request regarding the use of your personal information. We take your privacy seriously and are committed to complying with applicable data protection laws. Next Steps We will process your request as soon as possible and, in any event, within the timeframes required by law. In order to verify your identity, we need to know your full name, including middle name if applicable, as well as the last four digits of any and all credit card number(s) that you used to purchase air travel. Please also provide your address of residence. Any information collected for verification will be used solely for this purpose, and we will promptly delete any such information once the verification process is complete. If we do not receive this information, we may not be able to process your request. You will receive confirmation once your request has been fulfilled, along with information about any further actions, if necessary. Additional Information If your request relates to specific types of data or processing (e.g., direct marketing, profiling, or third-party sharing), please specify so we can address your request accurately. There may be certain legal exceptions where we are required to retain or process some information, such as to comply with legal obligations. If this applies, we will inform you accordingly. If you have any further questions or would like to clarify your request, please reply to this message. Thank you for reaching out regarding your privacy rights. Best, ARC Privacy </blockquote> Providing all this data felt a bit scary, but I guess they need to know who you are to know what to delete. So I replied with my name and last name, four last digits of a couple of credit cards, and my address. Then, I waited. Twelve days later — and probably would have been sooner if Thanksgiving wasn't during that time — I got this: We have received your request regarding the retention, use, and/or deletion of your personal information. We take your privacy seriously and are committed to complying with applicable data protection laws. We have repeatedly searched our files and are unable to locate any of your personal information in our system. Any information you provided for verification will not be used for any other purposes and will be deleted. If you have any further questions or concerns, please reply to this message. Best, ARC Privacy </blockquote> Which was not what was I was expecting. If that's true, I guess it's good news. But I wonder if they botched the search — having two last names separated with a space causes data input errors too frequently in the US — and that's why they couldn't find my data. If you give it a try and get a different outcome, I'm curious to hear out! Arrow functions are overused 2025-07-30T00:00:00+00:00 I've noticed something in online articles lately: arrow functions everywhere. It's as if function</code> became a dirty word overnight, and every function declaration got replaced with const myFunc = () => {}</code>. While arrow functions are undeniably useful, I think we've swung too far in the other direction. Let me be clear upfront—there are absolutely cases where arrow functions shine and others where function declarations are better. If you want a comprehensive breakdown of the differences, James Sinclair's article on the differences between ordinary functions and arrow functions</a> is an excellent reference. But when there isn't a clear technical winner, many developers still default to arrow functions. The assumption seems to be that they're more concise. Let's test that assumption. The "shorter" myth</h2> Here's a simple function declaration: function calculate() { // implementation }</code></pre> And here's the arrow function equivalent: const calculate = () => { // implementation };</code></pre> Count the characters of the first line: 22 vs 35. The arrow function is actually longer. If we ignore the function name (calculate</code>), it's 13 vs 16 characters. The "conciseness" argument falls apart pretty quickly when you're dealing with named functions. When syntax gets in the way</h2> I recently came across a perfect example of this in a TypeScript article about advanced type manipulation features</a>. The author needed to demonstrate generic functions and wrote: const sendEvent = <E extends EventName,>( event: E, payload: HomeEvents[E] ) => { /* ... */ };</code></pre> Notice that trailing comma after EventName</code>? The author had to dedicate an entire sidebar to explain why it's there—because TypeScript and JSX syntax clash when using arrow functions with generics. The comma tells the parser it's looking at a generic type, not a JSX element. The solution? Use a function declaration: function sendEvent<E extends EventName>( event: E, payload: HomeEvents[E] ) { /* ... */ }</code></pre> Clean, clear, and no syntactic gymnastics required. The reader can focus on the actual TypeScript concepts being taught instead of wrestling with parser ambiguities. A modest proposal</h2> Here's what I suggest: make function declarations your default choice. Reach for arrow functions when you have a specific reason—when you need lexical this</code>, when you're writing a short callback, when you're working in a functional style. But if you're just writing a regular function that does some work and returns a result? Consider the humble function</code> keyword. Sometimes the old ways persist because they just work better. The next time you type const myFunction = () => {</code>, pause for a second. Ask yourself: is there a compelling reason to use an arrow function here, or am I just following a trend? Happy coding! Bringing back the scrollbars 2025-03-30T00:00:00+00:00 I don't like the design pattern of hiding the scrollbars. I am not alone in this; I have frequently read articles complaining about it, like this blog post</a> that made it to Hacker News</a>, Reddit posts</a>, or even posts on Microsoft forums</a>. There are different variations of this pattern. On some cases, the scrollbar is hidden, and it only shows up when hovering the cursors over the area where the scrollbar is supposed to be. On other cases, it's there, but very thin, and it only becomes thicker — although not much nowadays — when you hover over it. I think both cases are bad from a usability and accessibility perspective, and just another example of today's software industry where form triumphs usability. Personally, I hate the ones that are hidden, as you lose the visual cue of how long the article/content is, and how much is left to scroll. Anyway, on Firefox on Linux, this can be easily solved on the browser settings. Open the settings window, search for "scrollbar" on the search box, and a checkbox with the text Always show scrollbars</samp></kbd> should show up. Enable it, and you are back to the good old times! On Windows 11 it's a bit different. You have to enable it at the OS level. Search for "scroll bar" on the search box of the Windows task bar. The first option it suggests should say Always show scroll bars / System settings</samp></kbd>. Click on it, and it will open a window titled Accessibility > Visual effects</kbd></samp>. On it there should be a checkbox with the text Always show scrollbars</kbd></samp> — you might have noticed they are inconsistent with the spelling of "scrollbar". Enable this option to get back to sanity. Happy scrolling! How to fix a Pixel Watch stuck on Fastboot 2025-03-08T00:00:00+00:00 I am the owner of a Pixel Watch 2. During the past months, approximately once a week, the battery would suddenly deplete very quickly. For example, I would charge it overnight, put it on around 8am, and when checking the time at 2pm I would find out it was almost dead (or already dead). If I caught this happening before the device died, a reboot would fix it and the watch would keep working as expected. To put it in perspective, a regular full charge lasts me more than 24 hours; it can probably reach 36. I tried looking online for a permanent solution but didn't find anything. I thought about reaching out to Google for support, but because of laziness, I never did. I ended up regretting that because when this behavior started it was probably still under warranty. Around the end of February, it happened again. I went to check the time and found out the watch was dead, only showing the icon of empty battery. I plugged it in, and a few hours later, when I went to sleep, I grabbed it with the intention to put it on and... I got greeted by what's called the Fastboot screen. The Fastboot screen is a menu with options like Start</samp></kbd>, Power Off</samp></kbd>, Recovery Mode</samp></kbd>, Device Info</samp></kbd>, etc. All the options I tried that would reboot the device would bring me back to that menu. I was stuck there. Inside the Recovery Mode</samp></kbd>, there is the option of Wipe data/Factory reset</samp></kbd>. Even that did not fix the issue. Interestingly, when I triggered that option, an error message would show up with: ERROR: recovery: [libfs_mgr] Unable to enable ext4 verity on /dev/block/bootdevice/by-name/metadata because /system/bin/tune2fs is missing ERROR: recovery: Open failed: /metadata/ota: No such file or directory Formatting /data... </samp> </blockquote> After that, I could reboot the system, but that would load again the Fastboot. I reached out to Google support. After trying to make me repeat the steps that I had just done, I explained to them I had already done that and shared with them the error message I was getting. Their answer was short of "Too bad. There is nothing you can do then, and as the device is out of warranty we are not gonna give you a new one." I've had two Fitbit devices that died soon after the warranty expired, so with that now happening to the Pixel Watch (warranty expired 2 months before this incident), I was fuming. A few days later, I kept researching. I found out you can download images of the OS, officially from Google, and that you can use the charger cable to flash the watch with them. Heck, what did I have to lose? So that I did. Using the Watch app on my phone, I identified what build of the OS I was running before. Then I downloaded the corresponding image from the repository of full OTA images for Google Pixel Watch devices</a>. I am not sure of the difference between OTA images and factory images, but all the posts I found online always pointed to the OTA ones. Next, I installed the Platform-Tools for Google Android SDK. Nowadays, I use Arch Linux, so I downloaded them from AUR</a>. This package includes adb</code>, aka Android Debug Bridge, which allows you to communicate with Android devices. Then, on the watch, using the Fastboot menu, I went to Recovery mode</samp></kbd>, and triggered the option Apply update from ADB</samp></kbd>. Then, I plugged the watch into the computer with the charger cable and checked that the device was recognized by executing: adb devices</code></pre> This listed my watch, so I started flashing the image with: adb sideload aurora-ota-aw2a.241105.012-a7c5bc2d.zip</code></pre> That showed me a progress report. This part was a little nerve-breaking because the charger attaches to the watch mostly with magnets, not a physical attachment, so it's very easy to unplug it, and I was worried that a disconnection mid-flashing could completely brick the device. Fortunately, none of that happened. The flashing finished, the watch rebooted, and it was as good as new! After pairing it again with my phone it downloaded the latest online backup and all my apps and settings were re-applied. I'm very happy that I could fix it, but at the same time, I am deeply disappointed that Google support did not inform me of this option. Either they lied by telling me there was nothing I could do about it, or they are insufficiently trained to do their job. Ode to the Kindle Keyboard (Kindle 3) 2025-01-18T00:00:00+00:00 In 2010, I got a Kindle Keyboard (aka Kindle 3) as a Christmas gift from my parents. It's still my only ebook reader, and it's probably the oldest piece of technology I regularly use. </div> It's 14 years old and still works!</figcaption> </figure> The specs</h2> The particular model I own is the one with only Wi-Fi. There was a more expensive option with 3G but at the time — and still nowadays — I saw no reason for that feature. According to Wikipedia, this model weighs 240 g (8.5 oz on freedom units), with a total size of 190 × 120 × 8.6 mm (7.5 × 4.8 × 0.34 in). It features a 6-inch screen with a resolution of 600 × 800 pixels, for a density of 167 PPI. It rocks a 16-level grayscale palette. It has 3GB of storage that I doubt I'll ever fill, a USB 2.0 Micro-B port for charging, speakers, and a 3.5mm headphone. These audio outputs are for a text-to-speech feature that I think I have never used. And, probably the most shocking feature for young generations, it has a small keyboard. Look at this cutie: </div> A beautiful clicky keyboard with real, physical buttons.</figcaption> </figure> Having that keyboard so readily available emphasized annotating your ebooks. I very rarely do that, but if I did I would love to do it on this device! You can sync these annotations with your Amazon account, so I guess that if you get a new Kindle device you can port them over. You can also highlight text. An interesting feature — that can be disabled — is to see text that is frequently highlighted by other users — this only works on books bought through Amazon —. And you can decide if you want to share your highlights or not. If you want an even more simplified marking, you can bookmark pages. </div> You can list all your notes, highlights and bookmarks for a given book.</figcaption> </figure> All this data — for all the books — can be found on the plain text file My Clippings.txt</code> on the device. Yeah, if you connect it to a computer it will mount like a standard USB drive. This is the plain text representation of the highlight, annotation, and bookmark shown in the image above: ========== Dune (Frank Herbert) - Highlight on Page 2 | Loc. 142-45 | Added on Saturday, January 14, 2023, 04:25 AM By the half-light of a suspensor lamp, dimmed and hanging near the floor, the awakened boy could see a bulky female shape at his door, standing one step ahead of his mother. The old woman was a witch shadow—hair like matted spiderwebs, hooded ’round darkness of features, eyes like glittering jewels. ========== Dune (Frank Herbert) - Note on Page 4 | Loc. 146 | Added on Saturday, January 14, 2023, 04:31 AM what a profound statement ========== Dune (Frank Herbert) - Bookmark on Page 4 | Loc. 150 | Added on Saturday, January 14, 2023, 04:33 AM ==========</code></pre>My experience</h2> I love this device. It has been with me for 14 years now. Yes, I am not a heavy user, but I can still load and read ebooks into it, and it works with Amazon ebooks or standard EPUB and .mobi files. Even PDFs if you feel like it, although these are a bit of a pain as they are formatted for big screens, and they need a lot of zooming and panning around. I tried a couple of times to read a manga where each page was an image, but the screen was a tad too small for it, and having to zoom and pan bothered me too much. If I buy a book via Amazon it will automatically sync it and add it to the device. If I get the file from somewhere else, I usually use Calibre</a> to load it. If I feel like it, I can send the file as an attachment to a special e-mail account Amazon provided for my device, and it will automagically add it to the device over Wi-Fi. I only turn on the Wi-Fi when I want to add new books via Amazon services, otherwise, I keep it off. With that, the battery lasts long enough so that I can read a book from start to end without needing to charge. I'm not sure how long it actually lasts because I rarely read two ebooks back to back, but heck, we plug in our phones every night and nobody beats an eye. This 14-year-old device lasts between charges way longer even with heavy use! The supported Wi-Fi is 802.11bg at 2.4 GHz, and fortunately, that has not been phased out. And for the few MBs an ebook takes, transfer speed is not an issue. And when using Calibre I use USB anyway. All the clicky buttons still work, even the ones for turning pages which are the ones I've used the most. The "next page" button on the right side feels softer, but that's it. And yes, I said "on the right side", because the same buttons are also on the left side for easy page change if you are holding it with the left hand. I said I barely use the keyboard, but the extra space and weight do not bother me. It actually serves as a nice extra surface to comfortably hold it. Turning a page takes about 1 second, and that's good enough for me. The resolution provides very legible text and B&W graphics. </div> This is perfectly readable. Any blur is because the picture is crap, in reality the text is very crisp.</figcaption> </figure> I can customize between 3 different typefaces, 8 different font sizes, 3 different line spacings, and 3 different words per line. Look at this: </div> The menu to configure how text is rendered.</figcaption> </figure> The lock screens</h2> I found the lock screen very amusing. Every time you lock it, the screen switches to the portrait of an author or a sketch. Remember that an and electronic ink screen only uses energy when refreshing; keeping content frozen uses zero battery. These are the different lock screens it rotates through: </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> </div> These are all the possible lock screens in order of rotation.</figcaption> </figure> Jailbreaking</h2> The Kindle Keyboard can be jailbroken to customize it or extend its capabilities, but I never felt the need to do it, so I didn't. I have nothing else to say about it ¯\_(ツ)_/¯. I'm not buying a new model</h2> I don't see why I should. Everything works. I can read ebooks bought from Amazon or any other platform that offers EPUBs or compatible formats. It performs this function well; I have no complaints about legibility or performance. The only feature from new models I might have missed at some point is the front-lit screen for reading in low light, but it's rare enough for me that it's not a deal-breaker. And I bet that newer models are full of tracking technology. That makes me wonder how often other people replace their ebook readers, and why. Definitely more frequently than I do, otherwise I don't see how manufacturers could keep up with the high pace of releasing new models. Just looking at the Kindle, I see 5 models were released in 2024, 2 models in 2022, 2 models in 2021, and 2 models in 2019. That's 11 new devices launched during the last 5 years! It makes me sad that I don't have more devices around me that are this old — yes, I am not counting old stuff inside a storage box that never gets to see the light of day because I don't have real use for it. Refactoring my homepage 2024-12-26T00:00:00+00:00 In my previous post</a>, I said I wanted to rebuild my blog using the principles of CUBE CSS</a> and Every Layout</a></cite>. But I decided to start with something smaller, my homepage</a>, and see how that turns out. How it looks</h2> First, let's have a quick look at the "before and after" of the rendered site: Old homepage rendered at 1920x1080.</figcaption> </figure> New homepage rendered at 1920x1080.</figcaption> </figure> They look very similar, though not identical, but this is fine. I was not aiming to exactly reproduce the same layout, but something similar that I liked. The change you probably noticed first is that now the content is centered vertically, and that was an intentional change. You might also notice a bigger contrast on the new website, with the default font color being darker. I decided to change that as part of declaring the site colors as global variables. On small resolutions, they also look nearly identical: Old homepage rendered at 375x667, resolution that Firefox labels as "iPhone SE 2nd gen iOS 14.6".</figcaption> </figure> New homepage rendered at 375x667, resolution that Firefox labels as "iPhone SE 2nd gen iOS 14.6".</figcaption> </figure> Using variables</h2> A good "developer quality of life" improvement was using CSS variables</a>. I defined them for all the colors used on the page, plus ratios for harmonic sizing</a>. Before, hexadecimal was all over the place, alongside font sizes declared in rem. Now all these properties reference variables, making it easier to keep them consistent. As mentioned before, I used the opportunity to tweak the color values to improve the contrast using a contrast calculator. I can't remember which one I used, but you can find many online that will tell you if the ratio conforms to the WCAG</a>. While working on font sizes, I realized that I did not have a maximum line length. On narrow screens, it would just wrap and break into new lines to not exceed the viewport's width, but on wide screens, the content would be as wide as the longest line. I was fortunate that none of the existing lines were too long, so it didn't look too bad, but that has now changed to a maximum of 65 characters — yes, I discovered that character is a unit</a>! — for optimal legibility. Using a CSS reset</h2> I did not have a CSS reset before, and while that seemed to be fine, I was risking the layout being off on some current or future browsers because of some unexpected defaults. I stole the one from Piccalilli</a>, using only the parts that would apply to the HTML elements on my site. If in the future I add new elements I might have to expand that. The CSS feels more clean, but there is way more of it than before</h2> I implemented the patterns for Cover</a>, Center</a>, Center with centered text</a> and Stack</a>. The HTML is clean and fully semantic with just a few div</code>s only for layout purposes: <body> <div class="cover"> <div class="center"> <div class="stack"> <header class="stack center-text"> <h1>Sergi Pons Freixes</h1> <h2>Software Engineer & Solutions Architect</h2> </header> <main class="center"> <section class="stack"> <p>Most of my open source contributions can be found on <a href="https://github.com/sponsfreixes/" target="_blank" rel="author external">GitHub</a>. Highlights:</p> <ul> <li>Creator of <a href="https://github.com/sponsfreixes/jinja2-fragments">Jinja2 Fragments</a>. </li> <li> Creator of <a href="https://github.com/sponsfreixes/htmx-flask">htmx-flask</a> and maintainer of <a href="https://github.com/edmondchuc/flask-htmx">Flask-htmx</a> after the projects got merged. </li> <li> Maintainer of <a href="https://github.com/MongoEngine/marshmallow-mongoengine">Marshmallow-Mongoengine</a>. </li> </ul> <p> If you are interested on my career, check out my <a href="cv.html">CV</a> or my <a href="https://www.linkedin.com/in/sergiponsfreixes" target="_blank" rel="author external">LinkedIn</a>. </p> <p>Contact me on <a rel="me" target="_blank" href="https://floss.social/@sergi">Mastodon</a>, <a href="https://x.com/sponsfreixes" target="_blank" rel="author external">X</a>, or at <a href="mailto:sergi@cub3.net" rel="author">sergi@cub3.net</a>.</p> <p>Oh, and I have a <a href="https://sergiswriting.com" rel="author external">blog</a>!</p> </section> </main> </div> </div> </div> </body></code></pre> With these reusable layout classes, I can picture in my head how the different blocks will be approximately rendered. The CSS for these classes makes it so that there is way more CSS than before where I just had some sprinkles of flexbox spread around. But now I feel that I can expand the site with more confidence because I have these reusable blocks to work with. Conclusion</h2> Was this change needed? No. The previous site had a decent layout, and I expect that I will very rarely add new content to it. But this was a learning exercise. Doing these changes felt good. Somehow, it feels like it's a more robust composition, easier to reason about. Both the HTML and CSS are clean and legible. In summary, the vibes are good enough that I will apply it to my CV page</a> next. After that, I will tackle this blog itself, where I expect the gains will be more quantifiable rather than just about "a good feeling". I feel excited about writing CSS 2024-09-23T00:00:00+00:00 I don't feel fully satisfied with the CSS of this blog. I handcrafted it from scratch, and while overall I like it, there are a few quirks here and there (like the spacing of list elements on some edge cases) that bother me. At the beginning of writing the CSS, it was feeling good because I was mostly targeting elements by type</a>. However, as I needed to add exceptions and customizations, I began using child combinators</a> with the types. Eventually, that was not enough, and ended also adding some classes</a> and even targeting by ID</a>. This approach isn't inherently bad, but it made me realize that I didn't have a strong guideline for what type of selector to use. I was trying to target by type as much as possible because somehow it seemed to help to enforce using semantic HTML</a>, which is a good</a> thing</a>. But that was it. All the other decisions seem too ad hoc. Something similar is happening at work. We don't have any guidelines for writing CSS or HTML; we only have them for JavaScript. Additionally, no one on the team is a web design expert who could teach the rest of us. We have been using PrimeNG</a> on most projects and dabbled a bit with Tailwind CSS</a> on a few others, but the former just gives you some pre-built components and the latter a set of utility classes (which I have a gut feeling is not the right way to go</a>). Neither of these resources teaches you about layouts or how to organize CSS properly. I started doing some research and discovered two resources that I read during my last vacation. They not only seemed to be what I was looking for, but their approach and philosophy made me feel excited about writing CSS! The first resource is the website about CUBE CSS</a>. Citing the homepage: CUBE CSS is a CSS methodology that’s orientated towards simplicity, pragmatism and consistency. It’s designed to work with the medium that you’re working in—often the browser—rather than against it. </blockquote> Among other things, CUBE CSS proposes a methodology for organizing your CSS. I'm not going to summarize or try to explain what it is. The website itself does a better job than I would. And if you don't feel like reading, there are a few videos covering the same content</a>. What I will do is highlight why I like it and cite some parts that resonate with me: It relies on the browser to do its job, in opposite of replicating/duplicating its built-in functionality like many try to do with a JavaScript-heavy approach to web development. It promotes the idea that the web is fluid and rigid layouts are destined to break:</li> </ul> The browser is hinted, rather micro-managed to do what it knows best in the context that it finds itself in. </blockquote> It doesn't force a library or tool, it's a way of thinking about vanilla CSS:</li> </ul> CUBE CSS is completely tool agnostic because it is more of a thinking and organisational methodology, rather than a tooling methodology. </blockquote> It acknowledges that CSS is not easy. It shouldn't be treated as a second-class citizen of the web, and to properly build good designs one must learn it properly, not avoid or hide it:</li> </ul> CSS is an incredibly complex programming language because a lot of knowledge is in how it works—not just how to write the syntax—which is understandably difficult when someone is used to other programming languages breaking and/or throwing errors, like JavaScript. </blockquote> While reading about CUBE CSS, I found many references to Every Layout</a>, and I realized it was a book I had seen often praised on social media and blog posts. This is the second resource I wanted to talk about. I loved it. This book is not a set of CSS tricks or a bunch of pre-packaged code ready to be copy-pasted without thinking about it. It's a philosophy, a way of creating resilient layouts and making you write good and powerful CSS. As it is focused on layouts, it's a great resource to use when building the composition layer of CUBE CSS for your site. It assumes you already know the basics of CSS, so it's not for learning CSS from scratch. But if you have some basic notions you will have no issues following it. I strongly recommend buying it if you are a web developer who does any frontend at all. Like before, I am going to mention some ideas and citations that I found very attractive and made me think "Writing CSS is fun!" It takes accessibility seriously. It is treated as any other design consideration, not as an afterthought.</li> When coming up with sizes/proportions, it relies on delegating to an algorithm how to determine the value rather than hard coding it as a px-based width.</li> </ul> To design “adaptable pages” (Allsopp’s term), we must relinquish control to the algorithms (like text wrapping) browsers use to lay out web pages automatically. But that’s not to say there’s no place for influencing layout. Think of yourself as the browser’s mentor, rather than its micro-manager. </blockquote> The layouts of Every Layout do not explore or prescribe styles for simple elements; that is for you to decide. It is the imbrication of simple elements into composite layouts that we are interested in here. </blockquote> ...it’s better to provide suggestions rather than diktats about the way the visual design is laid out. An overuse of @media breakpoints can easily come about when we try to fix designs to different contexts and devices. By only suggesting to the browser how it should arrange our layout boxes, we move from creating multiple layouts to single quantum layouts existing simultaneously in different states. </blockquote> With all that said, I'm planning to rewrite the CSS of this blog and probably of my homepage</a> using these patterns. I'll possibly write up how my experience goes after the fact. Wish me luck! Do not reinvent the wheel 2024-09-18T00:00:00+00:00 Python's standard library is awesome. Just skim through the list of available packages and modules</a>. I bet that there is something in there that you didn't know existed or that you have forgotten about it. From time to time I like to go through this list or check the Python release notes</a> to see if there is any addition that can make my life easier. It is not uncommon to forget about it and implement some functionality that already exists from scratch, and it's probably implemented in a better way. In other words, it's easy to reimplement the wheel</a>. A clear example of that is a blog post</a> I stumbled into a few weeks ago, which describes a way of checking if an IP belongs to a subnetwork. The solution on that blog post takes 83 lines of code (31 are docstrings), split into three functions: a main function and two auxiliary. With the help of the ipaddress</code></a> package from the standard library, it can be reduced to only 20 lines (9 are docstrings) and a single function, as the code is short enough for that: import ipaddress def ip_in_subnetwork(ip_address, subnetwork): """ Returns True if the provided IP address belongs to the subnetwork (specified in CIDR notation); otherwise, returns False. Both arguments should be strings. Supports both IPv4 (e.g., '192.168.1.1' and '192.168.1.0/24') and IPv6 (e.g., '2a02:a448:ddb0::' and '2a02:a448:ddb0::/44') addresses and subnetworks. """ address = ipaddress.ip_address(ip_address) network = ipaddress.ip_network(subnetwork) if address.version != network.version: raise ValueError('Incompatible IP versions') return address in network</code></pre> I want to make it clear that my intention is not to dunk on that other blog post, but I thought it was a real and good example of what can happen to anybody who doesn't know that what they need already exists. Notice that the author leverages two other packages from the standard library! In all fairness, their solution works on both Python 2 and 3, while mine is 3.3+ only. But, notice how for readers interested in a Python 3-only solution, they recommend using the 3rd party package netaddr</code>, which makes me think the author just didn't know of the existence of ipaddress</code>. Happy coding! SQLAlchemy relationship with five tables 2024-08-05T00:00:00+00:00 I had to create a relationship that needed to combine five different tables on a project I was working on. The SQLAlchemy documentation about composite secondary joins</a> has an example for combining four tables, and in this blog post, I am extending it to five. We start with a Company</code> model. That model represents, well, a company. That company will have users, which we represent with the User</code> model with a foreign key pointing to their company. In addition to that, we have Product</code> model that represents some sort of service that one or more companies might use. We model this with a Product</code> model and a ProductSubscription</code> model with foreign keys to a product and company. Each user can configure how they use a product their company is subscribed to. This is represented with a ProductUserConfiguration</code> model that contains foreign keys to the user and to the product. Putting this all together, the models look like this: class Company(Base): __tablename__ = "company" id: Mapped[int] = mapped_column(primary_key=True) name: Mapped[str] = mapped_column(String(64), nullable=False) class User(Base): __tablename__ = "user" id: Mapped[int] = mapped_column(primary_key=True) name: Mapped[str] = mapped_column(String(64), nullable=False) company_id: Mapped[int] = mapped_column(ForeignKey("company.id")) class Product(Base): __tablename__ = "product" id: Mapped[int] = mapped_column(primary_key=True) name: Mapped[str] = mapped_column(String(64), nullable=False) class ProductSubscription(Base): __tablename__ = "product_subscription" id: Mapped[int] = mapped_column(primary_key=True) company_id: Mapped[int] = mapped_column(ForeignKey("company.id")) product_id: Mapped[int] = mapped_column(ForeignKey("product.id")) class ProductConfiguration(Base): __tablename__ = "product_configuration" id: Mapped[int] = mapped_column(primary_key=True) some_setting: Mapped[str] = mapped_column(String(64), nullable=False) user_id: Mapped[int] = mapped_column(ForeignKey("user.id")) product_id: Mapped[int] = mapped_column(ForeignKey("product.id"))</code></pre> How the five models relate to each other with the foreign keys. Diagram generated with PlantUML</a>.</figcaption> </figure> Now, I want a relationship on ProductConfiguration</code> that returns the ProductSubscription</code> related to that configuration. In other words, it has to return the ProductSubscription</code> with a ProductSubscription.product_id</code> matching ProductConfiguration.product_id</code>, and with a ProductSubscription.customer_id</code> matching the User.company_id</code> of the User</code> with User.id</code> matching the ProductConfiguration.user_id</code>. Easy-peasy, right? Well, this is what it looks like as a SQLAlchemy relationship: class ProductConfiguration(Base): __tablename__ = "product_configuration" id: Mapped[int] = mapped_column(primary_key=True) some_setting: Mapped[str] = mapped_column(String(64), nullable=False) user_id: Mapped[int] = mapped_column(ForeignKey("user.id")) product_id: Mapped[int] = mapped_column(ForeignKey("product.id")) subscription = relationship( ProductSubscription, secondary="join(User, ProductSubscription, User.company_id == ProductSubscription.company_id).join(Product, Product.id == ProductSubscription.product_id)", primaryjoin="and_(ProductConfiguration.product_id == Product.id, ProductConfiguration.user_id == User.id)", secondaryjoin="and_(ProductSubscription.company_id == User.company_id, ProductSubscription.product_id == Product.id)", uselist=False, viewonly=True, )</code></pre> If you get confused with this example, try to understand the example from the SQLAlchemy documentation</a> first, as it combines only four tables instead of five, and it's a bit easier to follow. It's also interesting to read about secondary</code></a>, primaryjoin</code></a>, and secondaryjoin</code></a>. Fortunately, I don't need to forge this type of relationships often! Happy coding! Fix for Rust on Windows not able to find MySQL library 2024-07-07T00:00:00+00:00 I was tinkering with the Diesel ORM</a> on a Rust project, and when building it I faced the following error: $ cargo run Compiling tokio v1.34.0 Compiling tinyvec_macros v0.1.1 Compiling serde v1.0.193 Compiling tinyvec v1.6.0 Compiling unicode-bidi v0.3.13 Compiling pin-project v1.1.3 Compiling axum-core v0.3.4 Compiling mysqlclient-sys v0.2.5 Compiling byteorder v1.5.0 error: could not find native static library `mysqlclient`, perhaps an -L flag is missing? error: could not compile `mysqlclient-sys` (lib) due to previous error warning: build failed, waiting for other jobs to finish...</code></pre> After looking online, I found this GitHub comment</a> instructing that I needed to specify the location of mysqlclient.lib</code> using environment variables. Some old comments on that discussion say to point the environment variable to the C connector, but it seems that MySQL moved mysqlclient.lib</code> from the C connector to the Server between versions 6 and 7. So, in my case, I had to set the environment variable to $env:MYSQLCLIENT_LIB_DIR='C:\Program Files\MySQL\MySQL Server 8.0\lib'</code>. After that, success! Auto-incrementing IDs on MongoDB 2024-05-26T00:00:00+00:00 In relational databases, it is a common pattern to use auto-incremental integers as IDs for table rows. On MongoDB, if you don't set an _id</code> field on document creation, the document will get an ObjectId</a> value automatically assigned to it as _id</code>. This is fine in most cases because usually, you don't need to expose that ID to the users of the API (or on the UI presenting that data). But sometimes you might to create an ID that you want to share with the users, because they might need to reference a specific data object during conversations, and ObjectID values are not suited to that. For example, it's easier to say "Hey, invoice INV-204 is still due" than "Hey, invoice 507f1f77bcf86cd799439011 is still due". One way to accomplish that is using triggers</a>, but that's a feature only available on MongoDB Atlas</a> and not for the self-hosted product. The alternative is to use a collection as a counter for sequences. I found the concept explained on an old version of the official documentation</a>, but I couldn't find it on the newest version. Anyway, the idea is to have a collection that will be dedicated to keep track of auto-incrementing IDs. For each collection where you want to use an ID of this kind, you will have a document on this collection. What makes it work is to make sure that we are generating the new value and updating the collection storing it atomically. This is, that they happen on the same step. We want to avoid this scenario: Assume our current stored latest ID is 41.</li> Thread A tries to generate a new ID. It checks the latest stored ID, and it increments it by 1 to get 42.</li> Thread B tries to generate a new ID. It also checks the latest stored ID, which is still 41, so it decides the next one is 42.</li> Thread A stores 42 as the latest ID.</li> Thread B stores 42, again, as latest ID. Problem #1: we didn't auto-increment properly.</li> Thread A stores a document (using the same example as before, an invoice) using that ID, so invoice number 42.</li> Thread B stores also tries to store a new invoice, using the same ID. This is going to create problem #2, a clash of IDs.</li> </ol> Instead, we want: Assume our current stored latest ID is 41.</li> Thread A tries to generate a new ID. It checks the latest stored ID, it increments it by 1 to get 42 and it stores that new value in the database. All these 3 steps (fetch, increment, and store) happen as a single operation.</li> Thread B tries to generate a new ID. It also checks the latest stored ID, which is now 42, so it decides the next one is 43. Like before, it will fetch, increment, and store the new value in a single operation.</li> Thread A stores a document using that ID, so invoice number 42.</li> Thread B stores also tries to store a new invoice, which will be invoice 43.</li> </ol> The following is how to implement this solution with Python using MongoEngine</a>. Specifically, to create invoice IDs as INV-{invoice_number}</code>. The solution can easily be ported to PyMongo</a>, but I like to use MongoEngine to help with data validation and treat data as objects and not as dictionaries. from mongoengine import Document, fields # This is the collection that will store sequences and their values class Sequence(Document): id = fields.StringField(primary_key=True) value = fields.IntField(required=True, default=0) # This function is used to generate and store a new value for a given sequence def get_next_id(sequence_name: str) -> int: sequence = Sequence.objects(id=sequence_name).modify( upsert=True, new=True, inc__value=1 ) return sequence.value # Function to generate invoice IDs def generate_invoice_id() -> str: invoice_number = get_next_id("invoice") return f"INV-{invoice_number}" # Our example Invoice class leveraging the autogenerated invoice ID class Invoice(Document): id = fields.StringField(primary_key=True, default=generate_invoice_id) description = fields.StringField(required=True) dollar_amount = fields.Decimal128Field(required=True) # Sample code to create and save a new invoice new_invoice = Invoice(description="Writing a blog post", dollar_amount=1000) new_invoice.save()</code></pre> Happy coding! Enabling OpenSSL for Rust in Windows 2024-05-08T00:00:00+00:00 The other day I was compiling a Rust project on a Windows 11 environment, and when executing cargo run</code> and I got the following error: error: failed to run custom build command for openssl-sys v0.9.93 ... note: vcpkg did not find openssl: Could not find Vcpkg tree: No vcpkg installation found. Set the VCPKG_ROOT environment variable or run 'vcpkg integrate install'</code></pre> According to the openssl crate documentation</a>, you can locate the OpenSSL libraries using 3 ways: vendored, automatic or manual. I didn't want to use the vendored</a> option because I didn't want to modify that project's Cargo.toml</code>. First I tried the automatic</a> way, which consisted on: Installing vcpkg</code></a>.</li> Executing ./vcpkg/vcpkg.exe install openssl</code></li> </ol> But that was not enough. It was still failing to locate the OpenSSL library. So I ended following the instructions for the manual</a> approach. This approach required me to not only perform the two steps mentioned above of the automatic approach, but also set the following environment variables: $env:OPENSSL_LIB_DIR="C:\Users\sergi\vcpkg\packages\openssl_x64-windows\lib" $env:OPENSSL_INCLUDE_DIR="C:\Users\sergi\vcpkg\packages\openssl_x64-windows\include" $env:OPENSSL_DIR="C:\Users\sergi\vcpkg\packages\openssl_x64-windows"</code></pre> After that, cargo was happy and everything worked as expected! How to rotate Gunicorn log files 2024-04-12T00:00:00+00:00 A few weeks ago I found myself scratching my head about missing records on the log files of a Flask</a> application running with Gunicorn</a>. I knew that the requests had been performed and should have been logged, but they were nowhere to be found. While investigating, I noticed that the rotated log files had way less records than what I expected. Something was going on. After some online surfing, I found out the following crucial pieces of information: Python's standard library logging is thread safe but not process safe.</li> Gunicorn logs are written by the worker processes, not by the master process.</li> </ul> I figured out that because I was using TimedRotatingFileHandler</code></a> to rotate the log files daily, I was running into a situation where each worker was not only trying to write to the same file, but each worker also tried to handle the file rotation. I'm not sure how all these pieces interacted (when was data flushed to disk, if a worker was overwriting other workers' output, etc.), but definitely there was a conflict that was resulting on data being lost. And I was not alone on being confused about rotating Gunicorn logs. A sample: Gunicorn GitHub issue: [Design Question] How do gunicorn workers log correctly?</a></li> Gunicorn GitHub issue: (forum) logging from each worker</a></li> Loguru GitHub issue: Issues with rotate</a></li> Uvicorn GitHub issue: Gunicorn+UvicornWorker,access log not working after logrotate access log file.</a></li> </ul> So, I ended taking a pragmatic approach to see by myself how different configurations would work out. I created an environment where I had Gunicorn running a Flask application with 10 Sync workers. I used k6</a> to generate 1000 requests per minute during 3 minutes, which should generate 3000 log records. I recreated this setup with 3 different configurations, but always with a rotation set to 1 minute (or to 500KBs per file, which seemed to be the amount of records generated per minute): Python/Gunicorn handling the rotation with TimedRotatingFileHandler</code>: at the end of the test I had less than 200 log records among the 3 rotated files. Lots of records lost! </li> Python/Gunicorn writing to a single file with the default FileHandler</code></a>, and logrotate</a> handling the rotation: all the log records kept being written to the first file even after being rotated. So I ended with the most recent non-rotated file with 0 entries and a rotated file with 3000 records. </li> Python/Gunicorn writing to a single file with the WatchedFileHandler</code></a>, and logrotate handling the rotation: the log records were distributed evenly among the different rotated log files, for a total of 3000 records! Success! </li> </ol> If you found yourself with the same issue, this is the winning configuration: gunicorn_logging.conf</code> ; ... [handler_json_log_file] class=logging.handlers.WatchedFileHandler formatter=json ; filename, mode='a', encoding=None, delay=True, errors=None args=('/path/to/my/log_file.log', 'a', None, True, None) ;... </code></pre></blockquote> logrotate.conf</code> /path/to/my/log_file.log { daily rotate 100 create missingok notifempty }</code></pre></blockquote> Happy logging! Best practice for importing the datetime</code> module in Python 2024-02-04T00:00:00+00:00 The datetime</code> module is one of the most controversial</a> Python imports. That both the module and the class share the same name is unfortunate. I've seen many bugs caused by a developer using one thinking they are accessing the other because they didn't check how the import was done, and their IDE did not warn them. The practice I've been putting in place with great success at the teams I've worked on is to use the following form: import datetime as dt # Examples of usage: published_on = dt.datetime(2024, 2, 4, 22, 12) today = dt.datetime.today() five_seconds = dt.timedelta(seconds=5) </code></pre> The benefits of this form are: It removes the ambiguity of datetime</code> being the module or the class: If you know the convention, you know that dt</code> is the module and dt.datetime</code> is the class.</li> If you don't know the convention, and see code using it, it's intuitive to figure out that dt.datetime</code> is the class and not the module. Worst case, you will check the import statement to confirm that, as it's a pattern you haven't seen before.</li> If you don't know the convention, and want to use datetime</code> on a file where the proposed form is used, you won't accidentally just use datetime</code> because it's not imported as import datetime</code> or from datetime import datetime</code> (I am assuming here that your IDE would warn you of undefined names/variables). That will force you to go to the import section and discover that it's using import datetime as dt</code>.</li> </ul> </li> It frees the namespace to use datetime</code> and date</code> as variables. But be careful with that! Make sure you are using it on a small scope where another developer can see without scrolling that they are defined variables. Otherwise, there is the possibility of somebody not paying attention try to use them as the module or the class.</li> It's more beautiful than datetime.datetime</code> :D</li> </ul> One could argue: well, if you are just going to adopt a convention and make sure the whole team uses it, why not stick to import datetime</code> or from datetime import X</code>? If everybody knows, it's fine! The issue with that is existing code. If people have been mixing styles, you might open an old file, try to use datetime</code>, see that is available in that namespace and wonder "Uh... is this already using the new convention"? On the other hand, if you find dt</code> available on the namespace, it is almost guaranteed (unless somebody has been very creative with their imports) that the file is already using the convention. All that said, nowadays, decent IDEs like PyCharm are able to figure out if you are working with the module or the class, making the whole post a bit of a moot point on some aspects. Still, consistency on coding is key, so if you don't adopt this form, at least consider choosing one for everybody on your team to use. Happy coding! Tip: Speed up Python dictionary lookups 2024-01-14T00:00:00+00:00 Last week at work, there was a conversation about managing a fairly large key-value data structure using Python. A colleague recommended checking sys.intern</code> to improve performance. I can't add much beyond what's already covered in the documentation</a>: sys.intern(string)</code> Enter string in the table of “interned” strings and return the interned string – which is string itself or a copy. Interning strings is useful to gain a little performance on dictionary lookup – if the keys in a dictionary are interned, and the lookup key is interned, the key comparisons (after hashing) can be done by a pointer compare instead of a string compare. Normally, the names used in Python programs are automatically interned, and the dictionaries used to hold module, class or instance attributes have interned keys. Interned strings are not immortal; you must keep a reference to the return value of intern()</code> around to benefit from it. </blockquote> I thought it would be nice to not only share the existence of that, but to provide code examples of how to use it. I concocted these examples, but when I measured the performance of the code using "interned" strings and the code using "regular" strings, the timings were the same. I iterated a few times to see if I was misunderstanding something, but long story short, I gave up and decided to post on Stak Overflow</a>. The answer to this enigma was humbling</a>. I wasn't aware of Python's optimizations on string handling. Nick does a good job explaining them, and then offering an actual example where you can see how to use interning effectively. In conclusion, my advice would be this: whenever you come across claims of a performance boost, verify for yourself that it's actually effective in your specific use case! Better colors for moved text in Git 2024-01-06T00:00:00+00:00 If you move a block of text/code around, and then you run git diff</code>, you will see that the moved text is displayed like any other change. If you are using the default colors, the old location will show in red and the new one in green. So, we can't quickly tell if that change only involves moving that block around, or if in addition to the displacement something has actually changed inside the block. Well, Git has a setting to change that behaviour: color-moved</code>. According to the documentation</a>, at the date of this article, there are 6 different modes. I recommend trying them out and see which one you like the most. With the couple of examples I tried I couldn't appreciate a difference between plain</code> and zebra</code>, so I think I'll stick to zebra</code> as I liked it more than the others. I must say that I got very confused reading that the default behaviour is not the default</code> mode, but the no</code> mode. If you don't know how to set this setting, you have two ways. One is running the command git config --global diff.colormoved "zebra"</code>. The other is manually editing the config file. If you have a .gitconfig</code> file on your home directory or on your repository, add the following lines: [diff] colormoved = "zebra"</code></pre> Another setting related to moving code that is very useful is color-modev-ws</code>. Citing the documentation</a>: This configures how white spaces are ignored when performing the move detection for --color-moved. </blockquote> What does that mean? Well, it is not rare that when moving a block of code we change its indentation. Maybe the block was inside a top level function (one indentation level) and now it's inside a method inside a class (two indentation levels). If you set this setting to allow-indentation-change</code>, the diff will be more "clever" and figure out that this is still only a block displacement and not a regular text modification. So, it will apply the right colors on the diff according to your color-moved</code> setting. This post was inspired by matklad's post Git Things</cite></a>, where they briefly mention both settings explained above. Happy coding! How to create a Linux Desktop entry for PyCharm 2023-12-19T00:00:00+00:00 Unless your Linux distribution offers a package for PyCharm, you have to download a tar.gz from JetBrains' website</a>, unpack it, and then run the PyCharm.sh</code> script. There is no installer; PyCharm launches directly. Since you are likely using a Desktop environment (PyCharm being a graphical IDE), you may want want a convenient Desktop launcher to avoid opening a shell just for that. Well, the folks at JetBrains already provide this option, but it is a bit hidden. Start Pycharm, then on the menu bar, go to Tools > Create Desktop Entry...</code>, and that's it! This will create the file jetbrains-pycharm.desktop</code> either in ~/.local/share/applications</code> or on /usr/share/applications</code> if you selected "Create the entry for all users". Your Desktop environment should pick it up automatically and display it on you list of applications. Happy coding! How to pair a Bluetooth keyboard in Windows 11 2023-12-15T00:00:00+00:00 I am the happy owner of a Leopold FC660MBT Vapor 65% Bluetooth</a>. I decided that this would be my in-office keyboard instead of the cheap one provided at my current company. My work computer is a ThinkPad laptop running Windows 11, so I was expecting the pairing to be smooth as butter. To my surprise, when I tried to pair it, Windows greeted me with a dialog asking for a PIN. Well, that's funny. Asking to enter a PIN to be able to use the device that would allow you to actually type that PIN. Fortunately, it's a laptop, and I can use the built-in keyboard instead. Asking the user to type a PIN to be able to connect a keyboard. Something about that seems wrong.</figcaption> </figure> But then, what PIN? Maybe it's a default value the manufacturer provides on the manual. Nope, nothing there. Maybe it's on the frame or on some sticker? Nada. Confusion. After searching online, I finally found a forum post with the solution</a> that worked for me. I summarize it here: using a working keyboard, type 0000 as the PIN and accept. Then on the new keyboard, type 0000 and press Enter. So easy but at the same time so arcane. Many people on that linked post report that it didn't work for them. So, if you are reading this article because you are in this situation, I wish you the best of luck! This is a blog 2023-11-15T00:00:00+00:00 I used to have a blog. It was a mixture of tech articles — mostly about Linux, Open Source and privacy — and random ramblings. I wrote on different languages, depending on whom I thought could be interested on reading a particular article. As many blogs, it eventually died of inactivity. I kept it around for many years in case some tech articles were still useful for somebody. At some point I considered that these articles were obsolete, so I got rid of it. I must have a backup somewhere for nostalgic reasons. During the past few months I've started doing more contributions to open source projects than I did before. I like to think that I've also grown professionally, and there are some thoughts that I've considered sharing as they could be useful to others. And then, I joined Mastodon</a>, and found like-minded peers much easier than I did on Twitter — aka X — and re-discovered that personal blogs are way better than social media</a> for some content and RSS is coming back!</a> So, here it is. A blog. Photo by Pixnio</a></figcaption> </figure>

Jailbreaking</h2>
The Kindle Keyboard can be jailbroken to customize it or extend its capabilities, but I never felt the need to do it, so I didn't. I have nothing else to say about it ¯\_(ツ)_/¯.</p>

Sergi's writing

This blog got a new favicon thanks to the Small Web

Ditch Postman, use Bruno

My favourite Python library for calculating dice probabilities

I tried to opt-out of airlines selling my data to the government, and I am not sure if it worked

Arrow functions are overused

Bringing back the scrollbars

How to fix a Pixel Watch stuck on Fastboot

Ode to the Kindle Keyboard (Kindle 3)

Refactoring my homepage

I feel excited about writing CSS

Do not reinvent the wheel

SQLAlchemy relationship with five tables

Fix for Rust on Windows not able to find MySQL library

Auto-incrementing IDs on MongoDB

Enabling OpenSSL for Rust in Windows

How to rotate Gunicorn log files

Best practice for importing the `datetime</code> module in Python`

Tip: Speed up Python dictionary lookups

Better colors for moved text in Git

How to create a Linux Desktop entry for PyCharm

How to pair a Bluetooth keyboard in Windows 11

This is a blog

Sergi's writing

This blog got a new favicon thanks to the Small Web

Ditch Postman, use Bruno

My favourite Python library for calculating dice probabilities

I tried to opt-out of airlines selling my data to the government, and I am not sure if it worked

Arrow functions are overused

Bringing back the scrollbars

How to fix a Pixel Watch stuck on Fastboot

Ode to the Kindle Keyboard (Kindle 3)

Jailbreaking</h2> The Kindle Keyboard can be jailbroken to customize it or extend its capabilities, but I never felt the need to do it, so I didn't. I have nothing else to say about it ¯\_(ツ)_/¯.</p>

Refactoring my homepage

Conclusion</h2> Was this change needed? No. The previous site had a decent layout, and I expect that I will very rarely add new content to it.</p>

I feel excited about writing CSS

Do not reinvent the wheel

SQLAlchemy relationship with five tables

Fix for Rust on Windows not able to find MySQL library

Auto-incrementing IDs on MongoDB

Enabling OpenSSL for Rust in Windows

How to rotate Gunicorn log files

Best practice for importing the datetime</code> module in Python

Tip: Speed up Python dictionary lookups

Better colors for moved text in Git

How to create a Linux Desktop entry for PyCharm

How to pair a Bluetooth keyboard in Windows 11

This is a blog

Jailbreaking</h2>
The Kindle Keyboard can be jailbroken to customize it or extend its capabilities, but I never felt the need to do it, so I didn't. I have nothing else to say about it ¯\_(ツ)_/¯.</p>

Best practice for importing the `datetime</code> module in Python`