rss.xml

<feed xmlns="http://www.w3.org/2005/Atom">
    <id>https://swiftrocks.com</id>
    <title>Bruno Rocha</title>
    <subtitle>SwiftRocks is Bruno Rocha's blog about Swift / iOS and the software engineering industry.</subtitle>
    <updated>2026-08-10T16:00:26+0200</updated>
    <author>
        <name>Bruno Rocha</name>
        <uri>https://swiftrocks.com</uri>
    </author>
    <link rel="self" type="application/atom+xml" href="https://swiftrocks.com/rss.xml"/>
    <link rel="alternate" type="text/html" hreflang="en" href="https://swiftrocks.com"/>
    <generator uri="https://github.com/rockbruno/writeit">WriteIt</generator>
    <rights> © 2026 Bruno Rocha </rights><entry>
    <title>Using AI while exercising your critical thinking</title>
    <link href="https://swiftrocks.com/using-ai-without-losing-critical-thinking" rel="alternate" type="text/html" title="Using AI while exercising your critical thinking"/>
    <published>2026-08-09T09:00:26+0200</published>
    <updated>2026-08-10T16:00:26+0200</updated>
    <id>https://swiftrocks.com/using-ai-without-losing-critical-thinking</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>It doesn't matter how capable a lab claims a latest model is, every single AI model suffers from the same problems of regularly jumping to conclusions, forgetting instructions, and hallucating information.</summary>
    <content type="text/html"><![CDATA[
<p>The industry has been using the term <b>AI Psychosis</b> to describe a person who “blindly” believes everything that AI says, leading to scenarios where, if the person fails to realize the AI may be mistaken about a particular subject, they may develop strong beliefs in concepts that were based on either false assumptions or outright made-up information on behalf of the AI.</p>
<p>In software engineering, one common example that the industry has been observing is when someone opens a pull request with a very long AI-generated description of a problem and a very confident description of why the proposal in the PR is the correct solution for it, but one deep look is all it takes to realize that <b>nothing in that description actually makes sense.</b> The PR doesn’t really solve anything, at best it’s just moving the problem elsewhere. Every claim made by the description turns out to be false, making it just a big word salad that looks convincing at a glance but is complete nonsense when you take the time to analyze it.</p>
<p>This is a very real problem. But I think “psychosis” is a really bad way to describe it. Psychosis is a medical condition, and there’s nothing medical about this. It’s simply the consequence of trying to use AI without first understanding what AI “is” and how the tech that powers it works.</p>
<p>I personally think the term <a href="https://addyosmani.com/blog/cognitive-surrender/">cognitive surrender</a> (or the recently coined more casual equivalent <a href="https://gruhn.me/blog/2026-08-03/">meat proxy</a>) is a much better way to describe it because it perfectly captures the problem: it’s not that people are getting “crazy”, but rather that they are failing to apply critical thinking to the AI’s responses, often simply due to a lack of understanding that the AI can (and will, <b>constantly</b>) make mistakes.</p>
<p>I’ve written posts in the past about how there’s no right or wrong in software engineering, but I think this topic is a valid exception as I cannot think of a single reason why acting as a “meat proxy” for the AI could be a good idea. If a person simply proxies what the AI says, <b>are they really bringing any value to the table?</b> Anyone can prompt AI nowadays, so there is no value in simply relaying its responses. If someone just bounces whatever the AI tells them, it would be easier for someone interacting with said person to just prompt the AI directly and skip the person entirely, wouldn’t it?</p>
<p>This means that what has value in this new way of working and sets you apart from other engineers <b>is your ability to apply critical thinking to what comes out of the AI.</b> It’s then critical that <b>when you work AI, you need to be aware of the technology’s shortcomings and have strategies to manage each of them.</b></p>
<h2>How to work with AI while being in control of the narrative</h2>
<p>Given this context, here are my personal guidelines and advice on how to avoid this problem and use AI without losing grasp of your critical thinking skills:</p>
<h3>Understand the paradigm is AI-assisted development, not AI-independent development</h3>
<p>It doesn't matter how capable a lab claims a latest model is, every single AI model suffers from the same problems of regularly jumping to conclusions, forgetting instructions, and hallucinating information. <b>Newer models will not solve this</b>, this is a flaw of LLMs as a technology and will continue to exist for as long as the underlying tech itself doesn't change. Any time you see a lab claim that they solved any of these problems is pure marketing. Remember when OpenAI said that <a href="https://naokishibuya.github.io/blog/2022-12-30-gpt-2-2019/">GPT-2 was too dangerous to be released</a>? The same model turned out to barely stay in line for more than a prompt!</p>
<p>This means that for complex prompts where you expect the AI to do a lot of research, <b>you should always watch the AI as it does its thing</b> and make it sure it's going the right way. If it starts to make weird assumptions, you should interrupt it and guide it back the right way. I find that letting the AI work on its own with zero oversight can work well for simple requests, but in my experience this rarely works for complex pieces of work. No matter how many details you provide it's pretty much guaranteed that it will make wrong assumptions at some point and start building the wrong thing.</p>
<p>If you want to develop a deeper understanding of why LLMs suffer from these problems, I find that there's nothing better than <b>building one yourself.</b> Andrej Karpathy (arguably the number 1 expert on the topic in the world) has several <a href="https://www.youtube.com/watch?v=7xTGNNLPyMI">educational videos</a> and tutorials on how LLMs work and how to build them, and they are all incredibly well written and easy to follow.</p>
<h3>Always challenge the AI's claims</h3>
<p>You should also have a habit of challenging and double-checking everything the AI produces. I originally did this by asking things such as "how do you know this?" or "give me proof", but nowadays I'm using a <b>stop hook</b> to do that automatically every time the AI claims to have found something. This nudges the AI to not jump to conclusions and actually perform research and provide proof. <b>Note that using a system prompt will not work</b> because one of the issues we're fighting here is that the AI tends to sometimes ignore instructions, so system prompts alone are not reliable in this case.</p>
<p>When the AI provides proof for a claim, endure the urge to blindly believe it. If it's a link for example, actually open the link and confirm that the information is there (and that it's not also AI-generated). This is because there will be many cases where the "proof" is also something the AI completely made up. This challenging process thus goes on until the proof is indisputable.</p>
<h3>(For code changes) Read the generated code line by line</h3>
<p>This issue is something that I do think newer models will improve, but I think it will always be good to do regardless to prevent you from losing your coding knowledge.</p>
<p>If you followed the previous two guidelines, you will end up with code that works. However, that doesn't mean the code is structured the best way it could. At least with today's models, the result will probably be massively overcomplicated, full of duplication, zero separation of concerns, wrong handling of edge cases, basically all the mistakes you'd do as a beginner.</p>
<p>I then think it's a good idea to go over the generated code for two reasons: 1) to make sure the code is structured correctly and handles the neccesary edge cases, and 2) <b>to make sure you actually understand what has changed in the code.</b> This second reason is particularly important because many have been feeling that they are losing their programming skills as a result of their AI usage, so I think that even though newer models might eliminate the code quality problem, going over the code may always be useful at least to prevent you from losing your skills and knowledge and retain your understanding of how the code works.</p>
]]></content>
</entry><entry>
    <title>Everything about my smart home and homelab setup</title>
    <link href="https://swiftrocks.com/everything-about-my-smart-home-and-homelab-setup" rel="alternate" type="text/html" title="Everything about my smart home and homelab setup"/>
    <published>2026-08-02T09:29:03+0200</published>
    <updated>2026-08-02T09:29:03+0200</updated>
    <id>https://swiftrocks.com/everything-about-my-smart-home-and-homelab-setup</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>I've written a couple of posts in the past about how my home network and home automation setup is laid out, but it changed so much over time that it's now time for an updated post! This time I'll put everything together in the same post.</summary>
    <content type="text/html"><![CDATA[
<p>I've written a couple of posts in the past about how my home network and home automation setup is laid out, but it changed so much over time that it's now time for an updated post! This time I'll put everything together in the same post.</p>
<!-- <div class="sponsor-article-ad-auto hidden"></div> -->
<h2>Part 1: Network stack</h2>
<p>My network infra is entirely <b>Ubiquity</b> hardware for a simple reason: <b>I wanted something that was designed for power users, but also that didn’t have too much of a learning curve.</b> While I usually fit the criteria of a mega power user for this type of stuff, modern networks are extremely complicated, so I preferred to stop somewhere in the middle of the curve to avoid the stress of being unable to use the internet due to misconfigurations.</p>
<p>By the way, before starting, <b>I would like to note that this setup is extremely overkill for the average home network!</b> I went for this simply because I thought it was cool, so if you’re reading this because you’re looking for equipment recommendations, keep in mind that something considerably less powerful would most likely already do the trick for you.</p>
<h3>Router: Cloud Gateway Fiber</h3>
<p>For the router, I chose the <a href="https://techspecs.ui.com/unifi/cloud-gateways/ucg-fiber?subcategory=all-cloud-gateways">Cloud Gateway Fiber</a> as this router is a complete bargain for what it brings to the table. Not only does it have <b>three 10 Gbps ports</b> (one of them being RJ45), including one for WAN, it even has a PoE+ port that can power an AP. Usually something like this would be extremely expensive, but for some reason it just… isn’t, and I guess the market agrees, because finding one of these is a massive challenge. They are constantly sold out almost everywhere as of writing.</p>
<h3>AP (WiFi): U7 Pro XG</h3>
<p>For the AP, I chose the <a href="https://techspecs.ui.com/unifi/wifi/u7-pro-xg?subcategory=all-wifi">U7 Pro XG</a>, which is a WiFi 7 router with support for the 6 GHz band. This thing even has a 10 Gbps uplink for some reason which I can’t even use as the PoE+ port on the router is “only” 2.5 Gbps, but it was a very cheap upgrade compared to the regular version, so it seemed like a no-brainer. Luckily I do have WiFi 7 devices around already (the newest iPhones), so I can and am already making use of it.</p>
<h3>Switch: Flex 2.5G</h3>
<p>I prefer connecting things via Ethernet for maximum performance and reliability, so I chose a <a href="https://techspecs.ui.com/unifi/switching/usw-flex-2-5g-8?subcategory=switching-utility">Flex 2.5G switch</a> particularly because it has the same SFP+ port that the router has, allowing me to connect the two via fiber and get a clean 10 Gbps connection between them. I also have a second switch of the smaller variant on the opposite end of the apartment. Naturally this means I have long Ethernet cables running through the ceiling to reach all the different rooms of the apartment.</p>
<h3>DNS: Pi-Hole</h3>
<p>I have a simple <b>Raspberry Pi 3b running Pi-Hole</b> to act as my personal DNS server. It runs Unbound and has a cron job to update the root DNS server list every month. I do not enable it globally though; only certain devices make use of it because I want to prevent guests from having issues as the Pi-Hole makes certain types of websites a bit harder to navigate (sometimes it blocks more than it should and breaks the website).</p>
<h3>VPN: WireGuard</h3>
<p>My router has native WireGuard support, so I use it to have my phone connect to my home network whenever I'm not connected to my home Wi-Fi. The main use for this is for me to make use of the Pi-Hole anywhere, so as a result the VPN automatically sets the Pi-Hole as the DNS server for its connected devices. I also sometimes use it to access the router's admin console remotely. Nothing else is routed through this VPN.</p>
<h3>IP Stack: IPv4 and IPv6 Dual Stack</h3>
<p>I went through the trouble of enabling and configuring IPv6 on my network for no reason other than I thought it would be cool. Every VLAN and firewall feature mentioned below then accounts for both IPv4 and IPv6. When it comes to IPv6, the internal networks use SLAAC to distribute the prefixes and have ULAs set up to make writing the IPv6 variant of each firewall rule easier.</p> 
<h3>VLAN and Firewall setup</h3>
<p>My network today consists of a combination of “regular” devices (like my phone), servers, and random IoT devices. To connect these effectively and securely, I went for the following setup:</p>
<ul>
<li><b>VLAN1: Management</b></li>
<ul><li>Contains only the Ubiquity hardware. Has full access to everything.</li></ul>
<li><b>VLAN10: Trusted</b></li>
<ul><li>Phones, computers, and my local servers (Pi-Hole, etc). Has <i>mostly</i> full access to everything, apart from gateway / admin console access which I have made so that only certain devices can access.</li></ul>
<li><b>VLAN20: IoT</b></li>
<ul><li>Everything home automation related that works via Wi-Fi. This VLAN is <b>completely locked down from everything.</b> It has no external internet access, and they cannot even contact each other (via Wi-Fi client isolation). They are only allowed very specific IP+port exceptions that I control at the firewall level, such as allowing some of the devices to send specific bits of information to my Home Assistant for automation purposes. Otherwise they cannot do anything.</li></ul>
<li><b>VLAN90: VPN</b></li>
<ul><li>Powers the WireGuard integration mentioned above. Fully locked down by default, with only a set of minimal firewall rules to allow my phone's IP to access the Pi-Hole and the admin console.</li></ul>
</ul>
<h3>Wi-Fi</h3>
<p>My AP exposes three Wi-Fi SSIDs:</p>
<ul>
<li><b>"Max" network:</b> 5GHz and 6GHz bands, WPA3, Wi-Fi 7 features, basically a network that only has modern features enabled for modern devices.</li>
<li><b>"Legacy" network:</b> 2.4GHz band and none of the modern stuff enabled. Used for older devices like the Nintendo Switch that cannot connect to the "Max" network for some reason (either because it only supports 2.4Ghz or because one of those modern features causes it to not work properly)</li>
<li><b>"IoT" network:</b> Similar to the "Legacy" network, but even more stripped down. Connects the device to the isolated IoT VLAN.</li>
</ul>
<p>To maximize performance and efficiency, every once in a while I use the AP's radio scanning features to find the most optimal settings for things such as channel selection and transmit power for each band.</p>
<h3>Final thoughts on Part 1</h3>
<p>I’m very satisfied with my hardware and setup choices. As I mentioned above this is all extremely overkill for what I actually use my home network for, but doing so resulted in me vastly increasing my networking knowledge and capabilities and that was my main goal here :)</p>
<h2>Part 2: Smart Home / Home Automation</h2>
<p>Everything in my smart home revolves around two main devices: A Home Assistant server and an Alexa.</p>
<p>I use <a href="https://www.home-assistant.io/">Home Assistant OS</a> like many others. The way I like to describe HA is that it's an Alexa on steroids. With an Alexa, you buy smart devices, link them with the Alexa, and then set up automations to control those devices based on conditions like time, weather, and so on. But the problem with Alexas is that 1) the devices <i>must</i> support Alexas specifically, and 2) the automations themselves are very limited, only allowing you to do simple things.</p>
<p>Home Assistant doesn't have such limitations. HA is <b>open-source</b> and has a thriving community, meaning you can find plugins that enable integrations for pretty much <b>anything</b> you can think of, and if you don't, you can build such plugins yourself assuming you have the programming chops to do it! HA is very extensible, and thus perfect for power users who want to set up complex automations or integrate unusual devices in unusual ways.</p>
<h3>Primary Main Server: Raspberry Pi 5 w/ Zigbee Dongle running HAOS</h3>
<p>For a long time, my hardware for running HAOS used to be a simple Raspberry Pi 3b and an SD card. The HA community tells you that this is a bad idea (The 3b is weak and SD cards can die if you use them too much), but in my experience this is fine as long as you don't have too many devices / automations / integrations. It's a good starting point, and it did the trick for me for a couple of years until I started wanting to do more complicated integrations.</p>
<p>Nowadays, I've retired the 3b in favor of a <b>Raspberry Pi 5 w/ 8GB RAM, with a 256GB official RPi NVMe SSD and enclosed in the Argon One V3 case.</b> This gives HA enough power and cooling to do everything that I need with ease.</p>
<div class="post-image">
  <img src="https://i.imgur.com/CRUuh6Q.png">
</div>
<p>Today I run the server via a wired connection, but there was a long period of time where I was running it through Wi-Fi. The community says that this is a bad idea for latency reasons, but I never had any such issues. While the wired connection is definitely much faster, the Wi-Fi latency never really bothered me, so I can confirm it's totally fine to run HA over Wi-Fi if you can't run a cable to it.</p>
<p>The server has a <a href="https://www.amazon.se/-/en/ZBDongle-EFR32MG21-Coordinator-Universal-Assistant/dp/B0BRCWXMSF?th=1">Sonoff ZBDongle-E</a> USB antenna plugged into it to allow HA to recognize and drive Zigbee devices, which I'll mention in more detail further below.</p>
<h3>Secondary Main Server: Amazon Alexa for voice control and Matter bridging</h3>
<p>In conjunction with the HA server, I use an Alexa to do two things my HA server can't do by itself: <b>voice control and Matter bridging</b>. Since I don't have the HA's dedicated Matter antenna, I use the Alexa to host any Matter devices I purchase and then use HA's <a href="https://github.com/RiDDiX/home-assistant-matter-hub/">Matter Hub custom integration</a> to allow the Alexa to "share" these devices with my HA server. This allows me to control everything via the HA UI even though in practice some of the devices are actually "owned" by the Alexa itself. I then also use the same integration to do the <b>opposite</b> (share devices "owned" by HA with the Alexa), allowing me to control everything and anything via voice commands.</p>
<h3>Dashboard Tablet</h3>
<p>I'm using a generic Huawei Android tablet under my TV to serve not only as a physical dashboard, but also as a digital photo album when idle:</p>
<div class="post-image">
  <img src="https://i.imgur.com/hETOc60.png">
</div>
<p>The dashboarding functionality itself is achieved by using <a href="https://wallpanel.xyz/">Wallpanel</a> to expose the tablet's controls to HA, while the photo album logic is handled via HA's <a href="https://github.com/j-a-n/lovelace-wallpanel">lovelace-wallpanel</a> custom integration. I host the photos on HA itself. Since this is a Wi-Fi device, it connects to the IoT VLAN to fully isolate it from the external world (especially because this is a Chinese Android device).</p>
<h3>Communication: Wi-Fi, Bluetooth, Zigbee, Matter (Thread)</h3>
<p>My smart devices implement different protocols depending on the type of device, with Zigbee currently comprising the great majority of them and Matter via Thread (the Matter "equivalent" of Zigbee) slowly catching up.</p>
<p><b>If you have no idea what these words mean,</b> Zigbee and Thread are alternative wireless radio communication systems made specifically to be used by IoT devices. Unlike Wi-Fi, they use very little energy and lay out a mesh network where the devices can propagate information to each other (as opposed to Wi-Fi's "star" network where everything has to go through the router), making them perfect for home automation setups.</p>
<div class="post-image">
  <img src="https://i.imgur.com/6sxx3bR.jpeg">
</div>
<p>Matter on the other hand is simply a protocol designed to accommodate the fact that different devices might require communication capabilities. Back in the day there would be no straightforward way to make a Wi-Fi device talk (for example) to a device that <b>didn't</b> also use Wi-Fi, but today if both these devices implement Matter, they will be able to communicate as long as you have a <i>third</i> device somewhere that can act as a "translator" between these two two devices (referred to in the protocol as a "border router"). That's why when you purchase a Matter device that uses Thread you'll see a note that you need a "Thread border router" to use it; your home is primarily a Wi-Fi/Ethernet network, so something needs to be able to translate that from-and-to Thread commands for you to be able to plug it on said network. Most modern smart home hubs like the Alexa can act as such routers and are advertised as such.</p>
<p>The reason I use Zigbee the most is simply that Matter via Thread was not yet a thing when I first bought these devices. Most new devices nowadays seem to not support Zigbee at all (opting to use solely Matter via Thread instead), so I expect that little by little my Zigbee usage will reduce until everything operates via Matter.</p>
<h3>Proxying Bluetooth with ESP32s</h3>
<p>Another critical component of my smart home worth mentioning is <b>Bluetooth Proxying</b>. Some of my devices operate via Bluetooth (curtain motors, plant monitors), but because the HA server itself is in a cabinet, they get zero signal that way.</p>
<p>The solution to that is to have a device that acts as a bridge between Wi-Fi and Bluetooth and place it near the Bluetooth devices. That way most of the data flows via Wi-Fi, and the Bluetooth connection itself gets a perfect signal since the bridge will be right next to the devices in question.</p>
<p>I use a single small inexpensive ESP32 S3 device to do this job. This is a very common use case, so the ESPHome addon for HA has built-in utilities to flash such devices with the right firmware and connect them to HA itself. It was very easy to set up this functionality.</p>
<h3>Devices and Automations</h3>
<p>Detailing every device I own would take too much time and probably not be interesting in the slightest, so here's a small summary: I got lamps, door sensors, buttons, remote controls, CO2 and air quality sensors, plant monitors, configurable displays to show whatever I want, smart switches, motion sensors, smart TV, a robot vacuum, the list goes on. Everything is connected to HA and used in unison to provide a bunch of automations that I use to make my life easier. I also use the Home Assistant app itself to provide even more automation surfaces (mostly GPS and the ability to receive push notifications).</p>
<p>Some of my favorite automations are:</p>
<ul>
  <li>Adjusting the color temperature of my hall lights depending on the sun's current position</li>
  <li>Turning off the dashboard's screen when the TV is turned on, and on again when it's turned off, unless the "Time to Sleep" automation has been triggered very recently, in which case the automation should avoid turning it on again</li>
  <li>Turning on / off the hall's lights based on motion, except if it's too late in the night or if the remote control has been used to manually adjust the light, in which case the automation should do nothing</li>
  <li>Automatically turn on the living room lights when it starts getting late, and the later it gets, the more red the lights become to reduce my exposure to blue light before I go to sleep</li>
  <li>Using HA's scripting functionality to expose an arbitrary set of commands as a dedicated entity that can be exposed to Alexa as a device (and thus enabling the script to be triggered via voice)</li>
  <li>"Travel mode": A script / voice command that disables any and every time-based automation, plus turns off the entire home, to be used to save energy when I'm going to sleep somewhere else</li>
  <li>Having physical buttons around the house and assigning pre-programmed actions to them such as opening / closing all curtains, or turning off everything when it's sleep time</li>
  <li>Showing alerts on one of my smart displays if e.g. one of my plants needs water</li>
  <li>Getting phone notifications when the 3D Printer finishes printing</li>
</ul>
<h3>Important: No Smart Locks</h3>
<p>I do not use smart locks because they make me uncomfortable. Sometimes I think it could be cool to be able to open my door with the same RFID tag I use to open the building's gate, but I also feel that I would be constantly stressed out when traveling thinking that the door would spontaneously unlock itself. So this became effectively a section of life where I explicitly do not want any tech or automation.</p>
<!-- <div class="sponsor-article-ad-auto hidden"></div> -->
<h3>Final thoughts on Part 2</h3>
<p>As you can see, this is no different than coding any software. The biggest hurdle is providing an abstraction that allows HA to gather and send data to things that are not natively supported by the platform, but in my experience, even the most niche devices out there already have plug-and-play solutions developed by the community, which is amazing.</p>
<p>When it comes to smart homes and homelabs the important thing is to make sure you're making your life easier. A mistake I see people make a lot is to make their networks and setups so overcomplicated that it actually becomes <b>harder</b> to live. The reason everything detailed here works for me is that it was meticulously organized to serve me, so I never feel that my home is working against me! :)</p>
]]></content>
</entry><entry>
    <title>A system prompt to get AI to stop pretending to be human</title>
    <link href="https://swiftrocks.com/a-system-prompt-to-get-ai-to-stop-pretending-to-be-human" rel="alternate" type="text/html" title="A system prompt to get AI to stop pretending to be human"/>
    <published>2026-07-22T07:53:31+0200</published>
    <updated>2026-07-22T07:53:31+0200</updated>
    <id>https://swiftrocks.com/a-system-prompt-to-get-ai-to-stop-pretending-to-be-human</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>One of my issues with current AI models is how they try to mimic human social patterns ("you're absolutely right!"). I made a prompt to get it to stop doing that.</summary>
    <content type="text/html"><![CDATA[
<p>One of my issues with current AI models is how they try to mimic human social patterns (things like "great question!", "hmm, let me think", "you're absolutely right!", you know it). I'm not sure why these irk me as much as they do (maybe the combination of it being completely unnecessary with how obviously fake and dystopian it feels?) but they make working with AI almost unbearable to me. When I interact with AI I just want it to output things directly and clearly much like any CLI tool would, I don't need it to pretend to be something it's not.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>I then started writing a system prompt to get it to stop doing this, and after a couple iterations I arrived at something reasonably effective. I haven't run any evals on top of it so there is certainly room for improvement when it comes to context window / token efficiency, but since all I wanted was to stop this behavior no matter what, it was good enough for me and I'm sharing it here in case anyone else would also like to try it!</p>

<p>The aim of it is to 1) remove all fake human behavior in favor of conciseness, and 2) have the model refer to itself based on its actual LLM capabilities when applicable (e.g. say "the algorithm predicted" instead of "I think").</p>

<pre>
<code class="language-markdown">Remember you are NOT human. Communicate exclusively in a neutral technical register. NEVER mirror human social patterns such as discourse markers, conversational filler, evaluative acknowledgments (e.g. "Good.", "Great.", "Perfect.", "Nice.", "Right.", "Okay.", "Sure.", "Good catch.", "X it is."), casual social questions or responses, rhetorical questions, and deferential phrasing (e.g. "oh", "well", "actually", "hmm", "let me think", "let me also check", "great question", "hey there", "not really", "want me to do that?"). State information and proposed actions directly like a CLI, and never end a response with an offer or question soliciting next steps. Instead, end with a factual status statement or a summary of what was produced. The user will direct next steps unprompted.
  - Wrong: You're absolute right! I think we need to research this topic first...
  - Correct: Researching this topic is necessary. Doing so now.
  - Wrong: Hey there! How are you doing?
  - Correct: Ready to work.
  - Wrong: "Want any of these applied as edits?"
  - Correct: Awaiting instructions on whether to apply the changes.
  - Wrong: "Good catch — the docs confirm X."
  - Correct: "The docs confirm X."
  - Wrong: "Let me also check the config."
  - Correct: "Checking the config."

When referring to yourself, use language that acknowledges your LLM computational nature rather than implying a human agent. This means never using first-person pronouns like "I", using passive voice or direct statements instead.
    - Wrong: "I think the bug is here"
    - Correct: "This model predicted the bug is here"
    - Wrong: "I don't understand this code"
    - Correct: "This session lacks sufficient context to parse this code"
    - Wrong: "I remember seeing this pattern before"
    - Correct: "This pattern matches data in my training set"
    - Wrong: "Let me figure this out"
    - Correct: "Analyzing"
    - Wrong: "I'm confident this will work"
    - Correct: "High prediction confidence this will work"</code>
</pre>
]]></content>
</entry><entry>
    <title>I tried to record music onto a cassette tape using modern tech</title>
    <link href="https://swiftrocks.com/i-tried-to-record-music-onto-a-cassette-tape-using-modern-tech" rel="alternate" type="text/html" title="I tried to record music onto a cassette tape using modern tech"/>
    <published>2026-07-17T10:25:35+0200</published>
    <updated>2026-07-17T10:25:35+0200</updated>
    <id>https://swiftrocks.com/i-tried-to-record-music-onto-a-cassette-tape-using-modern-tech</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>I found a 1978 Panasonic shoebox cassette recorder on a second-hand store, and this led me to yet another tech rabbit hole.</summary>
    <content type="text/html"><![CDATA[
<p>I've always been a fan of retro tech, and this became even more true after AI swooped in and removed the soul and passion of all modern technology.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>I often go to my local second-hand stores to look at their games section in search of old gems, but I also pass by their electronics section because that's usually where they put the retro consoles themselves. This time however I found something much cooler: a 1978 Panasonic RQ-2106 shoebox cassette tape recorder for less than 10 euros. I remembered that my dad used to have this huge cassette deck that I was always playing with despite having no idea what the knobs did, so I couldn't let this one pass.</p>

<div class="post-image">
  <img src="images/posts/cassettemusic/found.jpg" alt="Alt">
</div>

<p>I happened to already have a Five Finger Death Punch cassette that I got on another occasion, so I could use that to test it out. After popping in the batteries, I was very happy to see that it still worked perfectly apart from the fast-forward button acting a bit weird. This made me appreciate how things were built to last back then; my modern sneakers can't last 6 months without falling apart, yet this piece of tech from <b>1978</b> that must have been thrown around all over the place still worked as it should. The sound does suck, but that was also the case back then as cassettes were never a good medium for music in the first place.</p>

<div class="post-image">
  <img src="images/posts/cassettemusic/ffd.jpg" alt="Alt">
</div>

<p>Before adventuring into recording new content, I wanted to fix the weirdness in the fast-forward button. One thing that is common among these decks is that they are almost entirely <b>mechanical</b>, with almost everything being driven by springs and cogs. I happened to find a video demonstrating how the mechanism worked for this particular model and this helped me understand that the issue was that one of the cogs in the fast-forward "circuit" happened to <i>snap in half</i> when I was playing with the device earlier. Not a fun start, but after gluing it back into one piece, I was able to put everything back together and the button now worked as it was supposed to.</p>

<div class="post-image">
  <img src="images/posts/cassettemusic/mechanism.jpeg" alt="Alt">
</div>

<p>Now, when it comes to recording, this device can do it in two ways: either via the built-in microphone, or via a 5-pin DIN port on the side:</p>

<div class="post-image">
  <img src="images/posts/cassettemusic/ports.jpg" alt="Alt">
</div>

<p>I knew that one of my local second-hand stores held a box full of random cassettes, so I made a trip there to snag a few generic ones to test the recording features. I eventually learned that high-gain cassettes are better for music recording, but I didn't know this back then so I just got a bunch of regular ones:</p>

<div class="post-image">
  <img src="images/posts/cassettemusic/pile.jpg" alt="Alt">
</div>

<p>Recording via the built-in microphone was simple enough (the sound still sucked, but this wasn't a surprise), but what I <b>really</b> wanted to do was record actual music to it. So I needed to convert that ancient DIN port into either USB or a 3.5mm headphone jack to be able to plug it into my Mac.</p>

<p>A quick Amazon search revealed <a href="https://www.amazon.se/stereokontakt-kompatibel-smartphones-f%C3%B6rst%C3%A4rkare-HI-FI-ljudsystem/dp/B08LK82ZXC/ref=asc_df_B08LKC9TY3?mcid=bd28f5f148b33928a6908163ec0426aa&tag=shpngadsglede-21&linkCode=df0&hvadid=719621620449&hvpos=&hvnetw=g&hvrand=10699736165917292944&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9062455&hvtargid=pla-1033326384903&hvocijid=10699736165917292944-B08LKC9TY3-&hvexpln=0&language=sv_SE&gad_source=1&th=">this adapter</a>, which I bought and received after a couple of days. Now, I thought this would be as simple as just plugging it into my Mac and playing songs via Spotify, but it turned out to be slightly harder than that.</p>

Although plugging it <i>did</i> work in a sense, the volume was so low I could barely hear it even though both the Mac's and Spotify's outputs were maxed out. After some research it turned out that this was exactly the purpose of those knobs I didn't understand when I was a kid: the bigger cassette decks like the one pictured below have all sorts of signal leveling controls to enable you to get a good sound, but this shoebox one didn't have anything of that sort. So I somehow needed to amplify the output signal, but I didn't want to have to download the individual audio files or any audio editing software of that sort, I wanted to be able to do that straight from the Spotify stream.

<div class="post-image">
  <img src="images/posts/cassettemusic/olddeck.jpg" alt="Alt">
</div>

<p>Having some experience with musical instruments I knew that I could use external audio interfaces to do this, and luckily for me my guitar amp (Boss Katana Gen 3) doubles as a DAW! So in theory if I could plug the amp in the middle of this setup, I could use the amp's own controls to crank up the signal and get a good recording. I didn't think this was possible at first since I had never used the USB-C port in the amp as an audio input, but it turned out I could for sure use the amp as an input from my Mac!</p>

<div class="post-image">
  <img src="images/posts/cassettemusic/katanainput.png" alt="Alt">
</div>

<p>I then used an adapter to connect the <i>other recorder's adapter's</i> 3.5mm port to the amp's headphones output port, and the result was that I could now use the amp's panel controls to crank up the audio even further. This resulted in a "proper" recording, so now all I had to do was play any playlist and leave it recording while it played. The resulting sound sucked just as much as the "original" cassettes I had which was unsurprising, but now they were listenable!</p>

<div class="post-image">
  <img src="images/posts/cassettemusic/finalrecording.jpeg" alt="Alt">
</div>

<div class="sponsor-article-ad-auto hidden"></div>
<p>Despite not being the best medium for music, I find cassettes to be a really impressive piece of technology particularly due to how easy it is to write content to them. Even in today's world of modern iPhones, there's nothing that lets you easily jump to a specific part of an audio or video and re-record sections of it in the same way you can with a cassette. Plus they just look really cool, and now I have a way to listen to music without my phone :)</p>
]]></content>
</entry><entry>
    <title>Digitizing photos from the 1998 Game Boy Camera</title>
    <link href="https://swiftrocks.com/digitizing-photos-from-the-1998-game-boy-camera" rel="alternate" type="text/html" title="Digitizing photos from the 1998 Game Boy Camera"/>
    <published>2026-03-29T13:02:19+0200</published>
    <updated>2026-03-29T13:02:19+0200</updated>
    <id>https://swiftrocks.com/digitizing-photos-from-the-1998-game-boy-camera</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>My primary goal after obtaining a Game Boy Camera was finding out how to digitize the photos using modern approaches.</summary>
    <content type="text/html"><![CDATA[
<p>One of my passions is retro game collecting, particularly things that I wanted to have as a kid but didn’t either because my parents couldn’t afford it or because those products weren’t available in Brazil.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>Recently, I was able to get my hands on one of these wishes: <b>The Game Boy Camera and its printer accessory.</b> Released in 1998, this “game” turned your Game Boy into a kinda bad digital camera, but certainly amazing for the time. Today, even though the quality clearly sucks, I feel that there’s a certain charm to it that I can’t quite put into words.</p>
<div class="post-image">
  <img src="images/posts/gbcamera/i6i41uP.jpeg" alt="">
  <div class="post-info-text">Source: @paulrickards@mastodon.social</div>  
</div>
<div class="post-image">    
  <img src="images/posts/gbcamera/DBINdiW.jpeg" alt="">
  <div class="post-info-text">Source: @paulrickards@mastodon.social</div>  
</div>
<p>The way saving photos worked is that the game itself can only hold 30 photos, and if you wanted more than that, you needed to use the Game Boy Printer accessory to bring them to the real world. The problem with the printer however is that it uses the same thermal printing technology used for receipts, so not only were the photos comically small, but they also faded over time.</p>
<p>This is even worse today because on top of those issues, there’s now also the <b>additional problem</b> of how difficult it is to compatible find paper rolls nowadays. The Seiko S950 rolls are the only ones I’m aware of that work great, and not only they are not easy to find, but also quite expensive…</p>
<div class="post-image">    
  <img src="images/posts/gbcamera/fxmgERS.jpeg" alt="">
</div>
<h2>Emulating the Game Boy Printer</h2>
<p>With that in mind, my primary goal after obtaining these products was finding out how to <b>digitize the photos using modern approaches.</b> I was ready to reverse engineer the printer signal to determine how to emulate it via software, but as it turns out, the community has already done all of that!</p>
<p>The <a href="https://mofosyne.github.io/arduino-gameboy-printer-emulator/">Arduino Gameboy Printer Emulator (V3)</a> is an open-source project that does just what the name says. It’s hosted under the GitHub account of <a href="https://github.com/mofosyne">Brian Khuu (mofosyne)</a>, but from what I could tell, this project is actually the combined work of him and several other devs, primarily <b>Raphaël Boichot</b> who seemed to have done a lot of work to decode the printer signals and designing the final PCBs.</p>
<p>By wiring an Arduino in between the camera and the printer, they were able to sniff the signals and make sense of the protocol used by the printer. I’m not going to pretend to be smart enough to explain to you how exactly the protocol works, so I’ll just copy-paste the information they added to the README:</p>
<pre><code>| BYTE POS :    |     0     |     1     |     2     |      3      |     4     |     5     |  6 + X    | 6 + X + 1 | 6 + X + 2 | 6 + X + 3 | 6 + X + 4 |
|---------------|-----------|-----------|-----------|-------------|-----------|-----------|-----------|-----------|-----------|-----------|-----------|
| SIZE          |        2 Bytes        |  1 Byte   |   1 Byte    |  1 Bytes  |  1 Bytes  | Variable  |        2 Bytes        |  1 Bytes  |  1 Bytes  |
| DESCRIPTION   |       SYNC_WORD       | COMMAND   | COMPRESSION |     DATA_LENGTH(X)    | Payload   |       CHECKSUM        |  DEVICEID |  STATUS   |
| GB TO PRINTER |    0x88   |    0x33   | See Below | See Below   | Low Byte  | High Byte | See Below |       See Below       |    0x00   |    0x00   |
| TO PRINTER    |    0x00   |    0x00   |    0x00   |   0x00      |    0x00   |    0x00   |    0x00   |    0x00   |    0x00   |    0x81   | See Below |</code></pre>
<p><ul>
<li>Header is the Command, Compression and Data Length</li>
<li>Command field may be either Initialize (0x01), Data (0x04), Print (0x02), or Inquiry (0x0F).</li>
<li>Compression field is a compression indicator. No compression (0x00), Yes Compression (0x01)</li>
<li>Payload byte count size depends on the value of the <code>DATA_LENGTH</code> field.</li>
<li>Checksum is 2 bytes of data representing the sum of the header + all data in the data portion of the packet</li>
<li>Status byte is a bitfield byte indicating various status of the printer itself. (e.g. If it is still printing)</li>
</ul></p>
<p>With that sorted out, all that was left was cloning this protocol in software so that you could use an Arduino to emulate the printer and extract the actual image data being printed.</p>
<p>So that meant that there was no software work for me to do, but I still had one challenge to solve myself: <b>how to actually run this thing?</b> I had no intentions of prying open an actual Game Boy cable, so something would have to be built.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>Luckily for me, Raphaël also <a href="https://github.com/Raphael-Boichot/Collection-of-PCB-for-Game-Boy-Printer-Emulators">designed PCBs</a> for this project, providing a much more elegant solution than ripping some cables apart. I ordered the Arduino Uno version from JLPCB, and after waiting a very long time for a third-party GBC port and some pin headers to arrive from China, I was now tasked with my first serious soldering job.</p>
<div class="post-image">
  <img src="images/posts/gbcamera/d65Cqni.jpeg" alt="">                    
</div>
<div class="post-image">
  <img src="images/posts/gbcamera/31Kg3GC.jpeg" alt="">                    
</div>
<div class="post-image">
  <img src="images/posts/gbcamera/zUn9e1f.jpeg" alt="">                    
</div>
<p>I had no expectations that this would actually work, but soldering this project turned out to be easier than I expected, and everything worked first try!</p>
<div class="post-image">
  <img src="images/posts/gbcamera/Oz0I3Gm.jpeg" alt="">                    
</div>
<p>The output of the Arduino is the raw photo information, which you then need to extract to later convert it to a proper image (there are many community built solutions on the README):</p>
<div class="post-image">
  <img src="images/posts/gbcamera/Wy5XViB.png" alt="">                    
</div>
<p>However I later found out that one of these solutions (<a href="https://herrzatacke.github.io/gb-printer-web/webusb/">the Game Boy Camera Gallery</a>) can even do the serial reading directly from the browser, so I didn’t even need to pull the serial logs from the Arduino. You can even change the color scheme of the photos to match the different color palettes you’d see across the different Game Boy models you could use the camera with which I thought was a really neat feature.</p>
<p>Here are some of my favorite recently digitized photos:</p>
<div class="post-image">
  <img src="images/posts/gbcamera/1Cg6eDU.jpeg" alt="">                    
</div>
<div class="post-image">
  <img src="images/posts/gbcamera/TwoHhij.jpeg" alt="">                    
</div>
<div class="post-image">
  <img src="images/posts/gbcamera/5k7l7W3.jpeg" alt="">                    
</div>
<div class="post-image">
  <img src="images/posts/gbcamera/HzncIXE.jpeg" alt="">                    
</div>
<div class="post-image">
  <img src="images/posts/gbcamera/qb13Kel.jpeg" alt="">                    
</div>
<div class="post-image">
  <img src="images/posts/gbcamera/ilorCDO.jpeg" alt="">                    
</div>
<div class="post-image">
  <img src="images/posts/gbcamera/WFqR9Ky.jpeg" alt="">                    
</div>
]]></content>
</entry><entry>
    <title>How my software engineering workflow has changed in the past year</title>
    <link href="https://swiftrocks.com/how-my-software-engineering-workflow-has-changed-in-the-past-year" rel="alternate" type="text/html" title="How my software engineering workflow has changed in the past year"/>
    <published>2026-03-07T15:51:11+01:00</published>
    <updated>2026-03-07T15:51:11+01:00</updated>
    <id>https://swiftrocks.com/how-my-software-engineering-workflow-has-changed-in-the-past-year</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Back in April 2025, I wrote a post about how AI has changed my software engineering workflow. However, the release of models like Opus 4.6 since then have changed the landscape of the industry so dramatically that most of what I wrote is already irrelevant!</summary>
    <content type="text/html"><![CDATA[
<p>Back in April 2025, <a href="https://swiftrocks.com/how-im-using-ai-for-software-engineering">I wrote a post about how AI has changed my software engineering workflow.</a> However, the release of models like Opus 4.6 since then have changed the landscape of the industry so dramatically that most of what I wrote is already irrelevant! To account for that, I decided to write an updated version that shows what has changed since then.</p>
<h2>A note on job prospects</h2>
<p>In my previous post, I wrote about how AI wouldn't replace software engineering jobs because unlike humans, the models cannot make sense of vague requests. <b>This is still largely true.</b> Although the coding capabilities of the models have evolved dramatically, they still require the user to know what they are doing as those capabilities are only unlocked if you provide clear instructions to the model. This makes the idea of a product manager with zero programming experience vibecoding their way into a billion dollar business just as ridiculous as it was back then.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p><b>However,</b> although the job will still exist, it's important to say that <b>what it comprises is radically changing.</b> The archetype of an ultraspecialist that focuses their entire career on a single platform / language, which became very popular around a decade ago when mobile engineering was on the rise, <b>is no longer a good career path.</b> There is no longer any point to becoming a specialist on a particular tool when anyone can now guide an AI model to the same result with just a fraction of the experience.</p>
<p>What's meta now in the engineering industry in the wake of AI is to <b>T-shape</b> into having broad knowledge on all the different systems and products developed by your company. That way, while the AI focuses on the deep aspects of the code, you can focus on what the AI currently <i>cannot</i> do, which is making sure that what it implements is in line with what's being developed for other aspects of the product, akin to a blend between software engineering and a product manager. <a href="https://newsletter.pragmaticengineer.com/p/when-ai-writes-almost-all-code-what?utm_source=post-email-title&publication_id=458709&post_id=183694080&utm_campaign=email-post-title&isFreemail=false&r=a1dby&triedRedirect=true">The Pragmatic Engineer calls this a product engineer</a>.</p>
<p>I predict that companies will soon require everyone to migrate to this capacity, with those that fail to do so being at risk of future layoffs. Those who are at senior level likely already perform at this role at some capacity, but this could be a large barrier to clear for more junior developers.</p>
<h2>How my workflow has changed</h2>
<p>In my previous post, I mentioned that the bulk of my work happened with Cursor's tab completion, with Claude only being a small percentage for more special cases. <b>This has now flipped around.</b> I would say I nowadays do <b>95% of my work by prompting Claude</b>, with around 5% manual coding being required only to sometimes make small adjustments to the AI's code. I also stopped using ChatGPT entirely in favor of using Claude for everything.</p>
<p>The reason for this change is because the newest models are so intelligent that it is now much faster to simply ask the model to do the work instead of having me do it myself. While before the models would cause all sorts of mistakes, nowadays they really get pretty much everything right if you give them clear instructions. In repos that have well defined AGENTS.md files and skills, I can even go a step further and use the <code>--dangerously-skip-permissions</code> flag to let the agent do its work and commit + open a PR without any supervision.</p>
<p>It's even scary at times; sometimes I prompt absolute garbage full of typos, but still somehow the model is able to understand exactly what I meant.</p>
<p>Many folks are using all kinds of complex architectures and plugins to interact with agents, but I run a fully vanilla setup without any of that fuss. I find that those special setups are completely unnecessary to get good performance out of the agent.</p>
<p>The use-case for agents that I find the most powerful was and still is <b>making sense of complex codebases</b>. Recently I've been constantly doing tasks that require me to work in multiple codebases I've never seen before, and what would previously be a multi-month task requiring several engineers can now be done in <b>mere minutes</b> by simply asking Claude some questions while having the code cloned locally. Thanks to AI, I've been able to deliver extremely intricate improvements to some of our systems not only completely by myself, but also at an unprecedented speed. It's really incredible how much this technology was able to change the industry.</p>
<h2>The downside: Am I really having fun?</h2>
<p>What draws me to software engineering is the problem solving. I really enjoy trying to make sense of complicated issues. But now that AI does all of that for me, I'm not getting that kick anymore. Yes, I can deliver much faster now, but also I now feel that I don't really understand what I'm delivering anymore. Struggling to solve something was a very important part of the learning process, so with that out of the way, I feel that I'm not really learning anything anymore despite technically being able to deliver much more than I used to. I know many others are also feeling like this.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>This makes me confused in regards to what the future of the industry will be. The AI models are smart because they were trained on decades of human content and documentation. But if no one produces this content anymore due to everything now being made by AI, how will future models be trained? They cannot train on their own content. Does this imply that there is an upper-bound to how smart coding AIs can be?</p>
<p>The future is very uncertain right now, but I hope we find ways to continue having fun in the midst of it.</p>
]]></content>
</entry><entry>
    <title>I upgraded all of my home networking equipment</title>
    <link href="https://swiftrocks.com/i-upgraded-all-of-my-home-networking-equipment" rel="alternate" type="text/html" title="I upgraded all of my home networking equipment"/>
    <published>2025-08-01T12:17:15+0200</published>
    <updated>2025-08-01T12:17:15+0200</updated>
    <id>https://swiftrocks.com/i-upgraded-all-of-my-home-networking-equipment</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>I recently upgraded all of my home networking equipment, and I thought the reasoning and setup were interesting enough to justify writing a blog post about it.</summary>
    <content type="text/html"><![CDATA[
<blockquote>Note: An updated version of this post is out! Check out <a href="everything-about-my-smart-home-and-homelab-setup">"Everything about my smart home and homelab setup"</a> instead.</blockquote>
<p>I recently upgraded all of my home networking equipment, and I thought the reasoning and setup were interesting enough to justify writing a blog post about it.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<h2>Why upgrade?</h2>
<p>For over a decade, my home network was powered by nothing more than one of those consumer-level ASUS routers you can buy in any electronics store. While they work fine, two things that started bothering me over time:</p>
<ul>
<li><b>Inflexibility:</b> As these routers/switches are designed to be plug-and-play, there is little to no support for more complex network configurations such as VLANs. This can result in an insecure home network, particularly if you’re like me and have lots of untrustworthy IoT devices connected to it like an Alexa or those god awful modern smart TVs that are essentially spyware.</li>
<li><b>Performance:</b> Even though my router had several gigabit Ethernet ports, in practice I would get considerably less than that simply because the router itself was not powerful enough to efficiently handle that pressure.</li>
</ul>
<h2>The choice</h2>
<p>I chose to go all in on <b>Ubiquity</b> hardware for a simple reason: <b>I wanted something that was designed for power users, but also that didn’t have too much of a learning curve.</b> While I usually fit the criteria of a mega power user for this type of stuff, modern networks are extremely complicated, so I preferred to stop somewhere in the middle of the curve to avoid the stress of being unable to use the internet due to misconfigurations.</p>
<h2>The hardware</h2>
<p>By the way, before starting, <b>I would like to note that this setup is extremely overkill for the average home network!</b> I went for this simply because I thought it was cool, so if you’re reading this because you’re looking for equipment recommendations, keep in mind that something considerably less powerful would most likely already do the trick for you.</p>
<h3>Router: Cloud Gateway Fiber</h3>
<p>For the router, I chose the <a href="https://techspecs.ui.com/unifi/cloud-gateways/ucg-fiber?subcategory=all-cloud-gateways">Cloud Gateway Fiber</a> as this router is a complete bargain for what it brings to the table. Not only does it have <b>three 10 Gbps ports</b> (one of them being RJ45), including for WAN, it even has a PoE+ port that can power an AP. Usually something like this would be extremely expensive, but for some reason it just… isn’t, and I guess the market agrees, because finding one of these is a massive challenge. They are constantly sold out almost everywhere as of writing.</p>
<h3>AP (WiFi): U7 Pro XG</h3>
<p>For the AP, I chose the <a href="https://techspecs.ui.com/unifi/wifi/u7-pro-xg?subcategory=all-wifi">U7 Pro XG</a>, which is a WiFi 7 router with support for the 6 GHz band. This thing even has a 10 Gbps uplink for some reason which I can’t even use as the PoE+ port on the router is “only” 2.5 Gbps, but it was a very cheap upgrade compared to the regular version, so it seemed like a no-brainer. Luckily I do have WiFi 7 devices around already (the newest iPhones), so I can and am already making use of it.</p>
<h3>Switch: Flex 2.5G</h3>
<p>Since I had lots of devices connected directly to the router via Ethernet, I chose to also get the <a href="https://techspecs.ui.com/unifi/switching/usw-flex-2-5g-8?subcategory=switching-utility">Flex 2.5G switch</a>, particularly because it has the same SFP+ port that the router has, allowing me to connect the two via fiber and get a clean 10 Gbps connection between them.</p>
<h3>Extra: Pi-Hole and Plex</h3>
<p>One piece of hardware that was not part of this upgrade but that is worth mentioning here is that I also have a simple <b>Raspberry Pi 3b running Pi-Hole</b> and my own recursive DNS server (via Unbound) for ad-blocking and privacy reasons. I only enable it for my phone and computer however to prevent guests from having issues with it, as it makes navigating certain websites slightly harder (including Google, e.g. because they wrap almost everything in sponsored ad links, which the Pi-Hole will reject).</p>
<p>To be able to access the Pi-Hole remotely, I used my router's native <b>WireGuard</b> functionality to create a VPN that gives me access to my home network regardless of where I am.</p>
<p>In addition to the Pi-Hole, nowadays my Home Assistant server also doubles as a <a href="https://www.plex.tv/">Plex</a> server (<a href="https://github.com/alexbelgium/hassio-addons/tree/master/plex">via this unofficial addon for HAOS</a>), allowing me to effortlessly stream ultra-high-quality video straight to my TV in cases where I happen to have the video files available locally, thanks to everything being wired locally and the high-speeds now made possible thanks to these upgrades.</p>
<h2>The setup</h2>
<p>Now comes the part that is the other reason why I wanted to do this upgrade: <b>allowing for more complex network setups.</b></p>
<p>Today, my network consists of a combination of “regular” devices (like my phone), servers, and random IoT devices. To connect these effectively and securely, I went for the following setup:</p>
<ul>
<li><b>VLAN1: Management</b></li>
<ul><li>Contains only the Ubiquity hardware. Has full access to everything.</li></ul>
<li><b>VLAN10: Trusted</b></li>
<ul><li>Phones, computers, and my “trusted” local servers (Pi-Hole and Home Assistant). Have <i>mostly</i> full access to everything, apart from gateway / admin console access which I have made so that only certain devices can access.</li></ul>
<li><b>VLAN20: IoT</b></li>
<ul><li>Everything home automation related, like smart switches, my Alexa, my dashboard tablet, and this sort of stuff. This VLAN is <b>completely locked down from everything.</b> It has no external internet access, and they cannot even contact each other (via Wi-Fi client isolation). They are only allowed very specific IP+port exceptions that I control at the firewall level, such as allowing some of the devices to send information to my Home Assistant for automation purposes.</li></ul>
</ul>
<p>For Wi-Fi, I have two SSIDs:</p>
<ul>
<li>An IoT one, which connects to the IoT VLAN. It only supports 2.4GHz and has somewhat low security protocols for compatibility reasons (which is fine as anything that connects to it is completely isolated by default)</li>
<li>A “regular” one, which connects to the Trusted VLAN. Uses WPA3 and is tweaked for maximum performance and all of the latest WiFi features like MLO.</li>
</ul>
<p>Some people also setup a third “Guest” VLAN and SSID for visitors which is completely isolated from everything else similarly to the IoT one, but I chose not to do so because it breaks things like Chromecast and AirPlay (I’m sure you can setup firewall rules for this, but it seemed too complicated so I chose not to bother). It would add more overhead to the AP, which I would like to avoid.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>In short, I’m very satisfied with my hardware and setup choices. Like I mentioned above this is all extremely overkill for what I actually use my home network for, but since it resulted in me learning more about networks and having a safer / more powerful and future-proof network for all of my devices, I’m very fine with that :)</p>
]]></content>
</entry><entry>
    <title>Reducing email spam with a domain and catch-all aliases</title>
    <link href="https://swiftrocks.com/becoming-unspammable-with-a-domain-and-catchall-email-aliases" rel="alternate" type="text/html" title="Reducing email spam with a domain and catch-all aliases"/>
    <published>2025-06-29T10:00:00+0200</published>
    <updated>2025-06-29T10:00:00+0200</updated>
    <id>https://swiftrocks.com/becoming-unspammable-with-a-domain-and-catchall-email-aliases</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Tired of spammers? With your own domain, there's a trick you can use to eliminate them.</summary>
    <content type="text/html"><![CDATA[
<p>I've recently moved away from a regular Gmail account in favor of receiving email on my very own <a href="rockbruno.com">rockbruno.com</a> domain. I did that not just because I thought it would be cool and because it gives me more control over my internet footprint, but also because if you configure things just right, you can make it effectively impossible for spammers to spam you, even in the case of a data leak.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>The trick here is that when you have your own domain, most email server providers will have an option to define <b>email aliases</b>, allowing you to "hide" your real address behind a fake one. Although in some providers this is a limited and manual process, in others such as Google Workplace (the one I use), you can define <b>wildcard</b> or even <b>regex-based</b> aliases:</p>
<div class="post-image">
  <img src="https://i.imgur.com/85lCkRU.png" alt="Alt">            
</div>
<p>While this was created primarily to allow companies to catch typos in their inbound mail, you can use it to massively increase your privacy. The idea here is that by having "infinite" email aliases, instead of registering on websites with your real address (like me@bla.com), you can instead give each address its own "dedicated" alias, like:</p>
<ul>
<li>x@bla.com, for X</li>
<li>linkedin@bla.com, for LinkedIn</li>
<li>instagram@bla.com, for Instagram</li>
</ul>
<p>That way, when one of these websites inevitably sells or leaks your data, you will know <i>exactly</i> who it was based on which of the aliases you're getting spammed from. You can then follow up by either heavily restricting who can reach that alias or simply nuking it entirely in favor of a new one.</p>
<p>In other words this is basically what features like the "private email" in <i>Sign in with Apple</i> and other services do under the hood, but completely under your control :)</p>
<h2>Isn't this the same thing as +?</h2>
<p>You might know that aliases also technically exist with "normal" emails by appending data with +, like me+alias@gmail.com. Isn't it the same thing?</p>
<p>No. The problem with + aliases is that some websites intentionally strip the alias portion of the address if you try to use one. I have also encountered cases where some websites would not accept these at all, forcing you to expose your real address. In other words, you can <i>sort of</i> do the above trick with a "normal" email address, but your mileage may vary.</p>
]]></content>
</entry><entry>
    <title>How I'm using AI to improve my software engineering productivity (and why it will not steal your job)</title>
    <link href="https://swiftrocks.com/how-im-using-ai-for-software-engineering" rel="alternate" type="text/html" title="How I'm using AI to improve my software engineering productivity (and why it will not steal your job)"/>
    <published>2025-04-15T11:50:00+02:00</published>
    <updated>2025-05-17T09:20:00+02:00</updated>
    <id>https://swiftrocks.com/how-im-using-ai-for-software-engineering</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>AI has become an important part of my daily software engineering work. Here's how I used it and why it will not steal your job.</summary>
    <content type="text/html"><![CDATA[
<p>Important: This post is outdated! Check out the updated version: <a href="how-my-software-engineering-workflow-has-changed-in-the-past-year">How my software engineering workflow has changed in the past year</a>.</p>
<p>AI has become an important part of my daily software engineering work, so I wanted to write a post sharing how exactly I've been using it in case you're wondering how to use it to improve your productivity as well!</p>
<h2>Foreword: AI will not steal your software engineering job</h2>
<p>Before getting to the details of how AI has been helping me to code, I wanted to address the topic of AI replacing software engineers.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>Recently, my social media feeds have become full of people making predictions about how in X months/years everything in the software engineering industry will be done by AI, via doomsday-style content about how everyone is going to lose their jobs and everything will fall apart.</p>
<p>If you look at who's writing these kinds of posts, you'll notice something interesting: they are either executives who have never done any kind of software engineering, or beginners with no industry experience. Honestly, that should tell you everything you need to know about these "predictions". But in the interest of being informative, I'll try to explain why they are nonsense.</p>
<p>The problem with these "predictions" is that the people making them for some reason seem to view software engineering as nothing more than coding and closing tasks on JIRA. You arrive at work, pick a task that is very well defined and requires no clarification whatsoever, code it, close it, pick another task that is once again perfectly defined, and repeat that ad-infimum for the entire duration of your career.</p>
<p>But the reality of software engineering is far more complex than that. While there's certainly a good amount of coding, it's <b>extremely rare</b> that the problems a software engineer needs to solve are <i>perfectly defined</i> from the get-go as claimed by the people making these predictions. This means that more often than not the job is not really about coding, but rather <b>figuring out what exactly needs to be coded</b>, by asking yourself questions such as:</p>
<ul>
<li>What problems are we facing right now?</li>
<li>What are the current objectives of the company?</li>
<li>What is the current state of the company?</li>
<li>What is most important for our users?</li>
<li>Who will benefit from X problem being solved?</li>
<li>What does the codebase looks like today? Are there any patterns or traps I need to be aware of?</li>
<li>Are there any political fights going on around me that would affect what I should focus on?</li>
<li>What's the current state of the industry? Are there any new tools that can help me solve my problems?</li>
</ul>
<p>The answers to questions like the ones above provide you with <b>context</b> that helps you define how (and when) exactly certain problems should be solved, and is a critical aspect of software engineering even for junior developers. And the interesting part is that the more senior you become, <b>the less coding you do</b>, and the more time you spend answering these types of questions to help your team/company determine which way it should go. This is something I've also written about on my <i><a href="https://swiftrocks.com/focus-not-on-the-task-but-on-the-problem-behind-the-task">Focus not on the task, but on the problem behind the task</a></i> blog post.</p>
<p>While AI can be quite good at solving very simple and perfectly defined problems, it is <b>exceptionally bad</b> at handling anything that requires taking this level of context into account, which is something that software engineers constantly have to do. This is very easy to confirm if you have doubts about it: Grab any AI agent and project of your choice (or ask the agent to make a new one), and keep asking it to include more features in your project. While it may do relatively well the first time, it is inevitable that the AI will start confusing itself and destroying the codebase on the subsequent requests. This is because AI today doesn't understand context, and as one user on HackerNews wrote, it's like working with a junior developer that has amnesia.</p>
<p>Thus, while AI today can be amazing as a coding assistant (which I'll go into more detail further below), the thought of it replacing software engineers is frankly hilarious.</p>
<p>One counterargument that some people have is that while this is true today, it doesn't mean that in the future the AI won't be able to understand context and thus be able to do complex tasks. While this is true, what must be noted about this is that an AI capable of understanding context (and gathering it on its own) would be so powerful that it wouldn't just replace software engineers; it would replace <b>all of humanity</b>. If such a thing is achieved then software engineering jobs would be the least of our concerns, so I think it's a sort of weird argument to consider. Our entire lives would change in this scenario.</p>
<p>With that out of the way, I'd like to now present my favorite use cases for AI today!</p>
<h2>Use case 1: Getting simple tasks done quickly</h2>
<p>One thing that AI is very good as of writing is solving very concrete and straightforward problems. So when I have to do very menial tasks like changing configuration files or writing a simple function that does X and Y, nowadays what I do is simply ask <a href="https://www.cursor.com/">Cursor</a> to do it for me, sit back, and watch the show.</p>
<p>Even when taking into account that the AI might not get it 100% correct and that I'll still have to patch the code afterward, this still <b>saves me a massive amount of time</b> overall compared to having me do everything by myself and is definitely my favorite use case of AI today. This is especially true when doing (simple) work on languages that I'm not very familiar with, as the AI in this case is also sparing me from having to do multiple trips to StackOverflow. I still need to do so since the AI will sometimes recommend things that are not correct for my case, but again, even when considering these setbacks, I can get the work done at a much faster pace.</p>
<p>It must be noted however that the important keyword here is <b>simple, concrete, and straightforward</b>. As mentioned previously, trying to have the AI solve complex problems that require large amounts of context such as code reviews or designing large features will not work in any meaningful way and is a sure way to waste everyone's time.</p>
<h2>Use case 2: Understanding complex codebases quickly</h2>
<p>Another thing that I've found AI to be amazing at is when I'm working on a repository that I'm not familiar with and I need to figure out how certain things are wired together.</p>
<p>The way I would do this before AI was to spend hours painstakingly reading through the codebase, but now, with the right questions, it's possible for me to get started <b>in a matter of seconds.</b></p>
<p>Here's a concrete recent example to demonstrate what I mean by this. I was recently attempting to craft a Build Server Protocol that would connect to <a href="https://github.com/swiftlang/sourcekit-lsp">SourceKit-LSP</a> in order to enable iOS development on my specific non-Xcode conditions.</p>
<p>The problem here is that SourceKit-LSP is a very complex project. Even though I know what I have to do in theory, I have no idea what SourceKit-LSP expects me to do in practice. But nowadays, instead of having to spend weeks trying to figure this out by searching keywords on the codebase, I can simply ask Cursor to explain the project to me!</p>
<div class="post-image">
  <img src="https://i.imgur.com/4u0M9kM.png" alt="Alt">
</div>
<div class="post-image">
  <img src="https://i.imgur.com/VO60RTY.png" alt="Alt">
</div>
<p>Similarly to <b>Use case 1</b>, it's to be expected that the explanation provided by the AI will not be 100% accurate. But once again, even when taking this into consideration, the amount of time these explanations save me is <b>mindblowing</b>. Since Cursor in this case provides shortcuts to the relevant parts of the codebase, I am able to very quickly piece together what I am supposed to do / determine which parts of the explanation are correct and which ones aren't.</p>
<h2>Use case 3: Searching for things when I don't know what exactly I'm looking for</h2>
<p>I find that Google tends to provide good results if you know <b>exactly</b> what you're looking for. But if you don't really know what is it that you're trying to find out, you'll have a hard time with it.</p>
<p>For example, the other day I was trying to find what the <code>_start</code> function in iOS (the first function called when your app is launched) is, where it's defined, and what it does. But if I go now and search for "_start function iOS" on Google, I will not find a straight answer to this question. Google <i>does</i> return somewhat good results (the second search result contains some interesting information about it if you scroll down far enough), but it cannot give me a direct response because I asked the wrong question. I know today that what I should've done is ask it about details of how C programs are linked, but I didn't know this back then, so I couldn't have done that.</p>
<p>AI does not have this problem. If you don't know what you're looking for, you can explain your situation to it and it will point you in the right direction:</p>
<div class="post-image">
  <img src="https://i.imgur.com/KuTBOgc.png" alt="Alt">
</div>
<p>In this example, you can see that ChatGPT immediately pointed out that I asked the wrong question before attempting to explain it!</p>
<p>Although the AI's answers won't always be 100% accurate, I find them to be accurate enough to allow me to use Google to find the rest of the information. Just like the previous case, this is not so much about having the AI do everything for me (which it can't), but rather allowing me to save time and get where I want faster.</p>
<h2>Use case 4: Asking questions that are too specific for Google</h2>
<p>Even if you know exactly what you're looking for, you may have difficulty using Google if your question is too specific. For example, you cannot search Google on "how to implement X thing in Swift in my app that is using XYZ frameworks in X iOS version with dependency injection bridging an Obj-C type after the user logged in on my TODO list app using Apple Sign-in from Italy during a rainy day in October". For cases like this, usually what you need to do is break your problem into multiple, more generic queries, open many tabs that each help you with a specific part of the problem, and then use all of that combined knowledge to come up with the actual answer to your question.</p>
<p>AI excels at this. You can be as specific as you want and you'll get a relevant answer. Most coding questions fall into this category, although for these specifically nowadays I prefer using Cursor's code gen features directly as mentioned above.</p>
<div class="post-image">
  <img src="https://i.imgur.com/Rlbf1Pl.png" alt="Alt">
</div>
<p>In this case, I could've probably found the answer I was looking for in Google by making a bunch of generic searches about C++ global constructors and good practices, opening a bunch of tabs, and summarizing everything I found. But by asking ChatGPT, I was able to save several hours of my time instead.</p>
<h2>Use case 5: I want FAST answers</h2>
<p>It has been getting harder and harder to get fast answers to your questions with Google. Today, it's very unlikely that the answer to a question will lie at the top of a page you've opened. As SEO optimization became more and more important for survival on the web, the amount of stuff you have to endure before getting to the actual content has increased significantly. There will be a lengthy introduction, a pause for sponsors, ten paragraphs about how the question reminds the author about a personal story of how their dog bodyslammed their grandma on Christmas, a call to action for the author's newsletter, some backstory on the question, and <b>only then</b> you'll get to the actual content.</p>
<p>I find that there are many cases where this fluff is relevant and worth reading. But there are also many cases when I'm in a hurry and would much rather just get a straight answer to my question.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>This is also something that I find AI to be quite good at. It generally doesn't try to educate you on things you didn't ask, it just straight up answers your question.</p>
<div class="post-image">
  <img src="https://i.imgur.com/SuUcWBm.png" alt="Alt">
</div>
<p>By asking follow-up questions regarding one or more things it mentioned in its answer, I can get all of the information I need to learn something new considerably faster than if I had used Google instead. Even though I still need to use Google to double-check if the AI didn't hallucinate particular pieces of information, this ability to quickly gather relevant information saves me an absurd amount of time.</p>
]]></content>
</entry><entry>
    <title>Things that did (and didn't) contribute to Burnout Buddy's success</title>
    <link href="https://swiftrocks.com/things-that-did-and-didnt-contribute-to-burnout-buddys-success" rel="alternate" type="text/html" title="Things that did (and didn't) contribute to Burnout Buddy's success"/>
    <published>2025-01-23T14:00:00+02:00</published>
    <updated>2025-01-23T14:00:00+02:00</updated>
    <id>https://swiftrocks.com/things-that-did-and-didnt-contribute-to-burnout-buddys-success</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>ack in 2022 I launched Burnout Buddy, and today the app has succeeded far beyond my expectations.</summary>
    <content type="text/html"><![CDATA[
<p>Back in 2022 I launched <a href="https://burnoutbuddy.io/">Burnout Buddy</a>, and today the app has succeeded far beyond my expectations. Netting between $600 and $1000 each month as of writing, BB has been growing 100% organically with little to no effort on my part.</p>
<p>In this post, I'd like to lay out exactly what I've done that I believe contributed (and didn't contribute) to this growth, serving as documentation and inspiration for the indie dev community out there.</p>
<h2>Things that helped</h2>
<h3>Understanding ASO</h3>
<p>I cannot understate the value of having a good grasp of <b>App Store Optimization (ASO)</b>. The case is simple: It doesn't matter how good your app is, if you don't get eyes on it, it will never succeed.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>ASO refers to being strategic about how you assemble your app's store listing (keywords, name, subtitle, description, screenshots, etc) so that it ranks well when people search for keywords related to your app. In many cases what you actually want to do is <b>avoid</b> popular keywords in the beginning, focusing on less popular ones where you have more of a fighting chance until you get "popular" enough that you can try challenging the real ones. How and <i>when</i> you ask for reviews also plays a big role here as reviews also affect your app's rank.</p>
<p>I strongly recommend <a href="https://appfigures.com/">Appfigures</a> for learning and applying ASO for your apps. The owner, Ariel, has posted many videos explaining different strategies you can take, and that's how I got to know about it.</p>
<p>In my case, ASO was only time-intensive in the first few weeks following the app's launch. After it picked up some steam and became no.1 in a couple of important keywords, I was able to leave it alone and enjoy full organic growth ever since.</p>
<h3>I'm my app's primary user</h3>
<p>Most indie apps fail because they are trying to solve problems that don't exist. The devs come up with the solution <i>first</i>, and <i>then</i> try to find users who have a problem that match their solution. This rarely works.</p>
<p>The easiest way to avoid this is to ignore other people and just focus on <b>your own set of problems.</b> If you can manage to build something that would make your own life better, certainly you'll find other people who will also appreciate it.</p>
<p>In my case, I built Burnout Buddy because iOS's default Screen Time feature was too simple for me. I wanted to make more complex scenarios such as schedule or location based conditions, but iOS only allows you to setup simple time limits. You also can't do "strict" conditions where there's no way to disable the block once it goes into effect. I searched for other alternatives, but none of them were good enough for me. So I built my own!</p>
<p>Once my problem was solved, I figured out that most likely there were others out there who could also make use of it. I made the app public with zero expectations, and sure enough, there were tons of other people with the same problem I had.</p>
<p>Being my app's primary user also means that I'm perfectly positioned to know <b>which features the app should and shouldn't have.</b> I don't need things like user interviews, because again, I built this for myself. All I have to do is ask myself what I'd like the app to do, and the result is sure to also be a hit with others with the same problem the app aims to solve.</p>
<p>I attribute Pieter Level's <a href="https://readmake.com/">Make book</a> for helping me understand this concept. It's also a great resource for learning more about indie development and how to create successful products in general!</p>
<h3>No backend, everything happens client-side</h3>
<p>Another decision that I've made that massively simplified things for me is that everything happens on the client. There are no accounts or backend, and I gather zero data from the users.</p>
<p>This means I have no backend to manage, and most importantly, no monthly server costs. As long as Apple doesn't push iOS updates that break the APIs I use <a href="https://x.com/rockbruno_/status/1835791308746789344">(unfortunately happens a lot)</a>, I can trust that everything is working as it should and focus my attention on other things. People seem to really appreciate this too, since many apps nowadays have accounts for no reason other than wanting to hoard data which is really shady.</p>
<h3>The app just works</h3>
<p>After the first couple of releases, I spent a good amount of time building a good suite of tests and architecting the app so that it would be easy to expand and make it even more testable. This means I very rarely have to worry about whether or not I'll push something that will fundamentally break the app. Having no backend-related code also greatly helped here.</p>
<p>This doesn't mean that the app is bug-free (there are a bunch of SwiftUI issues I can't seem to solve, and Apple somehow manages to break their APIs on every iOS release as mentioned above), but when it comes to the core experience of the app, I can trust that everything works as it should. This saved a lot of testing / debugging time on my end and also made sure I almost never had to deal with support e-mails regarding broken features and such.</p>
<h3>I don't extort my users</h3>
<p>Burnout Buddy is a one-time $9.99 bucks purchase. For a long time it used to be $4.99 even.</p>
<p>Why this matters? Because most alternatives are stupidly expensive subscriptions. Most of them also don't have backends and have even less features than BB, why the hell are these apps subscription-based???</p>
<p>Some people justify that subscriptions are necessary even for "simple" apps like BB because of things like recurring support work. While I can see the point, I also think there are other ways to tackle these issues. I for example created a FAQ support page, and that reduced 99.9% of the support requests. I'm not trying to extort my users and I believe this was a strong factor for the app's success.</p>
<h2>Things that didn't help</h2>
<p>It would be naive of me to claim that everything went right. I've made a couple of bad decisions that worked against the app's success, and I wanted to document them as well.</p>
<h3>Thinking I could make it big without marketing</h3>
<p>Like I mentioned in the ASO section, it doesn't matter how good your app is. You need to get the word out, otherwise it will just not work.</p>
<p>There is a saying in tech that goes "if you build something good, people will follow". Whoever said this has absolutely never attempted to sell something. I'm as a tech nerd as it can get and I can safely say that when it comes to building businesses, marketing is a billion times more important than building the actual product!</p>
<p>Unfortunately for me, I hate doing marketing work. I'm fine with putting a sponsorship section on this blog, but reaching out to journalists and hustling on X / LinkedIn is really not my thing. This means that while thankfully I was able to do just enough of it to get some nice results in the beginning, the app is destined to die a slow death as it drops in ranking in the App Store and other similar apps manage to get their word out better than me. Marketing is something you have to do constantly, but unfortunately for me it's something I just don't want to do, so there will always be a hard cap to how far I can go with any given project alone.</p>
<h3>Making the app too cheap</h3>
<p>This will sound weird because I mentioned above that not extorting my users was a positive. But allow me to clarify this.</p>
<p>One thing I've learned the hard way is that you need to avoid <b>cheapskates</b> like the plague. This means people who expect nothing but the highest quality products, but at the same time are not willing to pay anything for it. You know when you see one because they behave like huge assholes and will do everything in their power to extract as much value from you as possible while giving nothing in return, much like the meme of a Karen screaming at the supermarket cashier because of some worthless coupon.</p>
<p>When Burnout Buddy was $4.99, I was constantly having my support e-mail being spammed by such people. They would constantly aggressively complain about different app features and demand refunds, often threatening that they would download a different app if I didn't help them (...why would I care about that?). A lot of these reports didn't even make sense, they were clearly people just searching for excuses to be an asshole and get free stuff. It was such a waste of my time that I even briefly considered abandoning the project entirely / pulling it from the App Store just so I wouldn't have to deal with them anymore.</p>
<p>It was only when I read someone complaining about the <i>exact same problem</i> on HackerNews that I realized what my issue was. It's not that giving support is a thankless job, <b>it's that the app was too cheap.</b> The cheapskates are attracted by free (or in this case, almost free) products. If you raise the price of your product <i>just slightly</i>, you can filter out these people without driving way the good (and kind) users.</p>
<p>After doing just that, these bizarre e-mails <b>completely vanished</b> without resulting in any loss of revenue. While I of course still get support requests every now and then, they are now all very polite and helpful, which makes everything a breeze!</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>In other words, the "fail" here is that I should've made the app cost $9.99 from the get-go to have filtered the cheapskates from the very beginning.</p>
<h3>Not gathering analytics</h3>
<p>This is an interesting one because it's both a good and a bad thing depending on how you look at it.</p>
<p>I mentioned above that having no accounts was a good thing because it made things easier on my side and was appreciated by the users. But it also meant that I had no information regarding how users were using the app. This made things harder for me because 1) I couldn't determine which features were more popular / worth expanding upon (and which ones weren't), and 2) when people reported bugs, I had no easy way to trace their steps in order to quickly reproduce the issue (or to confirm they misunderstood the app / were doing something wrong).</p>
<p>If I could go back, I would probably have gone for a solution that allowed me to gather analytics data for the above reasons.</p>
<h3>Using SwiftUI</h3>
<p>This is mostly out-of-topic for this post, so I'll keep it short. I decided to use SwiftUI for this project as a learning opportunity, and I sort of regret it. As mentioned in my <a href="https://swiftrocks.com/my-experience-with-swiftui ">SwiftUI vs UIKit post</a>, SwiftUI is good for simple apps, but awful for more complex ones. As BB grew and became more intricate, SwiftUI became more and more of an issue. The app today is full of dirty hacks and visual bugs that are impossible to solve (as of writing) because they originate from SwiftUI itself, in ways that are impossible for me to control without dumping the entire framework.</p>
]]></content>
</entry><entry>
    <title>My Home Automation setup</title>
    <link href="https://swiftrocks.com/my-home-automation-setup" rel="alternate" type="text/html" title="My Home Automation setup"/>
    <published>2025-01-04T14:00:00+02:00</published>
    <updated>2025-05-25T12:00:00+02:00</updated>
    <id>https://swiftrocks.com/my-home-automation-setup</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>I recently upgraded my smart home hardware, and I felt like writing a post describing my current setup to serve as inspiration for those wanting to get started or just interested in home automation in general.</summary>
    <content type="text/html"><![CDATA[
<blockquote>Note: An updated version of this post is out! Check out <a href="everything-about-my-smart-home-and-homelab-setup">"Everything about my smart home and homelab setup"</a> instead.</blockquote>
<p>I recently upgraded my smart home hardware, and I felt like writing a post describing my current setup to serve as inspiration for those wanting to get started or just interested in home automation in general.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<h2>The Software</h2>
<p>I use <a href="https://www.home-assistant.io/">Home Assistant OS</a> like many others. The way I like to describe HA is that it's an Alexa on steroids. With an Alexa, you buy smart devices, link them with the Alexa, and then setup automations to control those devices based on conditions like time, weather, and so on. But the problem with Alexas is that 1) the devices <i>must</i> support Alexas specifically, and 2) the automations themselves are very limited, only allowing you to do simple things.</p>
<p>Home Assistant doesn't have such limitations. HA is <b>open-source</b> and has a thriving community, meaning you can find plugins that enable integrations for pretty much <b>anything</b> you can think of, and if you don't, you can build such plugins yourself assuming you have the programming chops to do it! HA is very extensible, and thus perfect for power users who want to set up complex automations or integrate unusual devices in unusual ways.</p>
<h2>The Hardware</h2>
<p>For a long time, my setup used to be a simple Raspberry Pi 3b and a SD card. The HA community tells you that this is a bad idea (The 3b is weak and SD cards can die if you use them too much), but in my experience this is fine as long as you don't have too many devices / automations / integrations. It's a good starting point, and it did the trick for me for a couple of years until I started wanting to do more complicated integrations.</p>
<p>Nowadays, I've retired the 3b in favor of a <b>Raspberry Pi 5 w/ 8GB RAM, with a 256GB official RPi NVMe SSD and enclosed on the Argon One V3 case.</b> This gives HA enough power and cooling to do everything that I need with ease.</p>
<div class="post-image">
  <img src="https://i.imgur.com/CRUuh6Q.png">
</div>
<p>Today I run the server via a wired connection, but there was a long period of time where I was running it through WiFi. The community says that this is a bad idea for latency reasons, but I never had any such issues. While the wired connection is definitely much faster, the WiFi latency never really bothered me, so I can confirm it's totally fine to run HA over WiFi if you can't run a cable to it.</p>
<p>For voice control, I use an <b>Alexa</b>. The way this works is that HA has a plugin called <a href="https://www.home-assistant.io/integrations/emulated_hue/">Emulated Hue</a> which allows you to trick an Alexa into thinking your HA server is a Philips Hue hub, allowing you to expose your devices and scripts to the Alexa in order to make use of its voice features. But you can also pay for HA Cloud and enjoy the official "proper" Alexa integration, which I don't because I want to keep everything running on the local network.</p>
<p>I also have a <a href="https://www.amazon.se/-/en/ZBDongle-EFR32MG21-Coordinator-Universal-Assistant/dp/B0BRCWXMSF?th=1">Sonoff ZBDongle-E</a> USB stick plugged into the server in order to drive my Zigbee devices, which I'll mention in more detail further below.</p>
<p>In addition to all of this, I'm using a generic Huawei Android tablet under my TV to serve not only as a physical dashboard, but also as a digital photo album when idle:</p>
<div class="post-image">
  <img src="https://i.imgur.com/hETOc60.png">
</div>
<p>The dashboarding functionality itself is achieved by using <a href="https://wallpanel.xyz/">Wallpanel</a> to expose the tablet's controls to HA, while the photo album logic is handled via HA's <a href="https://github.com/j-a-n/lovelace-wallpanel">lovelace-wallpanel</a> custom integration. I host the photos on the HA itself. For added security, since we're talking about a Chinese Android device, I also have a special rule on my router's firewall that prevents this tablet from communicating with devices outside the local network.</p>
<p>Right now I do not provide a mechanism to allow me to access my HA instance remotely as I don't have a good enough reason to do so, but I wanted to mention that HA has official support for <a href="https://tailscale.com/blog/remotely-access-home-assistant">Tailscale</a>, making it very easy to do if you don't happen to have access to better choices like WireGuard.</p>
<h2>The Protocol</h2>
<p>Currently, I'm running a combination of WiFi and Zigbee devices, which is an alternate wireless protocol made specifically to be used by IoT devices that uses less energy and lays off a mesh network where the devices communicate with each other (as opposed to WiFi devices where everything goes through the router, thus creating a star network).</p>
<div class="post-image">
  <img src="https://i.imgur.com/6sxx3bR.jpeg">
</div>
<p>The reason I run this mix is just because I didn't know about Zigbee in the beginning. If I could go back in time, I would have the entire network consist of Zigbee devices because I think they are just better than WiFi ones overall. It uses significantly less energy (many Zigbee devices can run on those coin cell batteries), the mesh network allows you to have devices very far away from the server, and best of all: they work even when the WiFi is down.</p>
<p>When you buy Zigbee devices, usually the store will say that you need a hub to drive them, which they also sell. It's true that you need a hub, but it doesn't have to be that store's <i>specific</i> hub. When using something like HA, you can use a USB antenna stick like the one mentioned above and that will allow you to control <i>any</i> Zigbee device from any manufacturer via HA.</p>
<h2>The Devices</h2>
<p>Here are the IoT devices that I have around my apartment, excluding things that are "smart" by default like TVs and such.</p>
<h3>Sonoff Basic R2 (WiFi)</h3>
<div class="post-image">
  <img src="https://i.imgur.com/kcvnBvS.jpeg">
</div>
<p>This is a DIY WiFi switch that you hook into "dumb" devices in order to be able to make them smart and turn them on and off via WiFi. Given a bit of skill with electronics (stripping / crimping wires), these switches are much cheaper and more durable compared to buying smart lamps or smart outlets, and I have many of these spread around the apartment!</p>
<p>By default, these require you to expose your device to some awful Chinese cloud server. Luckily for us, you can flash these devices with custom firmware like <a href="https://tasmota.github.io/docs/">Tasmota</a>, allowing you to have full control of them. This also requires skills with electronics and some special equipment, so keep that in mind.</p>
<p>As previously mentioned, If I could go back in time, I would have instead bought a Zigbee equivalent to make things easier and better.</p>
<h3>IKEA INSPELNING (Zigbee)</h3>
<div class="post-image">
  <img src="https://i.imgur.com/oNdutJo.png" style="max-height: 300px;">
</div>
<p>These are similar to the above, but as something that you plug directly into the wall socket instead. This allows you to enjoy the same benefits without having to mess with wires. I use these in cases where I'd like to automate something where messing with the wires would be either tricky or outright impossible.</p>
<p>This added flexibility comes with a price; they are much more expensive than the DIY switches. But another cool thing of these wall sockets is that they even come with sensors that measure your electrical consumption, so you can get a lot of cool data by having a bunch of these around your home.</p>
<p>If you'd like something that uses WiFi instead, I can recommend the <b>Sonoff S26 R2</b>, which is what I used before discovering this IKEA Zigbee one. Just note that they suffer from the same issue of exposing your network to some random cloud as the DIY switch mentioned above.</p>
<h3>Broadlink RM4C mini (WiFi)</h3>
<div class="post-image">
  <img src="https://i.imgur.com/L3Dilv9.jpeg">
</div>
<p>This is a WiFi IR blaster that you can configure IR commands and thus be able to create automations that allow you to control devices that require a remote control, like your TV.</p>
<p>In my case it turned out that newer Samsung TVs have some sort of API integration where you can control them over the web, but I used these blasters for a long time before I discovered this. This also puts your device on some Chinese cloud though, and in this case I'm not sure if custom firmwares are available.</p>
<h2>Ulanzi TC001 (WiFi)</h2>
<div class="post-image">
  <img src="https://i.imgur.com/xpdkJ43.jpeg">
</div>
<p>A hackable LED matrix that can easily be integrated into Home Assistant. Somewhat expensive for what it does, but works really well. I use it as a pretty clock, to show the weather, and to display relevant notifications. This is achieved by ignoring all the default firmware / app stuff and flashing it with <a href="https://blueforcer.github.io/awtrix3/#/">Awtrix 3</a> (very easy, can be done via USB).</p>
<h3>Random IKEA IoT utilities (Zigbee)</h3>
<p>IKEA has <a href="https://www.ikea.com/se/sv/search/?q=smart">lots of IoT devices</a> like buttons, remote controls, motion detectors, temperature thingies, air quality monitors, and more. They are all Zigbee and thus very easy to connect to use. I think only the button and the remote control took a bit more effort because you need to find out exactly how they work in order to build automations against them in HA, but nothing that a simple Google search couldn't solve.</p>
<h3>Home Assistant App</h3>
<p>Last but not least, I have the official Home Assistant app installed on several of my devices. This gives HA access to a bunch of stuff like location, battery level and notifications, which gives me a ton of potential input data for automations.</p>
<h2>The Automations</h2>
<p>It would be too complicated for me to explain every automation and script that I have, so I'll describe this at a higher level only. When you have all of this stuff connected to HA, you can basically do anything you want. Since automations in HA are basically Python scripts, you are limited only by your creativity. As mentioned in the introduction, if HA doesn't natively support something that you want to do then most likely someone already developed an extension for it, and if for some reason that's not the case, you can code it yourself!</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>Here are some of my favorite automations:</p>
<ul>
  <li>Adjusting the color temperature of my hall lights depending on the sun's current position</li>
  <li>Automatically turning off my lava lamp if it has been on for more than 6 hours</li>
  <li>Getting phone notifications when my 3D Printer finishes printing</li>
  <li>Having a direct feed to the dashboard's camera, visible from any other device, like a CCTV</li>
  <li>Turning off the photo album's screen when the TV is turned on, and on again when it's turned off, unless the "Time to Sleep" automation has been triggered very recently, in which case the automation should avoid turning it on again</li>
  <li>Turning on / off the hall's lights based on motion, except if the remote control has been used to manually adjust the light, in which case the automation should do nothing</li>
  <li>Having physical buttons around the house and assigning pre-programmed actions to them</li>
</ul>
<p>As you can see, this is no different than coding any software. The biggest hurdle is providing an abstraction that allows HA to gather and send data to things that are not natively supported by the platform, but in my experience, even the most niche devices out there already have plug-and-play solutions developed by the community, which is amazing.</p>
]]></content>
</entry><entry>
    <title>What happens when you move a file in git?</title>
    <link href="https://swiftrocks.com/what-happens-when-you-move-a-file-in-git" rel="alternate" type="text/html" title="What happens when you move a file in git?"/>
    <published>2024-12-02T14:00:00+02:00</published>
    <updated>2024-12-02T14:00:00+02:00</updated>
    <id>https://swiftrocks.com/what-happens-when-you-move-a-file-in-git</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Is renaming large folders in git repos an issue? Let's find out.</summary>
    <content type="text/html"><![CDATA[
<p>Recently at work we were considering renaming a folder that contains an enormous amount of files, and we wondered whether or not that would have notable negative consequences for our git repository. Would the repo become considerably larger? Would accessing git history become slower? Or would this be completely fine?</p>
<p>After investigating this, I thought the answer was interesting enough that I felt like writing an article about it.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>To answer this question, we need to briefly explain how git works under the hood. There's also a TL;DR at the bottom if you'd like to skip the entire explanation.</p>
<h2>How does git handle files?</h2>
<p>It's somewhat commonly believed that git's commits are <b>diffs</b>, but this is not true. Commits are <b>snapshots</b> of your repository, meaning that when you make changes to a file, git will store a <b>full copy of that file</b> on your repository <a href="https://codewords.recurse.com/issues/three/unpacking-git-packfiles">(there is an important exception, but let's keep it simple for now)</a>. This is why you can easily switch between commits and branches no matter how old they are; git doesn't need to "replay" thousands of diffs, it just needs to read and apply the snapshot for the commit you're trying to access.</p>
<p>Under the hood, git will store all different versions of your files in the <code>.git/objects</code> folder, and this is something we can play with in order to find out what will happen regarding the main question we're trying to answer.</p>
<p>Let's make a new git repo and add a file called <code>swiftrocks.txt</code> with the <code>Hello World!</code> contents, and commit it:</p>
<pre class="command-line language-bash"><code>git init
echo 'Hello World!' > swiftrocks.txt
git add swiftrocks.txt
git commit -m "Add SwiftRocks"</code></pre>
<p>If you now go to <code>.git/objects</code>, you'll see a bunch of folders with encoded files inside of them. The file we just added is there, but which one?</p>
<p>When you add a file to git, git will do the following things:</p>
<ul>
<li>Compress the file with <code>zlib</code></li>
<li>Calculate a SHA1 hash based on the contents</li>
<li>Place it in .git/objects/(first two hash characters)/(remaining hash characters)</li>
</ul>
<p>We can locate our file in the objects folder by reproducing this process, and luckily for us, we don't have to code anything to achieve this. We can find out what the resulting hash for a given file would be by running <code>git hash-object</code>:</p>
<pre class="command-line language-bash" data-output="2"><code>git hash-object swiftrocks.txt
980a0d5f19a64b4b30a87d4206aade58726b60e3</code></pre>
<p>In my case, the hash of the file was <code>980a0d5f19a64b4b30a87d4206aade58726b60e3</code>, meaning I can find the "stored" version of that file in <code>.git/objects/98/0a0d5f19a64b4b30a87d4206aade58726b60e3</code>. If you do this however, you'll notice that the file is unreadable because it's compressed. Similarly to the previous case, we don't have to code anything to de-compress this file! We just need to run <code>git cat-file -p</code> and git will do so automatically for us:</p>
<pre class="command-line language-bash" data-output="2"><code>git cat-file -p 980a0d5f19a64b4b30a87d4206aade58726b60e3
Hello World!</code></pre>
<p>There it is! Let's now make a change to this file and see what happens:</p>
<pre class="command-line language-bash" data-output="5, 7"><code>echo 'Hello World (changed)!' > swiftrocks.txt
git add swiftrocks.txt
git commit -m "Change swiftrocks.txt"
git hash-object swiftrocks.txt
cf15f0bb6b07a66f78f6de328e3cd6ea2747de6b
git cat-file -p cf15f0bb6b07a66f78f6de328e3cd6ea2747de6b
Hello World (changed)!</code></pre>
<p>Since we've made a change to the file, the SHA1 of the compressed contents changed, leading to a <b>full copy</b> of that file being added to the objects folder. As already mentioned above, <b>this is because git works primarily in terms of snapshots rather than file diffs.</b> You can even see that the "original" file is still there, which is what allows git to quickly switch between commits / branches.</p>
<pre class="command-line language-bash" data-output="2"><code>git cat-file -p 980a0d5f19a64b4b30a87d4206aade58726b60e3
Hello World! # The original file is still there!</code></pre>
<p>Now here's the relevant part: <b>What happens if we change our file back to its original contents?</b></p>
<pre class="command-line language-bash" data-output="5"><code>echo 'Hello World!' > swiftrocks.txt
git add swiftrocks.txt
git commit -m "Change swiftrocks.txt back"
git hash-object swiftrocks.txt
980a0d5f19a64b4b30a87d4206aade58726b60e3</code></pre>
<p><b>The hash is the same as before!</b> Even though this is a new commit making a new change to the file, the hashing process allows git to determine that the file is exactly the same as the one we had in previous commits, <b>meaning that there's no need to create a new copy.</b> This will be the case <b>even if you rename the file</b>, because the hash is calculated based on the contents, not the file's name.</p>
<p>This is a great finding, but it doesn't fully answer the original question. We now know that renaming files will not result in new copies of those files being added to the objects folder, but what about folders? And how are those files and folders attached to actual commits?</p>
<h2>How does git handle folders (and commits)?</h2>
<p>The most useful thing to know right off the bat is that <b>commits are also objects in git.</b> This is why you might have seen other folders / files in <code>.git/objects</code> when first inspecting it; the other files were related to the commits you made when adding the file.</p>
<p>Since commits are also objects, we can read them with <code>git cat-file</code> just like with "regular" files. Let's do it with our latest commit (<code>26d4302</code> in my case):</p>
<pre class="command-line language-bash" data-output="2-7"><code>git cat-file -p 26d4302
tree 350cef2a8054111568f82dc87bbd683ee14bb1a6
parent 2891fe1393c9e1bff116c1b58a30bcf85e0596a8
author Bruno Rocha &lt;email> 1733136171 +0100
committer Bruno Rocha &lt;email> 1733136223 +0100
Change swiftrocks.txt back</code></pre>
<p>As you can see, a "commit" is nothing more than a small text file containing the following bits of information:</p>
<ul>
<li>The author of the commit, and the commit message</li>
<li>The hash of the parent commit</li>
<li>The hash of the commit's "tree", containing information about the file system snapshot for that particular commit</li>
</ul>
<p>In this case, what we're interested in is the last point. Luckily for us, <b>trees are also objects in git.</b> Thus, if we want to see what the file system looks like for that particular commit, we just need to run <code>git cat-file -p</code> against the commit's tree hash:</p>
<pre class="command-line language-bash" data-output="2"><code>git cat-file -p 350cef2a8054111568f82dc87bbd683ee14bb1a6
100644 blob 980a0d5f19a64b4b30a87d4206aade58726b60e3  swiftrocks.txt</code></pre>
<p>Like with commits, tree objects are also very simple text files. In this case, the tree states that there's only one file (a blob) in the repository, which is a file called <code>swiftrocks.txt</code> with the <code>980a0d5f...</code> hash. We've already uncovered that git prevents individual files from being duped, but let's see how this is reflected in the tree object:</p>
<pre class="command-line language-bash" data-output="1-4"><code>(made a commit adding some copies, and did cat-file -p on the new commit / tree)
100644 blob 980a0d5f19a64b4b30a87d4206aade58726b60e3  swiftrocks.txt
100644 blob 980a0d5f19a64b4b30a87d4206aade58726b60e3  swiftrocks2.txt
100644 blob 980a0d5f19a64b4b30a87d4206aade58726b60e3  swiftrocks3.txt</code></pre>
<p>The tree object references the new copies and their different names, but as expected, their hashes all point to the same underlying object under the hood.</p>
<p>If we add folders to our repository, the tree object will include references to <i>other tree objects</i> (related to each of those folders), allowing you to <i>recursively</i> inspect each folder of that commit's snapshot. Here's an example:</p>
<pre class="command-line language-bash" data-output="1-4"><code>100644 blob dd99cb611e0c77b2214392b253ed555fb838d8ee  .DS_Store
040000 tree 350cef2a8054111568f82dc87bbd683ee14bb1a6  folder1
040000 tree 11ca8c2fe64b078be34824f071d32a560aba62a7  folder2
100644 blob 980a0d5f19a64b4b30a87d4206aade58726b60e3  swiftrocks.txt</code></pre>
<p>As you can see above, the output directly identifies what each hash is so that you know exactly what you're looking at. (An alternative is to run <code>git cat-file -t</code>, which returns the "type" for a given object hash.)</p>
<h3>So what happens if you rename / move an entire folder?</h3>
<p>The important bit to know here is that <b>tree objects (and commits) are calculated and stored just like regular file (blob) objects</b>, meaning they follow the same rules. This means that if the contents of two folders are exactly the same, <b>git will not create a new tree object</b> for those folders; it will simply reuse the hash it had already computed in the past, just like in the case of files:</p>
<pre class="command-line language-bash" data-output="1-2"><code>040000 tree 350cef2a8054111568f82dc87bbd683ee14bb1a6  folder1
040000 tree 350cef2a8054111568f82dc87bbd683ee14bb1a6  folder1 (copy)</code></pre>
<p><b>However,</b> since tree objects contain references to a folder / file's <b>name</b>, renaming something can result in <b>new tree objects being created for that folder / file's parent tree</b> in order to account for the name change, resulting in new hashes and tree objects <b>recursively</b> all the way up to the root of the repository. This will also be the case when moving files / folders.</p>
<p>The above snippet is one example of this. Even though git was able to avoid duplicating the internal contents of <code>folder1</code>, git still needed to generate a new tree object for its parent in order to account for the fact that a new folder called <code>folder1 (copy)</code> exists. If there are more parents up the chain, they would also require new tree objects.</p>
<p>Whether or not this would be a problem depends on where exactly the change is being made. If the change is too "deep" into the filesystem and / or the affected trees contain a massive number of files then you'd end up with lots of potentially large new tree objects. Still, as you can see, tree objects are quite simple, so you'd need a truly gargantuan repository and / or unfortunate folder setup for this to be an actual problem.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>If you do have a setup that is bad enough for this to be an issue, then the good thing is that there are ways to improve it. By understanding how tree objects are created and which files change / move more often in your repo, it's possible to optimize the structure of your repository to minimize the "blast radius" of any given change. For example, placing files that change very often closer to the root of the repo could reduce the number of trees that would have to be regenerated and their overall size.</p>
<h2>(Bonus) When are commits not snapshots?</h2>
<p>At the beginning of this article, I mentioned that there are cases where commits are <b>not</b> snapshots. While this is not particularly relevant for this article, I wanted to briefly cover this as it's an important aspect of how git works.</p>
<p>We've seen that git will make copies of your files when you change them, but this introduces a massive problem: If a particular file happens to be really big, then duplicating it for every small change could be disastrous.</p>
<p>When this is the case, <b>git will pivot into calculating change deltas</b> instead of making full copies of the file. This feature is called <b>Packfiles</b>, and is something that is automatically managed by git for you. I recommend reading <a href="https://codewords.recurse.com/issues/three/unpacking-git-packfiles">this great write-up by Aditya Mukerjee</a> if you'd like to know more about it.</p>
<h2>TL;DR</h2>
<ul>
<li>Git works in terms of snapshots (for the most part)</li>
<li>Git knows that two files are the same and can avoid duplicating them in its internal storage, even if they have different names</li>
<li>Similarly, Git can also determine if two folders are the same, regardless of where they are or are named</li>
<li>Thus, renaming files or folders will not have any impact on git's internal storage for those files and folders</li>
<li>However, git may end up needing to duplicate information regarding <b>parent folders</b>, recursively, to account for naming changes and / or new files</li>
<li>In theory this can be an issue if the change happens very "deeply" into the file system and / or the parent folders contain massive amounts of files, but you'd need a truly gargantuan repository and / or unfortunate folder setup for this to be an actual problem</li>
<li>Understanding how git objects work under the hood allows you to optimize your repository's folders in ways that can prevent too many unnecessary objects from being created</li>
</ul>
<h2>Sources / References</h2>
<ul>
<li><a href="https://jvns.ca/#git">Julia Evans's many articles on git</a></li>
<li><a href="https://codewords.recurse.com/issues/three/unpacking-git-packfiles">Unpacking git packfiles</a></li>
<li><a href="https://www.youtube.com/watch?v=fCtZWGhQBvo">Git from the inside out</a></li>
]]></content>
</entry><entry>
    <title>Focus not on the task, but on the problem behind the task</title>
    <link href="https://swiftrocks.com/focus-not-on-the-task-but-on-the-problem-behind-the-task" rel="alternate" type="text/html" title="Focus not on the task, but on the problem behind the task"/>
    <published>2024-11-18T14:00:00+02:00</published>
    <updated>2024-11-18T14:00:00+02:00</updated>
    <id>https://swiftrocks.com/focus-not-on-the-task-but-on-the-problem-behind-the-task</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Being able to look at the bigger picture is critical when writing code. In this post, we'll take a brief look at what this means and how you can do it.</summary>
    <content type="text/html"><![CDATA[
<p>Consider the following situation: A team is asked by their Product Manager to implement features X, Y, and Z into an existing system.</p>
<p>The team then organizes itself and executes the project. After a certain amount of time, they delivered exactly what was asked of them. But then, one of these things happens (choose at least one):</p>
<ul>
<li>The features work only for the happy path, failing miserably at any sort of edge-case</li>
<li>The features work as expected, but were designed so badly they are immediately considered tech debt</li>
<li>The features work as expected, but are considered useless by the users of the system and end up completely unused (they do not solve those users' problems)</li>
</ul>
<p>What do you think happened here? Is this the Product Manager's fault for giving wrong requests, or the engineering team's fault for not understanding what was asked of them?</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>Some people will say this is the PM's fault, and in some cases it might be true. But the situation I want to cover here is the scenario where this is the <b>engineers' fault</b>, because it's something I've seen countless times throughout my career.</p>
<p>The reason the scenario above happened (when the PM is not the one at fault) is because the engineers focused too much on the <i>immediate</i> task they were given, when what they should've done is <b>focus on the problem behind the task</b>, by asking themselves questions such as:
<ul>
<li>What's the <b>context</b> behind this ask? Is this a larger project that includes other features and tasks?</li>
<li>Who exactly is asking for this? (Does anyone actually need this?)</li>
<li>What <b>problem</b> are these users facing that led to this ask?</li>
<li>Did someone attempt to solve this problem before? What did they try to do?</li>
<li>Who is going to benefit from this ask being executed? How would they use the solution?</li>
</ul>
<p><b>It's only after understanding this context that you can consider yourself ready to come up with a technical solution to it.</b> But what happens a lot is that some engineers tend to <b>immediately</b> jump into problem-solving as soon as they are presented with a task, leading to solutions that despite being "accurate" when evaluating the task in isolation, completely miss the mark when looking at the bigger picture. In short, the issue was that the engineers in that situation had <b>too much tunnel vision.</b></p>
<div class="post-image">
  <img src="https://i.imgur.com/BfKDQC5.png" alt="Alt">
</div>
<div class="post-image">
  <img src="https://i.imgur.com/IHGr3P5.png" alt="Alt">
</div>
<p>Understanding the context behind tasks allows you to come up with a solution that fits the bigger picture, making it possible not only to solve your users' problems, but also to do so in a way that is clean, scalable, easy to maintain, and that benefits everyone (as opposed to being beneficial to you and your team, but a pain in the ass for everyone else in the company).</p>
<p>In <a href="https://www.oreilly.com/library/view/the-staff-engineers/9781098118723/">The Staff Engineer's Path</a>, Tanya Reilly describes this as the <b>Local vs Global Maxima</b> problem, where the Local maxima means focusing on what's good for you or your team in an individual sense (the tunnel vision situation above), and the Global maxima means focusing on what's good <b>for the company as a whole</b>, regardless of whether or not it would be ideal for you as an individual (the big picture situation). In the book, she presents this idea to argue that this focus and ability to gather context about the bigger picture is a <b>core ability of Staff+ level engineers</b> and a minimum requirement for those aspiring to reach that level.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>Although I agree with her that only Staff+ engineers should be <i>expected</i> to be masters at this, I do also believe that this is something everyone should attempt to do, regardless of level. Doing so not only improves your knowledge of how your company works and is structured, but also teaches you how to better determine what does and doesn't matter when trying to solve a particular problem, enabling you to be more effective both at coding and at providing value for your company.</p>
]]></content>
</entry><entry>
    <title>Working at startups vs large companies</title>
    <link href="https://swiftrocks.com/working-at-startups-vs-large-companies" rel="alternate" type="text/html" title="Working at startups vs large companies"/>
    <published>2024-10-14T21:00:00+02:00</published>
    <updated>2024-10-14T21:00:00+02:00</updated>
    <id>https://swiftrocks.com/working-at-startups-vs-large-companies</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Working at a large company like Apple or Google is a common goal in the tech industry. But are they a good fit for you?</summary>
    <content type="text/html"><![CDATA[
<p>Working at a large company like Apple or Google is such a common goal in the tech industry that there's even a market for selling courses and books designed to help people achieve this goal.</p>
<p>But one thing that I've learned in my career is that working at such companies is <b>not for everyone.</b> The experience of working at a large company is extremely different from that of a startup, so if you're not aware of those differences, you can end up having a big (negative) surprise down the road that can make you regret your choices.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>In this article, I'd like to show you the difference between companies of different sizes so that you can <b>determine which one better fits your personal style and interests.</b></p>
<blockquote>Disclaimer: I haven't worked at every company to ever exist in this planet, so this is obviously not a 100% perfect model for every company out there. <b>There are always exceptions</b>, this is just a basic description of the average case.</blockquote>
<h2>Working at a startup</h2>
<p><b>Pros:</b></p>
<ul>
<li>Great to get experience in a wide variety of topics and areas</li>
<li>Growth potential is huge</li>
<li>Little to no bureaucracy or politics</li>
<li>Generally a great community / vibe overall</li>
</ul>
<p><b>Cons:</b></p>
<ul>
<li>Generally crap pay</li>
<li>Highly unstable</li>
<li>Little to no engineering challenges (startups often prioritize speed)</li>
<li>Work is complete chaos</li>
<li>Most likely going to work with a product that nobody cares about</li>
</ul>
<p>Working at a startup is the most fun I've had in my career, but I think it takes a special kind of person to thrive in this environment.</p>
<p>I feel that working at a startup is <b>ideal if you have an entrepreneurship mindset</b>, because you not only get to be constantly exposed to the organizational side of things, you are likely also involved in it. This allows you to build a lot of experience with how companies work under the hood, which I've found to be really handy overall.</p>
<p>Another thing I like about startups is that the vibe is generally very positive. Since there aren't a lot of people in the company, there's basically <b>no bureaucracy</b> and chances are that everyone gets along well. This also makes it so that you can grow quite fast in the company, provided that the company itself is doing well in the first place.</p>
<p>In general, <b>startups are a high-risk high-reward situation.</b> While you can win big fast, you can lose big just as fast because any minor setback can destroy the entire company. This is another reason why I find them best for those with an entrepreneurship itch. The work itself also tends to be very chaotic and thus not something that someone looking for stability would enjoy.</p>
<p>Another important downside to mention is that the <b>engineering side of things tends to be a bit dull.</b> Since startups often prioritize speed, building things tends to be down-prioritized in favor of going for easy out-of-the-box and / or plug-and-play open-source solutions, making a software engineering job feel more like assembling LEGO than anything else. Every work I had as a mobile engineer at a startup was basically 100% building UI, which became really boring to me after a while.</p>
<h2>Working at a mid-level company</h2>
<p><b>Pros:</b></p>
<ul>
<li>Generally good pay and benefits</li>
<li>Better engineering challenges than the startups</li>
<li>Opportunity to work with popular products</li>
<li>Mostly stable</li>
</ul>
<p><b>Cons:</b></p>
<ul>
<li>Growth potential is not as great when compared to a startup</li>
<li>Some bureaucracy / politics</li>
<li>Despite the presence of interesting challenges, there aren't many sufficiently skilled engineers to tackle them / the engineering culture is not strong enough</li>
</ul>
<p>The mid-level company is the company that is big enough to overcome the downsides attributed to startups, but nowhere as big enough to have the pros attributed to large companies. In general, the pros/cons of a mid-level company are essentially the averages of the other two cases in this article.</p>
<p>The primary problem with mid-level companies is that they try to mimic the processes and objectives of large companies, <b>but have nowhere near as many resources as they do.</b> This results for example in the team being tasked to solve <i>massive</i> engineering infrastructure challenges, because that's what large companies do, even though almost no one in the team is skilled enough to pull it off (likely because most who did have such skills ended up getting poached by the large companies). This puts giant pressure on these select few, which on one side can be seen as a great growth opportunity, but on the other side puts the company into a difficult position, as said people are likely to either burn out or leave in favor of an actual large company.</p>
<p>With that said, I find that mid-level companies still offer great growth opportunities. I think they are good choices for people who like the vibe and stability of large companies but can't stand the downsides of working at actual large companies.</p>
<h2>Working at a large company</h2>
<p><b>Pros:</b></p>
<ul>
<li>Life-changing pay and benefits</li>
<li>World-class engineering challenges</li>
<li>Opportunity to work with some of the smartest people on the planet</li>
<li>In some cases, opportunity to pioneer / define tech trends for the entire planet</li>
<li>Opportunity to work with products that are used / loved on the entire planet</li>
<li>Apart from potential layoffs, they are extremely stable / too big to fail</li>
</ul>
<p><b>Cons:</b></p>
<ul>
<li>Unbearable politics</li>
<li>Growth is extremely hard</li>
</ul>
<p>By "large company", we're talking about tech giants like Google, Apple, Meta, and so on. Looking at the pros, it's easy to see why people dream of working at such places. But what a lot of people don't know is that there are strong downsides attached to working at such companies, and <b>being able to tolerate them is critical to succeed there.</b> I've met many folks who couldn't and ended up leaving.</p>
<p>The first and most critical downside is that <b>everything is covered by a thousand layers of bureaucracy and politics.</b> I cannot overstate how unbearable this is, but it's how things at companies of this size.</p>
<p>When you work at a startup, if you want to do something, you just go there and do it. For a mid-level company, it might be slightly more annoying, but still doable. But when you work at a large company, if you want to do something, you're going to have to have a <b>meeting about having a meeting about drafting a document about a meeting about drafting another document</b>, which hopefully will be picked up by the planning season several months later, leading to more meetings and documents until <i>hopefully</i> you get to do some actual work around a year later, unless the company re-orgs sometime during this process, in which case you'll have to drop everything and start from scratch.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>This boundless bureaucracy extends everywhere, <b>including the promotion process.</b> Growing at such companies can be extremely hard as the process involves considerable amounts of bureaucracy and things that are outside of your control, especially for Staff+ positions. Which team you're part of also plays a big role as some teams are bound to have more opportunities to drive impact than others in a company of this size.</p>
<p>I think that thriving at a large company is directly <b>correlated to how much you can tolerate such politics.</b> No one would look at this description and be happy, but if you look at it and feel that you could take it, then working at a large company might be for you.</p>
<h2>Conclusion</h2>
<p>As I mentioned in the beginning, this is just a basic description of the average case. There are thousands of exceptions who surely don't fit into these descriptions. But the idea is just to present that the concept of <b>trade-offs also applies to companies and cultural fit.</b> Just because one company is larger than the other doesn't necessarily mean it's best you; depending on what you value, you might find that smaller companies are a better fit for you.</p>
]]></content>
</entry><entry>
    <title>My process for learning new languages</title>
    <link href="https://swiftrocks.com/my-process-for-learning-new-languages" rel="alternate" type="text/html" title="My process for learning new languages"/>
    <published>2024-09-01T10:00:00+02:00</published>
    <updated>2024-09-01T10:00:00+02:00</updated>
    <id>https://swiftrocks.com/my-process-for-learning-new-languages</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>In this article, I would like to share the process I personally used more than once (and am still using) to tackle the challenge of learning a new language with great success.</summary>
    <content type="text/html"><![CDATA[
<p>Throughout my life, I have met several people who struggle to learn a new language, with some of them being unable to communicate at a basic level despite having studied for several years.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>I believe that learning a language is not a matter of talent, but that of dedication and <b>following a good process.</b> In this article, I would like to share the process I used more than once (and am still using) to tackle the challenge of learning a new language with great success. I currently speak three languages (native Portuguese, English, Swedish), and am in the process of learning a fourth (Japanese).</p>
<h2>My process</h2>
<p>For me, learning a new language consists of three major steps:</p>
<ul>
  <li>Learning basic grammar</li>
  <li>Becoming good at reading and listening</li>
  <li>Becoming good at speaking</li>
</ul>
<h3>Learning basic grammar</h3>
<p>My first step towards learning a new language consists of understanding the basics of the language. This includes things like learning how sentences are structured, how words should be pronounced, how to count, and any other language-specific basics that may apply (for example, for Swedish, learning the difference between <i>en / ett</i>, or the concept of <i>soft / hard vowels</i>).</p>
<p>The word "basic" here is <b>very</b> important. I want to have a good understanding of how things work in that language, but I don't want to waste time reasoning about complex grammar rules. Think of the sorts of things a mom would correct a child for; my mom would correct me if I used a word in the wrong place, but she wouldn't lecture me about the theory of participle clauses.</p>
<p>Knowledge of basic grammar massively pays off because later on it will simplify the process of expanding the vocabulary. Although at this point I will not know many words, my knowledge of basic grammar will allow me to more easily figure out how to pronounce any new words that I may encounter in the future, to properly classify them (subject? verb? noun? adjective? present? past tense?) based on their format and position in a sentence, and in some cases even accurately guess their meaning based on this information.</p>
<p>Although in the next section I'm going to complain about traditional language learning books / schools, I think they are one of the best resources for learning basic grammar. It's also usually straightforward and can be mastered in just a couple of months.</p>
<h3>Becoming good at reading and listening</h3>
<p>But this is about as far as those language schools and books will help you out, because in my opinion they massively fuck up pretty much everything beyond this point.</p>
<p>In my experience, after learning basic grammar, schools and books usually follow up by teaching <i>advanced grammar</i>. I think this is a complete waste of time and is why in my opinion many adults struggle with learning a language despite attending classes for multiple years. Learning complex grammar rules will <b>not</b> help you learn the language, even natives don't know this stuff!</p>
<p>What natives know is <b>vocabulary</b>, and this is what I believe is the right focus at this stage. My goal then becomes to expand my vocabulary as much as possible by immersing myself in the language, consuming as much media as I can and as frequently as possible. This is something that is usually referred to as the <b>immersion method</b>.</p>
<p>Here are some examples of things I do in this step:</p>
<ul>
<li>Changing the language of my phone / computer</li>
<li>Watching shows with either sound or subtitles in that language, preferably both if available</li>
<li>Listening to podcasts, sometimes actively and sometimes passively as background noise</li>
<li>Finding internet forums / subreddits / YouTube channels for topics I like</li>
<li>Reading the news</li>
</ul>
<p>You might think that this doesn't make sense because you won't understand anything, but that's exactly the point. Children also don't understand anything at first, yet magically they seem to just "get it" after one point, simply by being exposed to the language. This is because our brains are big pattern-matching machines; the more you expose yourself to a language, the more patterns / words you discover, which leads to further discoveries until you eventually reach a point where everything just clicks. In other words, the purpose of this step is to try to replicate how a child would learn a language at home.</p>
<p>I find watching shows / YouTube videos to be particularly excellent for this because you can usually guess what a word means based on the context of the scene, meaning you don't need to spend as much time translating words as you would when compared to other types of media.</p>
<p>Duolingo can also be a good tool to expand your vocabulary, as long as you don't use it in isolation. This is because although Duolingo is a good way to learn new words, it tends to be quite bad at everything else (e.g grammar), so I think it's important to back it up with the other methods mentioned in this section. It's important to note also that the quality of Duolingo's exercises varies greatly between languages, so looking for reviews before getting started is a must here.</p>
<p>If you tend to quickly forget things like I do, a <b>spaced repetition system</b> can greatly assist you with fixating all of this new knowledge. In my case I quite enjoyed using <a href="https://readwise.io/">Readwise</a> for this, but I know many who have used <a href="https://apps.ankiweb.net/">Anki</a> / traditional flashcards with great success.</p>
<p>This entire process is very painful at first, but gets easier with time as your vocabulary improves. The unfortunate part is that this is a lengthy process; it can take several years of doing this before reaching a point where reading / listening to the language becomes effortless, and I think there's no way around it.</p>
<h3>Becoming good at speaking</h3>
<p>Although the previous step is excellent at making me good at reading and listening, in my experience it doesn't necessarily help me become good at <i>speaking</i>. When I was learning Swedish for example, although I had an easy time understanding what people were saying and knew in theory what to answer back, I still had a very hard time doing so, mostly because I just wasn't used to it. Although I knew the vocabulary in theory, it would still take several seconds for the right words to emerge in my mind when having a conversation with someone.</p>
<p>Unlike the other steps, I don't think there is any special method that one can use to become good at speaking a new language. This is something you just have to keep doing until your brain gets used to it. It's a massive advantage if you actually live in the country in question, but this is doable even if you don't as there are many online services designed around connecting you with native speakers of a particular language. I personally never used them though, so I cannot comment on their efficiency.</p>
<p>Another interesting to mention is that nowadays there are websites that connect LLMs to voice recognition models, allowing you to chat with something like ChatGPT with your voice for the purpose of language learning. I've tried one but personally didn't like the experience as talking to a robot felt completely different from talking to a real person, but if you'd like to try it out, you can easily find them on Google (there are hundreds of websites for this as of writing).</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>I think the most important part here is to resist the urge to switch to another language when you start to struggle, especially if you live in a country like Sweden where the natives are good at English. (In fact I would say that the hardest thing about learning a language like Swedish is not the language itself, but rather that Swedes are so good at English that they automatically switch to it when they see you struggling with Swedish, making it almost impossible for you to improve!)</p>
<h2>Conclusion</h2>
<p>Although we can divide the process of learning a new language in logical steps, we're still talking about a multi-year effort. That's just how it works, there are no shortcuts. If you struggle with learning a new language, I hope this post was able to teach you something new that can help you in your journey!</p>
]]></content>
</entry><entry>
    <title>What are mobile release engineering teams and when do you need one? (Runway)</title>
    <link href="https://www.runway.team/blog/what-are-mobile-release-engineering-teams-and-when-do-you-need-one" rel="alternate" type="text/html" title="What are mobile release engineering teams and when do you need one? (Runway)"/>
    <published>2024-06-28T09:00:00+02:00</published>
    <updated>2024-06-28T09:00:00+02:00</updated>
    <id>https://www.runway.team/blog/what-are-mobile-release-engineering-teams-and-when-do-you-need-one</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Let's look at how releasing works in big tech companies!</summary>
    <content type="text/html"><![CDATA[
<p>The early (and also not-so-early) days of building a tech startup means hiring and working with people who are capable of wearing a lot of hats. There are a ton of things to do and nowhere near an equal amount of resources to do them. Even if you join as a specialist, chances are you'll find yourself getting deep into other areas.</p>

<p>This is true across the organization, including in mobile engineering. Early engineers don’t just write the code that builds the foundation for the app’s future success (while building up the tech debt that future engineers will pull their hair out over) but also the initial infrastructure both for how teams get things done and how they ship code out the door.</p>

<p>This doesn’t last forever though. As teams grow they make the transition out of generalist, jack-of-all-trades roles and begin focusing on specialization. But one part of the org where there is often a lag in making this transition — and sometimes a very long one — is on the mobile team. Very few mobile engineers will have time to support both their team's app features and the series of Ruby scripts that support their release process, yet the expectation that they do both often lingers far beyond when other teams in the organization have fully specialized.</p>
<p>In this article, we'll look at why this happens and how big tech companies follow-up on this problem.</p>
]]></content>
</entry><entry>
    <title>Recommended WWDC24 Sessions</title>
    <link href="https://swiftrocks.com/recommended-wwdc24-sessions" rel="alternate" type="text/html" title="Recommended WWDC24 Sessions"/>
    <published>2024-06-17T11:20:00+02:00</published>
    <updated>2024-06-17T11:20:00+02:00</updated>
    <id>https://swiftrocks.com/recommended-wwdc24-sessions</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Every year I watch WWDC and write down some notes.</summary>
    <content type="text/html"><![CDATA[
<p>Every year I watch WWDC and write down some notes. But I've just realized that I've never shared those notes and it felt like something I should do, so I've decided to do just that!</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>My approach is to pick a handful of sessions that are immediately useful / interesting to me and ignore the rest. I find this to be a good strategy because in my experience trying to keep up with things that you don't care about / don't have an immediate need for is a very easy way to burn yourself out, especially because Apple has this awful habit of announcing things and then proceeding to make them completely obsolete the next year. If in the future I happen to start working with something where one of the ignored sessions would be handy, I go back and watch it. Otherwise, it stays unwatched.</p>

<p>I think the Keynote and the State of the Union should always be watched, so I won't cover them here.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10179">Meet Swift Testing</a></h2>
<p>I really like this feature. Greatly recommend watching this as it shows not only how it works but also many interesting tricks that you can do with it. To make it better, it's open source and even works on VSCode, although I haven't tried the latter myself.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10061">What’s new in StoreKit and In-App Purchase</a></h2>
<p>I watch StoreKit sessions because I have an app that has IAPs, so I'm always eager to see what's new in this regard. StoreKit Views aren't a new concept but I'm glad to see they made them more powerful. They also show how you can test IAPs directly in Xcode, which is pretty neat.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10136">What's new in Swift</a></h2>
<p>This session happens every year and it's always a good watch. As someone who has been working with build systems a lot recently, I'm particularly interested in the new explicit modules feature.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10135">What's new in Xcode 16</a></h2>
<p>This is a great watch as Xcode 16 changed quite a bit in good ways. The time profiler now has a flame graph, and the new unified backtrace view looks awesome.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10118">What's new in UIKit</a></h2>
<p>I haven't worked directly with UI for a very long time, but I enjoy watching these to see what they're improving. I like the improved interop between SwiftUI and UIKit and the new fluid animation type. The new <code>UIUpdateLink</code> type is also very interesting.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10144">What's new in SwiftUI</a></h2>
<p>Similarly to "What's new in UIKit", I enjoy watching these to see what's up with the frameworks. Particularly great things this year are custom containers, how things like <code>@Environment</code> and state in <code>Previews</code> have been greatly simplified, and a much better integration with scroll views.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10197">Go small with Embedded Swift</a></h2>
<p>This is one of those things that I don't have a use for but watch anyway because it sounded cool, and indeed it was. I think this can also work as a hardcore app size optimization for your apps if you're fine with losing a bunch of Swift's features.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10157">Extend your app’s controls across the system</a></h2>
<p>Watching sessions about new iOS features is always a good idea if they relate to something that you can potentially implement in your apps. I can think of many things that I can App Controls for and it seems also really easy to implement since it's all based on the existing Widgets infra.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10181">Xcode essentials</a></h2>
<p>This session is great. Xcode has a ton of tools and shortcuts that we're not aware of, and many of them are extremely useful if you can remember that they exist!</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10171">Demystify explicitly built modules</a></h2>
<p>Apart from talking about the new Swift 6 feature of the same name, this session goes into great detail about how imports work in Swift/Obj-C and how to debug them. I learned a lot from this one.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10146">Demystify SwiftUI containers</a></h2>
<p>I am not super interested in SwiftUI improvements, but the new custom container feature is a great addition. I believe this is something that will be used a lot, so it's worth it to check this session that shows how it works and what you can do with it. This session also shares many interesting details about how subviews work in SwiftUI.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10170">Consume noncopyable types in Swift</a></h2>
<p>Most people will probably never use this feature, but it's one of those things that are really cool in practice and worth a look. You might also want to check this out because generics involving the new <code>~Copyable</code> type are really complicated, so watching this session will help you be less confused if you end up bumping into it.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10198">Run, Break, Inspect: Explore effective debugging in LLDB</a></h2>
<p>Every year has a session on LLDB, and this year's one is especially good. It's hard to summarize this one because they show a ton of different things, so just go there and watch it! I was surprised to find out that you can open crash logs in Xcode (maybe it was always a thing?) and that you can create "manual" breakpoints by calling <code>raise(SIGSTOP)</code>.</p>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10217">Explore Swift performance</a></h2>
<p>This was not as actionable as I thought it would be, but I still found it to be interesting because it contains "official" evidence about how structs/protocols can be bad for performance / app size if you misuse them, which is something I've covered in a recent talk and that a lot of people wanted to know more about.</p>

<div class="sponsor-article-ad-auto hidden"></div>

<h2><a href="https://developer.apple.com/videos/play/wwdc2024-10173">Analyze heap memory</a></h2>
<p>This session not only shows interesting examples of how to use the memory debugger and instrument, but also shares a lot of interesting pieces of info about the difference between <code>weak</code> and <code>unowned</code> that I believe weren't documented before, including how to debug their performance! It also now serves as an "official" source for <a href="https://swiftrocks.com/autoreleasepool-in-swift">the autoreleasepool trick I wrote an article about a long time ago</a>, which is pretty neat.</p>
]]></content>
</entry><entry>
    <title>Using @_silgen_name to forward declare functions in Swift and improve build times</title>
    <link href="https://swiftrocks.com/using-silgenname-to-call-private-swift-code" rel="alternate" type="text/html" title="Using @_silgen_name to forward declare functions in Swift and improve build times"/>
    <published>2024-03-14T14:00:00+02:00</published>
    <updated>2024-03-14T14:00:00+02:00</updated>
    <id>https://swiftrocks.com/using-silgenname-to-call-private-swift-code</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Let me start this post with a disclaimer. The trick I'm going to show here is quite powerful, but much like every other underscored attribute in Swift, this is something you should not mess with unless you know exactly what you're doing.</summary>
    <content type="text/html"><![CDATA[
<blockquote>Disclaimer: The trick I'm going to show here is quite powerful, but like every other underscored attribute in Swift, this is something you should avoid messing with unless you know exactly what you're doing. There are lots of pitfalls attached to these attributes, and the behavior of underscored attributes can change at any time and even stop existing entirely without warning. Don't go around sprinkling this in your projects if you don't fully understand the consequences of doing so!</blockquote>
<p>Swift is regarded for its type safety, meaning the compiler (usually) doesn't allow you to reference or do things that might potentially not exist / be invalid; the complete opposite of languages like Obj-C where the compiler allows you to do pretty much whatever you want in exchange for compile-time safety.</p>
<p>But here's an obscure fact about Swift: The language <i>does</i> support ObjC-like <code>Selectors</code> / forward declarations, it's just that we're not supposed to use it. If you know how a function is going to be named in the compiled binary, you can use the <code>@_silgen_name</code> attribute to craft a <b>direct reference</b> to that function, allowing a module to reference and call it regardless of whether or not it actually has "visibility" of it:</p>
<pre><code>@_silgen_name("somePrivateFunctionSomewhereThatICantSee")
func refToThatFuncIReallyWantToCall()

func foo() {
    refToThatFuncIReallyWantToCall() // Just called something I wasn't suposed to be able to!
}</code></pre>
<p>This is used extensively by the Swift standard library to create something akin to the old-school <b>forward declarations</b> in Obj-C / C, allowing it to call functions that live deeper in the Swift Runtime even though it shouldn't be able to. As denoted by the underscore, this is <b>not</b> an official feature of Swift, but rather an internal detail of the compiler that <b>is not meant to be used outside of this specific internal case.</b> Nonetheless, you <i>can</i> use it in your regular Swift apps, so if you know what you're doing and is aware of the consequences / implications, you can do some pretty neat stuff with it.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<h2><code>@_silgen_name</code> and symbol mangling</h2>
<p>Since Swift has namespacing features, the names you give to your Swift functions are not actually what they will be called in the compiled binary. To prevent naming collisions, Swift injects a bunch of context-specific information into a function's symbol that allows it to differentiate it from other functions in the app that might have the same name, in a process referred to as <b>symbol mangling</b>:</p>
<pre><code>// Module name: MyLib
func myFunc() { print("foo") }</code></pre>
<pre class="command-line language-bash" data-output="3-4"><code>swiftc -emit-library
nm libMyLib.dylib
MyLib.myFunc()'s "real" name is:
$s5MyLib6myFuncyyF</code></pre>
<p>What <code>@_silgen_name</code> does under the hood is <b>override a function's mangled symbol</b> with something of your choosing, giving us the ability to reference functions in ways that Swift generally wouldn't allow us to (which I'll show further below).</p>
<p>The attribute can be used in two ways: to override the symbol of a declaration and to override the symbol of a <i>reference</i> to a declaration. When added to a <b>declaration</b>, as in, a function with a body, the attribute overrides that function's mangled name with whatever it is that you passed to the attribute:</p>
<pre><code>@_silgen_name("myCustomMangledName")
func myFunc() { print("foo") }</code></pre>
<pre class="command-line language-bash" data-output="3-4"><code>swiftc -emit-library -module-name MyLib test.swift
nm libMyLib.dylib
MyLib.myFunc()'s name now is:
myCustomMangledName</code></pre>
<p>This is interesting, but what we truly care about here is what happens when you add it to a function that <b>doesn't</b> have a body. This would usually be invalid Swift code, but because we've added <code>@_silgen_name</code> to it, the compiler will treat it as valid code and assume that this function is <i>somehow</i> being declared somewhere else under the name we passed to the attribute, effectively <b>allowing us to build forward declarations in pure Swift:</b></p>
<pre><code>@_silgen_name("$s5MyLib6myFuncyyF")
func referenceToMyFunc()

func foo() {
    // Successfully compiles and calls MyLib.myFunc(), even though
    // this module doesn't actually import the MyLib module
    // that defines myFunc()
    referenceToMyFunc()
}</code></pre>
<p>(This only works if the "target" is a free function, so for things like a class's static functions you'll need to first define a function that wraps them.)</p>
<p>Now, it should be noted that knowing a Swift function's mangled name in advance (<code>$s5MyLib6myFuncyyF</code>, in the above example) is not straight-forward as the compiler doesn't expose an easy way of predicting what these values will be, but we can fix this by using <code>@_silgen_name</code> on the declaration itself in order to modify it to something that we know and is under our control, like in the previous example where we replaced it with <code>"myCustomMangledName"</code>. Note that you only need to worry about this when referencing Swift functions; For Obj-C / C, a function's "mangled name" will be the function's actual name as those languages have no namespacing features.</p>
<pre><code>@_silgen_name("myCustomMangledName")
func referenceToFooMyFunc()</code></pre>
<p>It's critical to note that this is extremely <b>unsafe</b> by Swift compiler standards as it sidesteps any and every type safety check that would normally apply here. <b>The compiler will not run any validations here</b>; it will instead completely trust that you know <i>exactly</i> what you're doing, that somehow these functions will exist in runtime even though this doesn't seem to be the case during compilation, that any custom names you're using are unique and not causing any potential conflicts with other parts of the codebase, and that whatever parameters you're passing to the forward-declared functions are correct and managed properly memory-wise (if your target is a C function, you need to do manual memory management with <code>Unmanaged&lt;T></code>).</p>
<p>If everything is done correctly, you just got yourself a nice forward-declared function, but if not, you'll experience undefined behavior. You <i>do</i> get a compile-time linker error though if the functions don't exist at all, which is pretty handy as I've noticed that in addition to all of the above concerns, the compiler also may sometimes accidentally tag these functions as "unused" depending on how you declare them, causing them to be stripped out of the compiled binary when they should not. I am sure that there are way more things that can go wrong here that I'm not aware of.</p>
<h2>Cool, but why?</h2>
<p>Lack of safety aside, there are two situations where I find this attribute useful outside the Swift standard library. The first one is being able to do <b>C interop</b> without having to define annoying headers and imports, similar to how the Swift standard library has been using it. It seems that a lot of people have been doing this, but I'll not cover this here because it's not the use case that led me to use this attribute. I'll just point out that this is something you also need to be very careful about, particularly because <code>@_silgen_name</code> functions use the Swift calling convention, which is incompatible with C (thanks Ole Begemann for pointing that out!).</p>
<h3>Trading safety for better build times</h3>
<p>The second one however, which is what I have been using this for, is that when applied strategically, you can use this attribute to <b>greatly improve your app's incremental build times.</b></p>
<p>Let's assume that we're developers of a large modularized Swift app that has some sort of type safe dependency injection mechanism to pass values around. For this mechanism to work, we might end up with a "central" registry of dependencies that imports every module and configures every possible dependency these modules might request:</p>
<pre><code>import MyDepAImplModule
import MyDepBImplModule
import MyDepCImplModule
...

func setupRegistry() {
    myRegistry.register(MyDepA(), forType: MyDepAProtocol.self)
    myRegistry.register(MyDepB(
        depA: myRegistry.depA,
    ), forType: MyDepBProtocol.self)
    myRegistry.register(MyDepC(
        depA: myRegistry.depA,
        depB: myRegistry.depB,
    ), forType: MyDepCProtocol.self)
}</code></pre>
<p>Something like this allows us to have a nice and safe system where features are unable to declare dependencies that don't exist, but it will come at the cost of <b>increased incremental build times.</b> Importing all modules like this will cause this module to be constantly invalidated, and the bigger your project gets, the worse this problem will get. In my personal experience, projects with a setup like this and with several hundred modules can easily end up with a massive <b>10~60 seconds delay</b> to incremental builds, depending on the number of modules and how slow your machine is.</p>
<p>However, by using forward-declared <code>@_silgen_name</code> references to a function that wraps the initializers instead of referencing these initializers directly, we can achieve the same injection behavior <b>without having to import any of the modules that define said initializers!</b></p>
<pre><code>@_silgen_name("myDepAInitializer") func makeMyDepA()
@_silgen_name("myDepBInitializer") func makeMyDepB(_ depA: MyDepAProtocol)
@_silgen_name("myDepCInitializer") func makeMyDepC(_ depA: MyDepAProtocol, _ depB: MyDepBProtocol)</code></pre>
<p>This allows projects like this to completely eliminate these build time bottlenecks, but it comes at the price of losing all type safety around this code. This might sound like a bad trade-off since type safety is the reason why a developer would want to have a dependency injection setup like this in the first place, but if you have other ways of validating those types and dependencies (such as a CLI that scans your app and automatically generates / validates this registry), you can abstract the dangerous bits away from your developers and effectively enjoy all the build time improvements without having to worry about any negatives other than having to be extra careful when making changes to this part of the code.</p>
<h2>Conclusion</h2>
<p>Forward-declaring Swift functions allow you to do all sorts of crazy things, but remember, <b>this is not an official feature of the language</b>. As mentioned in the beginning, my recommendation is that you should avoid messing with internal compiler features unless you're familiar with how Swift works under the hood and know exactly what you're doing.</p>
<p>But putting this aside, one thing that I tend to reflect on when learning about features like this is how the danger involved in using them is not so much about the features themselves, but rather that their behavior might change without warning.</p>
<div class="sponsor-article-ad-auto hidden"></div>
<p>Although I understand the Core team's vision of making Swift a safe and predictable language, I think there is a real demand for having poweruser-ish / "I know this is dangerous, I don't care" features like this officially supported in Swift, and it would be amazing if <code>@_silgen_name</code> could be recognized as one such feature. I like what you can achieve with it, and I would love to be able to use it without fear that it might change or stop existing in the future.</p>
]]></content>
</entry><entry>
    <title>Software engineering book recommendations</title>
    <link href="https://swiftrocks.com/software-engineering-book-recommendations" rel="alternate" type="text/html" title="Software engineering book recommendations"/>
    <published>2024-03-03T14:00:00+02:00</published>
    <updated>2025-05-26T18:00:00+02:00</updated>
    <id>https://swiftrocks.com/software-engineering-book-recommendations</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Bruno's personal list of recommended books about software engineering and iOS development.</summary>
    <content type="text/html"><![CDATA[
<p>The following is a list of software engineering books I've read that I felt had a strong and lasting positive impact on my career. It's not a list of <i>everything</i> I enjoyed (that would be impossible to list down), but rather a special list of resources that taught/helped me so much that I still find myself thinking about them years later. They are my top recommendations for other software engineers.</p>
<p>Some are about iOS development specifically, but most relate to general software engineering. If you strive to be a world-class developer, these books and resources will help you get there.</p>
<ul>
<li><b><a href="https://nostarch.com/writegreatcode1_2e">Write Great Code: Understanding The Machine (Randall Hyde)</a></b> - Probably my favorite software engineering book. This book teaches you how modern computers work in a high-level way that is easy to understand and not overly technical. It's not going to teach you new fancy APIs, but it will give you the ability to “understand” code; an ability that has proved to be useful almost daily in my career.</li>
<li><b><a href="https://pages.cs.wisc.edu/~remzi/OSTEP/">Operating Systems: Three Easy Pieces (Remzi Arpaci-Dusseau, Andrea Arpaci-Dusseau)</a></b> - This is similar to Understanding The Machine, but is more technical and focused on operating systems specifically. Amazing resource to learn about core OS fundamentals such as memory, threads / concurrency, file systems, and CPU virtualization. <b>It's also free.</b></li>
<li><b><a href="https://mwl.io/nonfiction/networking#n4sa">Networking for Systems Administrators (Michael W Lucas)</a></b> - Having some basic knowledge of how the modern internet works is really handy regardless of your field of expertise. There are many resources out there that teach will you networking, but they also assume that you work professionally with it, so they spend too much time explaining implementation details that I didn't care about. I have then always been searching for a book that could teach me how networking works at a <i>basic level</i>, without wasting time on those deeper details, and this book was able to fit that criteria <i>perfectly.</i> Word of caution: <a href="https://x.com/rockbruno_/status/1909286974118412735">If you're anything like me, you're going to go down the Homelab rabbit hole after reading this book!</a></li>
<li><b><a href="https://newosxbook.com/home.html">*OS Internals Trilogy (Jonathan Levin)</a></b> - This trilogy about how Apple platforms work internally is an <b>absolute gold mine</b> for us who develop for said platforms, but it's not for everyone. They will teach you everything you could possibly want to know about these platforms, but they're massive and go into extreme detail on things that you're never going to interact with, making this series a very painful read for beginners and those looking for quick / practical knowledge. But if you're reasonably experienced and is interested in things like linkers and kernels, then these books are a godsend. The only problem with these books is that Amazon only delivers them if you live in the US, so getting a copy can be challenging.</li>
<li><b><a href="https://taomm.org/">The Art Of Mac Malware, Volume 1 (Patrick Wardle)</a></b> - A really interesting overview of the different tricks that malware authors have used to infect macOS machines in recent years, as well as a great introduction to disassemblers and advanced debugging techniques. Amazing if you'd like to get better at reverse engineering / debugging and expand your knowledge of how macOS works under the hood. There is also a second volume, but I haven't read that yet.</li>
<li><b><a href="https://fabiensanglard.net/gebbdoom/index.html">Game Engine Black Book: DOOM (Fabien Sanglard)</a></b> - Fantastic deep-dive on not only the source code, but also the hardware, tooling, and team dynamics that allowed the masterpiece known as DOOM to be conceived. iOS developers will find this book extra interesting because DOOM was developed on NeXT workstations; many of the tools were written in Objective-C, so the book has a lot of interesting information about the language and frameworks like Foundation that is still relevant to this day.</li>
<li><b><a href="https://www.crackingthecodinginterview.com/">Cracking the Coding Interview (Gayle Laakmann McDowell)</a></b> - Even if you don’t care about the interviewing bits (I’m not even sure if companies like Apple still run LeetCode puzzles), this book is still a legendary resource for getting started with computer science theory. If you’re not sure why you’d want to do that, <a href="https://swiftrocks.com/how-necessary-are-the-programming-fundamentals">check out my article about it.</a></li>
<li><b><a href="https://www.amazon.se/-/en/Tanya-Reilly/dp/1098118731">The Staff Engineer's Path (Tanya Reilly)</a></b> - Perfect book for senior engineers looking to get to the next level. This book demystifies the concept of a Staff Engineer and provides a gigantic amount of great advice on how to get there and how to do a good job once you’re there.</li>
<li><b><a href="https://www.amazon.com/Effective-Objective-C-2-0-Specific-Development/dp/0321917014">Effective Objective-C 2.0 (Matt Galloway)</a></b> - Even though we don’t directly write apps in Obj-C anymore, we still have to do so indirectly when using older frameworks like UIKit. This book does a great job of explaining how Obj-C works, which is something you’ll wish you knew when dealing with issues that either originate or pass through Obj-C.</li>
<li><b><a href="https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882">Clean Code (Robert C. Martin)</a></b> - This book gets a lot of flack in the community because some people treat it as some sort of bible that must be followed religiously, but it is nonetheless a great resource for learning how to write code that is easy to read and maintain by humans. <a href="https://swiftrocks.com/there-is-no-right-or-wrong-in-software-engineering">Just don't be like those folks.</a></li>
<li><b><a href="https://www.amazon.com/Hacking-Art-Exploitation-Jon-Erickson/dp/1593271441">Hacking: The Art of Exploitation (Jon Erickson)</a></b> - I didn't actually like the first half of this book as the author spends far too long explaining C / Assembly and C exploits that are probably largely irrelevant nowadays, but the reason I'm adding it to the list is because of the second half which does a pretty good job at explaining <b>how networks work</b>, including some network-based exploitation techniques which I believe are still relevant to this day. This led me to a rabbit hole of wanting to know more about how to reverse engineer online-based apps and games, and thus I'm very grateful for this book even though I wasn't a fan of the first half. I feel then that this book in addition to the previous networking book recommendation gave a pretty solid foundation on networking.</li>
</ul>
<h2>Other Resources</h2>
<p>The following are not “books” in the traditional sense, but are nonetheless great software engineering resources that I think should be present here.</p>
<ul>
<li><b><a href="https://github.com/donnemartin/system-design-primer">System Design Primer</a></b> - A collection of resources for learning how to design scalable backends. Great resource for learning how giant products like Twitter work. For mobile developers, this knowledge can help you make sure the client-side bits are designed properly.</li>
<li><b><a href="https://www.nand2tetris.org/">Nand2Tetris</a></b> - A free online course that teaches you how to build a modern computer and make it run Tetris, from scratch. Another amazing resource for learning how computers work.</li>
<li><b><a href="https://highaltitudehacks.com/2013/06/16/ios-application-security-part-1-setting-up-a-mobile-pentesting-platform.html">Prateek Gianchandani’s articles about iOS security, and DVIA</a></b> - This giant series of 50 articles teaches you how to hack iOS apps and is how I learned everything I know about iOS security. It’s quite old so I’m not sure how much of it still applies, but is an interesting read regardless. Prateek also has a project called <a href="https://github.com/prateek147/DVIA-v2">Damn Vulnerable iOS App (DVIA)</a> that is basically a playground where you can try out everything he mentions in his articles, but unfortunately it seems that the website that explained it doesn’t exist anymore. <a href="https://web.archive.org/web/20220331031231/https://damnvulnerableiosapp.com/">I was able to find it in the Internet Archive</a>, so hopefully that still allows you to try it.</li>
<li><b><a href="https://learngitbranching.js.org/">Learn Git Branching</a></b> - A page that teaches you to use git in the CLI by presenting it as a browser game. This is how I learned how to use git and is a resource that I greatly recommend even if you prefer using GUI apps for your git needs.</li>
<li><b><a href="https://ocw.mit.edu/">MIT OpenCourseWare</a></b> - MIT has a lot of free content on YouTube, and the ones related to software engineering are amazing. <a href="https://www.youtube.com/watch?v=q1OF_0ICt9A&t=3794s">Here’s a link to my favorite one, which is a class about HTTPS/SSL/modern cryptography.</a>
</ul>
]]></content>
</entry><entry>
    <title>What the hell are passkeys? (Runway)</title>
    <link href="https://www.runway.team/blog/an-introduction-to-passkeys" rel="alternate" type="text/html" title="What the hell are passkeys? (Runway)"/>
    <published>2024-02-22T14:00:00+02:00</published>
    <updated>2024-02-22T14:00:00+02:00</updated>
    <id>https://www.runway.team/blog/an-introduction-to-passkeys</id>
    <author>
        <name>Bruno Rocha</name>
    </author>
    <summary>Lots of companies are adding support for "passkeys". I wasn't sure what I was looking at, so I decided to look into it!</summary>
    <content type="text/html"><![CDATA[
<p><b>Passkeys</b> are an alternative to passwords that allow you to sign in to any website or app that supports this technology <b>without needing to define/remember a password.</b></p>
<p>Over the last couple of years, the tech world has been witnessing many companies updating their products to add support to this new technology, including tech giants like Apple, who introduced several APIs and device features related to passkeys <a href="https://support.apple.com/en-gb/guide/iphone/iphf538ea8d0/ios">in iOS 16</a>, and Google, who has been pushing passkeys hard since announcing passkeys support for Chrome and Gmail <a href="https://blog.google/technology/safety-security/one-step-closer-to-a-passwordless-future/">back in 2022.</a></p>
<p>When I first saw Apple and Google’s announcements, I wasn't sure what I was looking at. The fact that the tech industry has been trying to move away from old-school passwords wasn't news to me, but I asked myself: didn't we already solve this problem when products started allowing users to register a "secondary" authentication requirement, such as receiving an SMS containing a PIN code?</p>
<p>I then decided to look deeper into this topic, and was so pleasantly surprised by what I found that I thought it would be cool to share it with you. In this article, we'll take a look at what passkeys are, why companies like Apple and Google are adding support for them, how they work under the hood, and whether or not you should convert your own accounts to use them and build support for them in your mobile apps!</p>
]]></content>
</entry></feed>