<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Babak Arjmandnia on Medium]]></title>
        <description><![CDATA[Stories by Babak Arjmandnia on Medium]]></description>
        <link>https://medium.com/@babaknia?source=rss-3f20cc1680e8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*7Ry7-bu0tflr_Hb5voi-Tw.jpeg</url>
            <title>Stories by Babak Arjmandnia on Medium</title>
            <link>https://medium.com/@babaknia?source=rss-3f20cc1680e8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 00:16:38 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@babaknia/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Who is really your client?]]></title>
            <link>https://medium.com/@babaknia/who-is-really-your-client-e218dbc7653c?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/e218dbc7653c</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[customer-success]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 17:13:51 GMT</pubDate>
            <atom:updated>2026-11-13T19:36:35.211Z</atom:updated>
            <content:encoded><![CDATA[<p>Have you ever watched the C-levels fall in love with your demo, only to see a competitor walk away with the contract a year later? Have you ever wondered who you were really selling to?</p><p>I’ve been in many customer-facing meetings. I’ve sold and demoed software products to new clients, extended contracts with existing ones and sat in the middle of incidents when things went wrong. Now, looking back, I keep asking myself: who was really my client in those meetings? It’s not simply the company that pays you. Inside every organization, there are (at least) two kinds of clients and you have to serve both.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KOH4X3aCXqoD7Nhp" /><figcaption>Photo by <a href="https://unsplash.com/@sunday_digital?utm_source=medium&amp;utm_medium=referral">Nastuh Abootalebi</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Your client when selling</h3><h4>The one who signs the check</h4><p>C-levels and high-level managers approve the deal and sign the check for you. That is very important. With them, keep it high-level. Shiny demos, futuristic designs and, yes, buzzwords are totally fine: agentic AI, quantum computing, blockchain, cloud-native, self-healing and many more. They care about the big picture and the strategy more than the details of each feature.</p><h4>The one who actually uses it</h4><p>Years ago, we received a list of about 30 features from one of the biggest clients in our country. Every feature meant a big change to our product. The contract was worth a huge amount of money and the deal was clear: no payment until every feature was delivered. We had about three months. The pressure came from everywhere: senior management, sales and marketing, finance. People even started keeping an eye on when we arrived at the office and when we left. We told them many of those features made no sense, but with that much pressure, nobody cared to listen. So we built them anyway. In the end, the team delivered everything two weeks ahead of schedule.</p><p>When it was time to install, I joined the installation team at the client’s office. I was proud of what we had done. I went to the manager of the operators (about 5,000 people all over the country who would actually use the product every day) and happily told her we had finally shipped all the features they had asked for. She looked surprised. “What features? We never asked for any!”</p><p>It turned out the list had come from a consultant who never really talked to the operators. On our side, under pressure to close the deal, nobody had checked either. So I sat down with her and asked a simple question: “What problems do you actually have?” Instead of 30 items, she gave me <em>two</em>. One developer could have built both in a week. Instead, a team of ten had spent almost three months under heavy pressure.</p><p>When we delivered those two things, she was extremely happy because they saved her team a lot of time. Back at the office, I was angry, and I didn’t hide it. I asked our management to consult us and trust their own team before signing anything. If anyone had taken the time to understand the people who actually use the product, we could have avoided all of it and everyone would have been happy.</p><p>That’s the second kind of client: the people who really use your application every day, like operators, analysts and support staff. Vendors usually try to keep them happy with parties and gifts like t-shirts and pens. That’s nice, but it’s not what they’re really interested in. These people are thirsty for knowledge. They want to know how they can improve themselves in their position.</p><p>So educate them. Give them understandable, detailed documentation and real training sessions. Sit beside them from time to time and watch how they really use your product. Sometimes moving a button here and there or removing one step from a flow makes the whole product easier. Help them gain enough knowledge to tackle their problems by themselves. Always leave a way for them to contact you, share ideas and tell you what’s not working. Be kind and respectful. And during the contract, go and visit them.</p><h3>Your client during an incident</h3><p>Every product has incidents: errors, failures, something that just doesn’t work. Sometimes it’s not even a bug. The user made a mistake or did something nobody expected. (I shared more of what outages taught me in my other post: <a href="https://medium.com/@babaknia/lessons-from-outages-f5a124e24f0f">Lessons from outages</a>). Here, again, you have two kinds of clients.</p><h4>The angry client</h4><p>When a client is angry, be respectful and help them as soon as possible. Pick up the ticket no matter what its priority says. If your client is angry, it is urgent.</p><p>Please don’t invent fancy titles like Incident Manager, Incident Captain, or, who knows, Chief Fire Officer. These are useless positions. They don’t fix anything. They schedule a meeting about the fire while the house is still burning. All they really add is one more layer between you and your client. Mind <a href="https://en.wikipedia.org/wiki/Conway%27s_law">Conway’s Law</a>: organizations ship products that mirror their own communication structures. If your organization is complex and layered, your clients will feel every one of those layers, especially during an incident. Rethink your structure and don’t let the complexity of your organization hurt your clients and end users. An angry client doesn’t care how many divisions you have. They just want their issue solved.</p><h4>The happy client</h4><p>Some clients stay happy even when something is broken and they’re willing to help. Use this as a window into your client’s world. Sit beside them and review, step by step, what happened and how they use the product.</p><p>Whichever kind of client you have, don’t just call the developer who built the feature and let everyone else read the root cause analysis afterwards. A document at the end is not involvement. Product and support should be there at every step: in the meetings, while the investigation happens and when the changes are decided and made. They need to see what’s happening as it happens, not get a summary a week later. Only then does everyone really understand what went wrong.</p><p>Then educate your support team so they can handle a similar issue by themselves next time. Create checklists and update your documentation. Tell the users exactly what happened, so they don’t make the same mistake again. None of this works if your team is afraid to say what’s actually broken (have a look at my other post: <a href="https://medium.com/@babaknia/psychological-safety-vs-standards-fe82e85ae592">Psychological Safety vs. Standards</a>).</p><p>And do follow-ups. Once the incident is closed, nobody will answer. Push anyway and find out how they use your system.</p><h3>Nobody is irreplaceable</h3><p>The C-levels sign the check but the end users are almost everyone who actually uses your product and most organizations don’t care about them. I’ve witnessed companies so confident that their product was stuck in a client’s organization that nobody could ever remove it. They were wrong. Your competitor is always there, ready to do for your client what you didn’t. They can easily migrate your data to their own database, remove your product and nobody signs your check next year.</p><p>Make sure your users are happy, well-educated and able to reach you whenever they need to. Then even your competitor can’t remove you. So next time you walk into a meeting, ask yourself: <em>who is really your client?</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e218dbc7653c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[UUID v4, v7 or v5?]]></title>
            <link>https://medium.com/@babaknia/uuid-v4-v7-or-v5-c818c2537cdb?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/c818c2537cdb</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[system-design-concepts]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Fri, 06 Nov 2026 19:30:26 GMT</pubDate>
            <atom:updated>2026-11-06T19:49:08.079Z</atom:updated>
            <content:encoded><![CDATA[<p>In <a href="https://medium.com/@babaknia/replay-the-world-5e094cb906a1">Replay the world</a>, I warned that a 4-byte key runs out faster than free snacks in the office. The usual next step is a 64-bit auto-increment. Sooner or later, someone in a design meeting says “let’s just use UUIDs.” Fair enough. But which one? How does a machine make them without asking anyone? And how unique is “unique”, really?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*umML_YXHCGRjsYMq" /><figcaption>Photo by <a href="https://unsplash.com/@rocinante_11?utm_source=medium&amp;utm_medium=referral">Mick Haupt</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>What is a UUID?</h3><p>A UUID (Universally Unique IDentifier) is a 128-bit number. That’s it. Microsoft calls it a GUID (Globally Unique IDentifier), but it is the same thing (one catch: Windows stores the first three groups byte-swapped in binary form, so be careful when moving raw bytes between systems). We usually write it as 32 hexadecimal digits in five groups (8–4–4–4–12), so 36 characters with the hyphens.</p><p>The format was first standardized in RFC 4122 back in 2005. In May 2024, <a href="https://rfc-editor.org/rfc/rfc9562.html">RFC 9562</a> replaced it and added three new versions, including the one everybody is talking about these days: version 7.</p><p>The beauty of a UUID is that there is no central authority. Any machine, any process, even a phone in airplane mode, can create one without a database round-trip or a coordination service and still be (almost) sure nobody else has it.</p><p>Not all 128 bits are free, though. Two small fields tell you what kind of UUID you are looking at:</p><pre>f47ac10b-58cc-4372-a567-0e02b2c3d479<br>              ^    ^<br>              |    └─ variant: 8, 9, a or b<br>              └─ version: 4</pre><p>The first digit of the third group is the version. The first digit of the fourth group holds the variant (<em>8</em>, <em>9</em>, <em>a</em> or <em>b</em> for the standard one). Next time you see a UUID in a log, you can tell its version at a glance.</p><p>Why four options for the variant? The variant tells you which family of layouts the UUID follows and the version only means something inside the standard family. The standard variant is just the first two bits of that digit, always 10. The other two bits belong to the data, so the digit ends up as <em>8</em> (1000), <em>9</em> (1001), <em>a</em> (1010) or <em>b</em> (1011). The remaining values are reserved: <em>0</em>–<em>7</em> for the 1980s Apollo NCS format, <em>c</em>–<em>d</em> for old Microsoft GUIDs and <em>e</em>–<em>f</em> for the future. In practice, you will only ever see <em>8</em>, <em>9</em>, <em>a</em> or <em>b</em>.</p><h3>The family</h3><p>RFC 9562 lists eight versions. You will meet three or four of them in real life.</p><ol><li><strong>v1</strong> (Gregorian timestamp + clock sequence + a node ID, traditionally the MAC address. The original one)</li><li><strong>v2</strong> (Defined outside the RFC and you will hardly ever see one)</li><li><strong>v3</strong> (MD5 hash of a namespace and a name. Same input, same UUID)</li><li><strong>v4</strong> (122 random bits. The default almost everywhere)</li><li><strong>v5</strong> (like v3, but with SHA-1)</li><li><strong>v6</strong> (v1 with its timestamp bits reordered so it sorts properly)</li><li><strong>v7</strong> (Unix time in milliseconds + random bits. Sortable and the new favorite)</li><li><strong>v8</strong> (a free-form layout for vendor-specific or experimental formats)</li></ol><p>There are also two special values: the <em>Nil UUID</em> (all zeros) and the <em>Max UUID</em> (all 128 bits set to 1).</p><h3>How does a machine make one?</h3><p>There is no magic. Each version is just a recipe for filling 128 bits.</p><h4>v4 — roll the dice</h4><p>The machine asks a cryptographically strong random number generator for 16 bytes and then overwrites 6 bits with the version and the variant. The remaining 122 bits are pure randomness. That is more or less what UUID.randomUUID() does under the hood:</p><pre>SecureRandom rng = new SecureRandom();<br>byte[] b = new byte[16];<br>rng.nextBytes(b);<br>b[6] = (byte) ((b[6] &amp; 0x0F) | 0x40); // version 4<br>b[8] = (byte) ((b[8] &amp; 0x3F) | 0x80); // variant 10<br>// …pack the bytes into two longs: new UUID(msb, lsb)</pre><h4>v7 — a clock plus dice</h4><p>The first 48 bits hold the Unix time in milliseconds. The rest (minus the version and variant) are random:</p><pre>| unix_ts_ms (48) | ver (4) | rand_a (12) | var (2) | rand_b (62) |</pre><p>Because the timestamp sits at the front, v7 UUIDs sort by creation time. Java 26 finally added a factory method for it:</p><pre>// Java 26+<br>UUID id = UUID.ofEpochMillis(System.currentTimeMillis());</pre><p>On older Java versions, it is only a few lines:</p><pre>private static final SecureRandom RNG = new SecureRandom();<br>static UUID uuidV7() {<br> long ts = System.currentTimeMillis();<br> long msb = (ts &lt;&lt; 16) // 48-bit Unix timestamp (ms)<br>           | 0x7000L // version 7<br>           | (RNG.nextInt() &amp; 0x0FFFL); // rand_a: 12 random bits<br> long lsb = (RNG.nextLong() &gt;&gt;&gt; 2) // rand_b: 62 random bits<br>           | 0x8000000000000000L; // variant 10<br>  return new UUID(msb, lsb);<br>}</pre><p>Note that both the Java 26 method and the hand-rolled version only sort by the millisecond. Two IDs created in the same millisecond can come out in any order. The <a href="https://docs.oracle.com/en/java/javase/26/docs/api/java.base/java/util/UUID.html">JDK documentation</a> says it plainly: if you want monotonic values, the timestamps you pass in must be monotonic. RFC 9562 offers three fixes: use rand_a as a counter, increment the random part, or spend those 12 bits on sub-millisecond precision. <a href="https://thenile.dev/blog/uuidv7">PostgreSQL 18&#39;s</a> new uuidv7() function takes the last route, which keeps values from the same session in order, even if the clock jumps back.</p><h4>v3 and v5 — a hash</h4><p>Name-based UUIDs hash a namespace plus a name. Feed the same input and you get the same UUID on any machine, on any day. The JDK only ships v3 (MD5):</p><pre>UUID id = <br>  UUID.nameUUIDFromBytes(&quot;hi@example.com&quot;.getBytes(StandardCharsets.UTF_8));<br>// always a8277e7e-83ab-310c-bf8b-c249809293ca</pre><p>Keep in mind that nameUUIDFromBytes does not add a namespace for you. There is no JDK method for v5 (SHA-1), but it is only a few lines with MessageDigest:</p><pre>static UUID uuidV5(UUID namespace, String name) throws NoSuchAlgorithmException {<br> MessageDigest sha1 = MessageDigest.getInstance(&quot;SHA-1&quot;);<br> sha1.update(ByteBuffer.allocate(16)<br>       .putLong(namespace.getMostSignificantBits())<br>       .putLong(namespace.getLeastSignificantBits())<br>       .array());<br> byte[] h = sha1.digest(name.getBytes(StandardCharsets.UTF_8));<br> h[6] = (byte) ((h[6] &amp; 0x0F) | 0x50); // version 5<br> h[8] = (byte) ((h[8] &amp; 0x3F) | 0x80); // variant 10<br> ByteBuffer bb = ByteBuffer.wrap(h, 0, 16); // keep the first 128 of 160 bits<br> return new UUID(bb.getLong(), bb.getLong());<br>}<br><br>UUID dns = UUID.fromString(&quot;6ba7b810–9dad-11d1–80b4–00c04fd430c8&quot;); // DNS namespace, predefined in RFC 9562<br>UUID id = uuidV5(dns, &quot;www.example.com&quot;);<br>// always 2ed6657d-e927–568b-95e1–2665a8aea6a2</pre><h4>v1 — a clock plus your network card</h4><p>v1 combines a 60-bit timestamp (100-nanosecond ticks since 15 October 1582, the start of the Gregorian calendar), a 14-bit clock sequence and a 48-bit node ID, traditionally the machine’s MAC address. It is unique by design as long as clocks and node IDs behave, but it tells everyone when and on which machine it was made. RFC 9562 now recommends against MAC addresses and suggests a random node ID instead.</p><h3>Which one should we use?</h3><h4>v7 — database primary keys</h4><p>Random v4 keys land at random places in a B-tree index, so every insert touches a different page. The index bloats and your cache suffers. v7 keys arrive roughly in time order, so new rows land near the end of the index, much like an auto-increment, but without a central counter. “Roughly”, because IDs from the same millisecond or from machines whose clocks drift apart can swap places. For index locality, that is good enough. As a bonus, you get a free “created at” when you are digging through logs.</p><p>Here are three v7 IDs, created moments apart:</p><pre>01a1b207–38bf-7c09–91ca-ff5743210146 2026–11–06 18:03:00.159 UTC<br>01a1b207–38d7–7f18–9538–1f482ab7c9bb 2026–11–06 18:03:00.183 UTC<br>01a1b207–38dc-736a-b83a-4d7236e84da6 2026–11–06 18:03:00.188 UTC</pre><p>The first 12 hex digits are the timestamp, so they share a prefix and only its tail grows (38bf → 38d7 → 38dc). Even sorted as plain strings, they are already in creation order, so each new key lands right next to the previous one in the index.</p><h4>v4 — when the ID should reveal nothing</h4><p>Anyone who sees a v7 can tell when the record was created. For public IDs in URLs (user profiles, invoice links), you may not want to leak that or how fast you are growing. v4 is also the simplest default when ordering does not matter.</p><h4>v5 — when the same input must produce the same ID</h4><p>Idempotent imports, deduplicating events from an external system or deriving a stable ID from a URL in two services that never talk to each other. Prefer v5 over v3.</p><p>Why not just store a SHA-1 hash of the input? Because v5 already is one, cut down to 128 bits and stamped with a version, so it fits any UUID column right next to your v4 and v7 keys (a raw SHA-1 is 160 bits). The namespace keeps the same name in different contexts apart, so order “42” and user “42” never share an ID. And it is a standard: any UUID library, in any language, turns the same namespace and name into the same UUID, as long as everyone encodes the name the same way (typically UTF-8). Just keep in mind that v5 is for naming, not security: SHA-1 is broken for collision resistance and anyone who knows the name can compute the ID.</p><h4>v1 and v6 — legacy only</h4><p>RFC 9562 itself says to use v7 instead of them if possible.</p><h4>v8 — your own layout</h4><p>For when you need to embed something specific (a shard or region ID, for example) and still want a value that fits in any UUID column.</p><p>One rule applies to all of them: a UUID is an identifier, not a secret. The RFC is explicit that UUIDs must not be used as security capabilities, where simply holding the ID grants access. Don’t use one as a password reset token or an API key. And an unguessable ID in a URL is no replacement for checking that the caller is allowed to see that record.</p><h3>What are the odds of a collision?</h3><p>Remember the birthday paradox? Put 23 people in a room and there is a 50% chance that two of them share a birthday. UUIDs follow the same math, just with a much bigger calendar.</p><h4>v4, anywhere in the world</h4><p>122 random bits give about 5.3 × 10³⁶ possible values. To reach a 50% chance of even one duplicate, you need around 2.7 × 10¹⁸ UUIDs. That is one billion UUIDs per second for about 86 years. Generate 103 trillion of them and the chance of a single duplicate is still about one in a billion.</p><h4>v7</h4><p>Only 74 bits are random, but they only have to differ from the IDs created in the same millisecond. Here is how the two compare for one table running for a full year, assuming the IDs are spread evenly over time (bursts raise the odds):</p><ul><li>1 million v4 IDs per second: about 1 in 10 billion chance of a single collision</li><li>1 million purely random v7 IDs per second: about 1 in 1.2 million</li><li>10 million purely random v7 IDs per second: about 1 in 12,000</li></ul><p>So v7 is less collision-resistant than v4, but at the rates most of us deal with, it is still nothing to lose sleep over. A monotonic generator (a counter or extra clock precision, like PostgreSQL’s) makes duplicates from the same generator practically impossible.</p><h4>On the same machine</h4><p>For v4, the formula does not care where the UUID was made. The risk is in the dice, not the math. Real-world duplicates come from broken randomness: a VM restored from a snapshot or a cloned container replaying the same random state or someone “optimizing” with java.util.Random instead of SecureRandom. java.util.Random has only a 48-bit seed, so your 122 “random” bits suddenly have at most 2⁴⁸ starting points. For v7, also watch the clock. If NTP moves it backwards, a careless generator can reuse timestamps.</p><h4>In the whole world</h4><p>Honestly, it doesn’t matter. A duplicate only hurts when both IDs meet in the same table, topic or cache, today or after a future migration merges two datasets. Your UUID colliding with one in a bank in Singapore hurts nobody. The question that matters is the probability within your system and the numbers above answer that.</p><p>Still, keep a unique constraint on the column (a primary key already is one). Then a one-in-a-billion event becomes an exception you can retry, not silently corrupted data.</p><p>Keep in mind that UUID or plain number as a table’s primary key is a long-running debate, with good arguments on both sides. A 64-bit integer is half the size and easy to read in a log. A UUID can be created anywhere, before the row ever reaches the database, and doesn’t reveal how many rows you have. So decide wisely, based on your system rather than on fashion.</p><p>If you go with UUIDs, reach for v7 for new tables. For anything public that shouldn’t reveal its age, v4. For anything that must be reproducible, v5. Whatever you pick, let the database enforce uniqueness instead of blindly trusting the math.</p><p><em>Bonus point</em>: store UUIDs as 16 bytes (PostgreSQL’s uuid type or BINARY(16) in MySQL), not as a 36-character string. Otherwise, you pay more than double for every key and every index that points to it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c818c2537cdb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Know C# and JavaScript? You’re Already a Mobile Developer]]></title>
            <link>https://medium.com/@babaknia/know-c-and-javascript-youre-already-a-mobile-developer-61c81bb5d95a?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/61c81bb5d95a</guid>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 18:23:29 GMT</pubDate>
            <atom:updated>2026-10-28T18:23:29.688Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lgqKwH-AbXujMZle" /><figcaption>Photo by <a href="https://unsplash.com/@halacious?utm_source=medium&amp;utm_medium=referral">Hal Gatewood</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Have you ever tried to help your child with Dutch dictation when your own Dutch isn&#39;t perfect? I have. For almost a year now, I’ve been working on a mobile app on and off because of it. It wasn’t a side project or a business idea. It started at my kitchen table.</p><p>My child needed to practice Dutch dictation. As parents, we wanted to help, but to be honest, our own Dutch wasn’t good at all. The last thing we wanted was for him to practice with our accent and pick up our mistakes. It was important to me that he heard every word with correct, native Dutch pronunciation. I also wanted him to practice as much as he liked, whenever he liked, without depending on us.</p><p>So I built an app. I already knew web development, JavaScript, CSS and especially C#, so the choice was easy: .NET MAUI with Blazor Hybrid.</p><h4><strong>What are .NET MAUI and Blazor Hybrid?</strong></h4><p><a href="https://learn.microsoft.com/en-us/dotnet/maui/what-is-maui">.NET MAUI</a> (Multi-platform App UI) is Microsoft’s framework for building native apps for Android, iOS, Windows and macOS from a single codebase. Blazor Hybrid lets you build the UI of those apps with Razor components (HTML, CSS and C#). The UI is rendered inside a native WebView, while your C# code runs directly on the device with full access to .NET and platform APIs.</p><p>In short, you build it like a web app, but it’s packaged, installed and run like a native mobile app.</p><h4>Why Blazor and not XAML?</h4><p>The default way to build a UI in .NET MAUI is XAML, an XML-based markup language. I tried it first. It didn’t take long before I was lost. I couldn’t figure out how to use it properly or how its components connect and work together. That XML syntax never felt natural to me.</p><p>HTML, CSS and JavaScript, on the other hand, were old friends. With Blazor, I could use them from day one and see results quickly, instead of learning a new UI language first. JavaScript still has its place, too. In a few spots, I used Blazor’s JS interop to add visual effects and animations to the UI by calling small JavaScript functions from my C# code.</p><h4>Why it felt so easy</h4><p>The core of the dictation app came together surprisingly fast. A few reasons:</p><ul><li><strong>Dependency injection out of the box.</strong> Text-to-speech, storage, settings: each one is a service, registered in .NET’s built-in DI container and injected wherever it’s needed. A new feature usually means writing a new service, registering it and using it in a component.</li><li><strong>Testable code.</strong> The logic lives in plain C# services, so unit testing works like in any other .NET project (more on this below).</li><li><strong>The whole .NET ecosystem.</strong> NuGet packages, familiar tooling and Visual Studio, all available from day one.</li><li><strong>Code sharing.</strong> The same Razor components can be reused in a Blazor web app, so mobile, desktop and web can share a lot of code.</li><li><strong>Works offline.</strong> Everything runs on the device. No server needed.</li></ul><h4>The hard part: making it look good</h4><p>The app worked. It didn’t look good, though, and I have to be honest about that. Writing the logic was the easy part. Making the UI and UX polished and pleasant was a different story. For a long time, my app was like a car with a great engine and a cardboard body. That was just simply because I’m not the UI guy.</p><figure><img alt="The before and after screenshots of the Spell Monster app." src="https://cdn-images-1.medium.com/max/559/1*Wd7e3kfR5MQJheUiWWOUEg.png" /></figure><h4>Where AI tools actually helped</h4><p>About six months ago, I started using Claude and GitHub Copilot for the UI. As someone who is usually skeptical of these tools, I was genuinely surprised. Layouts, colors, spacing, small interactions: things that used to cost me hours of trial and error came together quickly. Finally, the app looked as good as it worked. That turned out to be the winning combination for me: a framework that uses the skills I already have, plus tools that fill the gaps where I’m weaker.</p><figure><img alt="The before and after screenshots of the Spell Monster app." src="https://cdn-images-1.medium.com/max/559/1*lrccKi4V_QuRENigPO6_2g.png" /></figure><h4>From one app to many</h4><p>That experience gave me confidence and I started building the apps I’d always wanted:</p><ul><li><strong>A language-learning app</strong> for Dutch, designed around the way <em>I</em> learn best</li><li><strong>A micro-habit tracker</strong></li><li><strong>A journaling app</strong></li><li><strong>MVPs for three other ideas</strong>, to quickly test whether they’re worth pursuing</li></ul><p>Most of these already exist as commercial apps, usually with a monthly subscription or a one-time price. More importantly, nobody really knows what happens to the personal data you put into them. With my own versions, my data stays with me and I pay nothing (except, of course, for my time and some tokens).</p><h4>Lessons learned working with AI tools</h4><p>These come purely from my own experience. The tools change every month, so some of these points may not age well.</p><ul><li><strong>Define the architecture yourself, first.</strong> Before asking for help, decide how files are organized, how services are structured, how tests are written and how the projects connect. Write it down and insist that the AI follows it.</li><li><strong>Watch out for unnecessary dependencies.</strong> AI tools sometimes add libraries or NuGet packages that aren’t needed at all and make the project far more complicated than it should be. (I wrote more about this in my other post: <a href="https://medium.com/@babaknia/a-weekend-and-a-startups-missing-milliseconds-a907193eadf1">A weekend and a startup’s missing milliseconds</a>.)</li><li><strong>Watch out for duplicated code and styles.</strong> With Blazor, AI assistants tend to repeat themselves. A CSS change on one page gets copied into other pages instead of being defined once and reused. Push for shared styles and components early. Otherwise, one small change later means editing many places.</li><li><strong>Work iteratively and review every change.</strong> Move in small steps, task by task. Check what changed and why. If something doesn’t make sense, ask for it to be redone. Stay involved at every step. These tools can make your code so complex, so quickly, that you no longer know what lives where.</li><li><strong>Separate the logic from the UI.</strong> Keep as much logic as possible out of the UI. Unit testing becomes much easier and meaningful tests protect your core logic as the app grows. You can even ask the AI assistant to test the app for you. I was surprised to see it launch the app and take screenshots to check whether a style or a piece of logic works the way I intended.</li><li><strong>Ask for an onboarding document.</strong> Ask the AI to write a guide for a new developer joining the project and keep it updated as the project grows. If you ever get lost or lose access to these tools, you can still understand and continue the work yourself.</li><li><strong>Don’t count on the official skills, at least for now.</strong> Microsoft offers recommended skills for .NET and MAUI that you can add to AI coding assistants. I tried them and they didn’t help me at all. They may improve but interest in those skills and their development, seems to be fading.</li></ul><p>Above all, never take their output at face value. Review it, test it and double-check it. (See also: <a href="https://medium.com/@babaknia/should-we-trust-llms-015e632f6f06">Should we trust LLMs?</a>)</p><h4>The challenges you should know about</h4><p>It’s not all sunshine (but then again, neither is the Dutch weather). A few things to be aware of when developing an app with MAUI .Net:</p><ul><li><strong>Native features can be tricky.</strong> When you need deep access to platform-specific features, things get harder and you may need to write platform-specific code.</li><li><strong>Startup time.</strong> Apps can be noticeably slow to start, especially on Android.</li><li><strong>App size.</strong> Apps tend to be larger than fully native ones.</li><li><strong>WebView limitations.</strong> The UI runs inside a WebView, so it doesn’t always feel exactly native and heavy animations can struggle. From time to time, you’ll also notice small hiccups in the UI, like a brief stutter or delay. In my case, that was rare.</li><li><strong>Debugging on real devices</strong> can be frustrating. Hot reload in particular doesn’t always work reliably, so you may restart the app more often than you’d like.</li><li><strong>A smaller community</strong> than some other cross-platform frameworks, which means fewer ready-made answers and packages.</li></ul><h4>A note on iOS and Android</h4><p>If you only have a Windows machine, keep in mind that building and debugging for iOS requires access to a Mac. Plan for that before you commit to iOS.</p><p>Android on Windows, on the other hand, is a pleasure to work with. Wireless debugging lets you deploy and debug without plugging your phone into your computer. You can also test on several devices at the same time, which makes checking different screens and Android versions much faster.</p><h4>When should you use it?</h4><p><strong>A great fit when:</strong></p><ul><li>You or your team already know .NET and web technologies</li><li>You want to build an MVP quickly</li><li>You’re building internal, business or data-driven apps with forms, lists and dashboards</li><li>You already have a Blazor web app and want mobile and desktop versions</li><li>You’re building personal tools where privacy and control matter</li></ul><p><strong>Look elsewhere when:</strong></p><ul><li>You’re building games or graphics-heavy apps</li><li>Your app depends heavily on advanced native features</li><li>Startup speed and app size are critical</li></ul><p>There are other cross-platform options, such as Flutter and React Native, each with its own strengths. I haven’t used them myself, so I won’t compare them. But if you already live in the .NET world, MAUI with Blazor Hybrid is a very natural choice.</p><h4>Back to the kitchen table</h4><p>What started as a small app for my child’s dictation practice turned into a whole collection of personal tools. If you know C#, HTML, CSS and JavaScript, you already have most of what you need to build mobile apps. Add AI tools for the design, and the barrier gets even lower.</p><p>The best part has nothing to do with code, though. My child now asks to practice dictation with the app, all on his own. He even comes up with ideas to make it better and he has been my biggest cheerleader for releasing it publicly. Right now, I’m fighting my way through the Google Play Store’s rather complicated publishing process. Hopefully, it will be out soon so other families can use it too.</p><p>If you’re a C# developer who has never built a mobile app, give it a try. You might be closer than you think.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=61c81bb5d95a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A weekend and a startup’s missing milliseconds]]></title>
            <link>https://medium.com/@babaknia/a-weekend-and-a-startups-missing-milliseconds-a907193eadf1?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/a907193eadf1</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Tue, 27 Oct 2026 16:51:00 GMT</pubDate>
            <atom:updated>2026-10-28T18:05:04.616Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*deIm2v0XJzhguZkXbSUvHg.jpeg" /><figcaption>Westeinderplassen — Aalsmeer</figcaption></figure><p>8% sounds small, until it breaks your contract with your customers.</p><p>Last weekend, I had some free time and spent it helping a few friends who are building a startup. I’m not part of their team. Their product had suddenly become slower and since I have some experience with this kind of problem, they asked me to take a look.</p><p>Their team is small. Like most early-stage startups, they are in a constant race to ship the features their customers ask for, because every feature means a better chance at a bigger share of the market. That race hasn’t stopped (will it ever?!). In a short time they added a <em>lot</em> of features and somewhere along the way performance slipped through the cracks. The application had become about 8% slower, which pushed them well past the response-time limits in their customer contracts. On top of that, every now and then strange latency spikes showed up and nobody could tell where they came from. By the time I got involved, they had been struggling with this for about three weeks. They had no idea where to start. All they knew was that a lot had changed in a short period.</p><h4><strong>They did the smart thing from day one</strong></h4><p>I have to give them credit here. Many startups treat profiling and monitoring as something to add “later, when we’re bigger”. And before you blame it on startup chaos: I’ve seen the same heroic optimism in so-called mature companies, the ones with a slide deck on “operational excellence” and not a single profiler in production. Apparently, preparing for the worst case is something you do after it happens.</p><p>My friends were wise enough to think about <strong>Java Flight Recorder (JFR)</strong> from the very first days of the project. They built it into their application, set up detailed monitoring alongside it and kept track of their performance baseline. So when things went wrong, they had real evidence. Their monitoring had already told them that the application had degraded. What they lacked was the time to find out <em>why</em>. With a small team and limited resources, all their energy went into shipping features and the deep analysis of all that carefully collected data kept getting pushed further down the list. Having the right signals is half the battle. Someone still has to sit down and read them.</p><p>The same discipline showed in their Git history. The commits were tidy. The commit messages actually explained what changed and why. For someone like me, coming in cold with only a weekend, that was worth its weight in gold. (I wrote more about this in my other post: <a href="https://medium.com/@babaknia/use-git-to-onboard-new-employees-df804eabf5a1">Use Git to onboard new employees</a>.)</p><p>If you take one thing from this post: <em>record JFR and keep a baseline before you need them.</em> Without that data, my weekend would have been pure guesswork.</p><h4><strong>Too much data, too little time</strong></h4><p>I had two days, a pile of JFR files from many servers and a codebase I knew almost nothing about. I had no idea what had been built, what had changed or when things started to go wrong. Opening the recordings one by one in a GUI was out of the question, so I split the work into two tracks that could run at the same time.</p><p>First, I wrote a few bash scripts to read JFR’s own API and read all the recordings, group the events by the categories JFR already provides (CPU sampling, allocations, GC, locks, I/O and so on) and turn them into plain text summaries. (If you want to try this yourself, take a look at the end of this article.) Then I fed those summaries to an LLM (they provided me access to their Claude), one batch at a time and asked it to look for patterns, outliers and anything that pointed to a likely cause. I didn’t expect it to solve the problem for me. I only wanted a few leads in that chaos. It also cross-checked its findings against the JFR documentation and other resources, so I didn’t have to read all of it myself.</p><p>Meanwhile, I was going through the Git history and the source code to understand what had been added recently, how the system fit together and where a regression could hide. By the time a lead came up in the profiling data, I already had a rough idea of which part of the code it pointed to.</p><h4><strong>A weekend that never slept</strong></h4><p>The most fun part of this weekend had nothing to do with Java. My friends are spread between the US and Australia and I’m in Europe, somewhere in the middle. Whenever one of us went to bed, someone else was waking up. When it was night for me, it was day for them and the other way around. Before signing off, each of us left a message about how far we’d gotten and what we’d found, so the next person could pick it up right where we left off.</p><h4><strong>What I found</strong></h4><p>I can’t go into the details of the project itself. It hasn’t been announced publicly yet, and honestly, it’s a really exciting idea. I hope the team can share more about what they’re building soon. So I’ll stick to the kinds of problems I found, not the specifics. In the end, the slowdown wasn’t one problem. It was three, and each one was very different.</p><p><strong>1. Heavy logging.</strong> The project is sensitive, so the team wanted every event logged, which is a reasonable goal. But it had been implemented in a naive way. Once I pointed it out, they saw the problem right away and fixed it using well-established logging patterns. Performance improved noticeably and they still log everything they need.</p><p><strong>2. Trusting LLMs a little too much.</strong> Under pressure to ship fast, the team had leaned heavily (and a bit too optimistically) on coding assistants. Along the way, three third-party libraries had found their way into the project. Some were added by the tools and some by the team itself, but in every case without really knowing what the library was or why it was needed. Nobody had stopped to ask. The clues came from two places at once: the JFR files, where these libraries kept showing up in the profiling data for no obvious reason, and the Git history, which showed when and why each of them had been added.</p><p>I studied the code carefully to understand the original requirement behind each library. I removed all three of them completely and wrote it myself in less than 60 lines of code. Fewer external dependencies, code that is much simpler to read and reason about and a noticeable share of the slowdown gone with them.</p><p>The irony is hard to miss. One LLM helped create this problem and another one helped me solve it. The tool is the same. The difference is whether a human is reviewing and steering it. Never take their output at face value. (More on that in my other post: <a href="https://medium.com/@babaknia/should-we-trust-llms-015e632f6f06">Should we trust LLMs?</a>)</p><p><strong>3. Hidden concurrency deep in a library.</strong> This was the hardest one: a concurrency problem that simply didn’t show up in the application code, which looked perfectly fine. And that’s one of Java’s quieter traps. The language makes it very easy to end up with shared, changeable state tucked away somewhere you’d never think to look and it gives you almost no signal when that happens. State that hides inside a component, or that slips out and gets touched by other threads, is only part of the risk. Once data can change while several threads use it, there are many more ways for things to go wrong. (It was very similar to this famous issue: <a href="https://bugs.openjdk.org/browse/JDK-4228335">https://bugs.java.com/bugdatabase/JDK-4228335</a>)</p><p>The real cause was inside one of the underlying libraries, in how it handled concurrency internally. Nobody had noticed it, and under load it was quietly slowing everything down.</p><p>The clue came from <strong>parked threads</strong>. When a Java thread waits on a lock from `<em>java.util.concurrent`</em> (such as a `<em>ReentrantLock</em>`), the JVM parks it and JFR records this as a `<em>jdk.ThreadPark</em>` event. Each event includes how long the thread waited, the class it was parked on and the full stack trace. Waits on `<em>synchronized</em>` blocks show up separately as `<em>jdk.JavaMonitorEnter</em>` events.</p><pre>- Here is a simplified view of before and after:<br><br>--- before<br>Top blocking sites (first non-JDK frame on the waiting thread&#39;s stack), all stages:<br><br> #1  jdk.ThreadPark            26,893 events     3,720.5 s blocked (100.0% of all blocked time), longest 518.3 ms<br>     waiting in:   com.acme.format.internal.FormatEngine.money(FormatEngine.java:75)<br>     blocked on:   java.util.concurrent.locks.ReentrantLock$NonfairSync<br>     called from:  com.acme.invoice.format.AcmeInvoiceFormats.money(AcmeInvoiceFormats.java:17)<br><br>--- fixed<br>Top blocking sites (first non-JDK frame on the waiting thread&#39;s stack), all stages:<br><br> #1  jdk.JavaMonitorEnter          39 events         1.0 s blocked (11.0% of all blocked time), longest 1.4 ms<br>     waiting in:   com.acme.format.internal.FormatEngine.money(FormatEngine.java:69)<br>     blocked on:   java.util.concurrent.ConcurrentHashMap$Node  (+2 other)<br>     called from:  com.acme.invoice.format.AcmeInvoiceFormats.money(AcmeInvoiceFormats.java:17)</pre><p>In my summaries, the number of long park events grew sharply under load and their stack traces kept pointing to the same place deep inside that library. JDK Mission Control’s thread view told the same story: long gaps where threads were waiting instead of working. This is exactly where JFR shines. It shows what the JVM is really doing, not what the code seems to say.</p><p>It also solved the mystery of the latency spikes. Whenever enough threads piled up waiting on that same spot, response times jumped for a moment and then settled again. The spikes that had puzzled the team for about three weeks were simply this hidden contention showing itself.</p><p>After fixing all three issues, we ran the team’s load tests again. The 8% slowdown was gone, and the application was even faster than before the slowdown began, comfortably within their contract again.</p><h4><strong>Something they can keep</strong></h4><p>The fixes were the main goal, but the scripts I wrote didn’t have to be a one-off. It’s now part of their automation. Whenever they face a similar problem, they can run the same pipeline over their recordings and get a clear report (not to mention the need of burning some tokens!). The report is useful on its own and speaks for itself. Their early investment in JFR finally has a fast, repeatable way to pay off.</p><p>The part I like the most is how the script prepares data for the LLM. Instead of sending huge dumps, it aggregates, filters and compresses everything into compact summaries and sends only what matters for each question. That kept the conversation focused, fast and cheap, while still giving the model enough context to come up with useful leads.</p><p>Record JFR and keep a baseline from day one. Review every library your coding assistant (or your colleague) adds, because each one costs you in size, complexity and risk. Look below your own code. Some performance problems live in the libraries and the runtime and only profiling data will reveal them. And sometimes a small team just needs a fresh pair of eyes from outside the daily feature race.</p><p>Bonus point: If your Git commit messages only say “fix” or “minor changes”, a weekend as this one turns into a month.</p><h4><strong>Tips for feeding the data to an LLM</strong></h4><ul><li>Summarize, don’t dump. Top-N lists and aggregates beat raw events. A full `jfr print — json` output is far too big for any context window.</li><li>One category at a time. Send CPU first, then allocations, then GC, then locks. Ask the model what stands out before moving on.</li><li>Label everything. Put the server name, time range, and JDK version at the top of each summary so the model can compare like with like.</li><li>Compare against the baseline. Sending a summary from a healthy period next to one from a slow period is the fastest way to surface what changed.</li><li>Treat the answers as leads, not conclusions. Always verify the model’s suggestions in the code or in JDK Mission Control.</li></ul><h4><strong>Turning JFR files into LLM-friendly text</strong></h4><p>A JFR file is a compact binary format, so an LLM can’t read it directly. The trick is to turn each recording into short, structured text that keeps the signal and drops the noise. There are two easy ways to do it. The JDK ships with a `jfr` tool. Since JDK 21, it has a `view` command with ready-made aggregated reports, which are perfect for an LLM because they are already summarized.</p><pre># Quick overview of what&#39;s inside a recording<br>jfr summary recording.jfr<br><br># Aggregated views (JDK 21+)<br>jfr view hot-methods recording.jfr<br>jfr view allocation-by-site recording.jfr<br>jfr view gc-pauses recording.jfr<br>jfr view contention-by-site recording.jfr<br>jfr view longest-compilations recording.jfr<br><br># List all available views<br>jfr view --help</pre><p>Looping over all files from all servers is then a small shell script:</p><pre>#!/usr/bin/env bash<br>set -euo pipefail<br><br>JFR_DIR=&quot;/&lt;path-to-jfrs&gt;&quot;<br>OUT_DIR=&quot;$JFR_DIR/analysis&quot;<br><br>JVM_VIEWS=(<br>  blocked-by-system-gc gc-concurrent-phases jvm-information<br>  class-modifications gc-configuration longest-compilations<br>  compiler-configuration gc-cpu-time native-memory-committed<br>  compiler-phases gc-parallel-phases native-memory-reserved<br>  compiler-statistics gc-pause-phases safepoints<br>  deoptimizations-by-reason gc-pauses tlabs<br>  deoptimizations-by-site gc-references vm-operations<br>  gc heap-configuration<br>)<br><br>ENV_VIEWS=(<br>  active-recordings cpu-load native-library-failures<br>  active-settings cpu-load-samples network-utilization<br>  container-configuration cpu-tsc recording<br>  container-cpu-throttling environment-variables system-information<br>  container-cpu-usage events-by-count system-processes<br>  container-io-usage events-by-name system-properties<br>  container-memory-usage jvm-flags<br>)<br><br>APP_VIEWS=(<br>  allocation-by-class exception-by-site method-timing<br>  allocation-by-site exception-by-type modules<br>  allocation-by-thread exception-count monitor-inflation<br>  class-loaders file-reads-by-path native-methods<br>  contention-by-address file-writes-by-path object-statistics<br>  contention-by-class finalizers pinned-threads<br>  contention-by-site hot-methods socket-reads-by-host<br>  contention-by-thread latencies-by-type socket-writes-by-host<br>  cpu-time-hot-methods longest-class-loading thread-allocation<br>  cpu-time-statistics memory-leaks-by-class thread-count<br>  deprecated-methods-for-removal memory-leaks-by-site thread-cpu-load<br>  exception-by-message method-calls thread-start<br>)<br><br>ALL_VIEWS=(&quot;${JVM_VIEWS[@]}&quot; &quot;${ENV_VIEWS[@]}&quot; &quot;${APP_VIEWS[@]}&quot;)<br><br>mkdir -p &quot;$OUT_DIR&quot;<br><br>for jfr_file in &quot;$JFR_DIR&quot;/*.jfr; do<br>  base=$(basename &quot;$jfr_file&quot; .jfr)<br>  rec_dir=&quot;$OUT_DIR/$base&quot;<br>  views_dir=&quot;$rec_dir/views&quot;<br>  mkdir -p &quot;$views_dir&quot;<br><br>  echo &quot;=== Processing $base ===&quot;<br><br>  echo &quot;  summary...&quot;<br>  jfr summary &quot;$jfr_file&quot; &gt; &quot;$rec_dir/summary.txt&quot; 2&gt;&amp;1<br><br>  echo &quot;  metadata...&quot;<br>  jfr metadata &quot;$jfr_file&quot; &gt; &quot;$rec_dir/metadata.txt&quot; 2&gt;&amp;1<br><br>  echo &quot;  print (json)...&quot;<br>  jfr print --json &quot;$jfr_file&quot; &gt; &quot;$rec_dir/print.json&quot; 2&gt;&amp;1<br><br>  for view in &quot;${ALL_VIEWS[@]}&quot;; do<br>    output=$(jfr view --width 200 &quot;$view&quot; &quot;$jfr_file&quot; 2&gt;&amp;1) || true<br>    if [[ &quot;$output&quot; == &quot;No events found for&quot;* ]] || [[ &quot;$output&quot; == &quot;Can&#39;t find event type named&quot;* ]]; then<br>      echo &quot;    WARNING: $view - $output&quot;<br>    else<br>      echo &quot;$output&quot; &gt; &quot;$views_dir/$view.txt&quot;<br>    fi<br>  done<br>  done<br>  echo &quot;  views done (${#ALL_VIEWS[@]} views)&quot;<br>done<br><br>echo &quot;&quot;<br>echo &quot;Done. Output in: $OUT_DIR&quot;</pre><p>You can modify and extend the script to fit your needs.</p><p>See also this: <a href="https://youtu.be/AgFOJEkBVjg">Programmer&#39;s Guide to JDK Flight Recorder</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a907193eadf1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Psychological Safety vs. Standards]]></title>
            <link>https://medium.com/@babaknia/psychological-safety-vs-standards-fe82e85ae592?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe82e85ae592</guid>
            <category><![CDATA[team-building]]></category>
            <category><![CDATA[management-and-leadership]]></category>
            <category><![CDATA[management]]></category>
            <category><![CDATA[leadership-skills]]></category>
            <category><![CDATA[leadership]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 17:19:19 GMT</pubDate>
            <atom:updated>2026-08-28T15:07:44.424Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9ftXG4AC5vddFmzG" /><figcaption>Photo by <a href="https://unsplash.com/@pyeshtiaghi?utm_source=medium&amp;utm_medium=referral">POOYAN ESHTIAGHI</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Psychological safety is often mistaken for a soft environment where nobody is ever criticized and weak work is quietly tolerated. That is not what the term means. Amy Edmondson, who coined the term, defines it narrowly: the shared belief that you will not be punished or humiliated for speaking up, asking a question, admitting a mistake, raising a concern, or disagreeing with someone more senior. It says nothing at all about how good the work has to be.</p><p>Edmondson makes the point with a simple two-by-two grid, with safety on one axis and standards on the other. Low safety and low standards produce apathy: people have checked out. Low safety and high standards produce anxiety: people are pushed hard but are afraid to admit when something is going wrong, so problems stay hidden until they are expensive. High safety and low standards produce what she calls the comfort zone: a pleasant team that does not achieve much. Only high safety combined with high standards gives you the learning zone, where people surface problems early and are still held to a demanding bar.</p><p>I bet you can easily point to teams in your company that are always either in their comfort zone or anxiety zone. It’s even worse to be on a team where you can’t freely share ideas or raise concerns, especially when your contributions are dismissed as personal attacks by those too weak to engage constructively rather than being addressed collaboratively.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qG9OwuC8vZmaqJjwDxrdYA.jpeg" /><figcaption><a href="https://amycedmondson.com/">https://amycedmondson.com</a></figcaption></figure><p>The two are not in tension because they answer different questions. Standards are about the work (does this code meet the bar? is this design sound? did this project deliver what it promised?) Safety is about the person. For example, what happens to you when you admit the work fell short or when you say something unpopular?<br>Lowering the bar is not what makes someone safe. Being treated fairly and without humiliation when they miss the bar is. A team can run genuinely blameless postmortems and still refuse to ship code that fails review. In fact, those two things reinforce each other: people only report problems honestly when reporting them is safe and you cannot hold a high reliability bar if nobody tells you what is actually breaking.</p><p>In practice, holding both comes down to how feedback is delivered. Kim Scott’s radical candor framing is the useful one. Care personally and challenge directly at the same time. Each failure mode drops one half of that. Softening or withholding hard feedback to keep the room comfortable trades away the standard for a false kind of safety and the person being protected loses the chance to improve. Delivering the same feedback harshly, or in public, gets the standard across but teaches everyone that being honest about problems is dangerous.</p><figure><img alt="https://www.radicalcandor.com/our-approach" src="https://cdn-images-1.medium.com/max/500/1*4-69ISUNi59hGin6c5TAXA.jpeg" /><figcaption><a href="https://www.radicalcandor.com/our-approach">https://www.radicalcandor.com/our-approach</a></figcaption></figure><p>A Team Lead holds both by being specific and unambiguous about what the bar is and where the work fell short, making clear that the gap is in the work rather than in the person and keeping the consequences of admitting a mistake proportionate. The engineer who owns up to causing an incident should still be trusted with important work afterwards. That last part is the real test, because a team learns which of the two you actually mean from what happens to people and not from what is said in a meeting.</p><p>See also:<br>- <a href="https://www.amazon.com/dp/B07KLT8RKM">The Fearless Organization: Creating Psychological Safety in the Workplace for Learning, Innovation, and Growth by Amy C. Edmondson</a><br>- <a href="https://amzn.eu/d/0ijwzpMB">Radical Candor: Be a Kick-Ass Boss Without Losing Your Humanity by Kim Scott</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe82e85ae592" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Moving beyond a fire extinguisher]]></title>
            <link>https://medium.com/@babaknia/moving-beyond-a-fire-extinguisher-aa092e1543bd?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa092e1543bd</guid>
            <category><![CDATA[leadership-development]]></category>
            <category><![CDATA[management]]></category>
            <category><![CDATA[team-collaboration]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[conflict-resolution]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Mon, 10 Aug 2026 16:26:42 GMT</pubDate>
            <atom:updated>2026-08-16T09:24:46.018Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0gz6rpZiN0Rs5d3G" /><figcaption>Photo by <a href="https://unsplash.com/@kevphotomcr?utm_source=medium&amp;utm_medium=referral">Tak Kei Wong</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I recently discovered <a href="https://en.wikipedia.org/wiki/Tuckman&#39;s_stages_of_group_development">Bruce Tuckman’s model</a>, which describes four (later five) stages most teams move through as they mature.</p><ol><li><strong>Forming</strong> (polite, cautious, unclear roles. Early team life)</li><li><strong>Storming</strong> (conflict emerges as people push back on ideas and roles get contested)</li><li><strong>Norming</strong> (the team establishes shared working agreements and trust)</li><li><strong>Performing</strong> (the team operates with high trust and autonomy, able to handle disagreement productively)</li><li><strong>Adjourning</strong> (covers a team’s eventual dissolution or major reshuffling)</li></ol><p>The practical value for a team lead is recognizing that storming isn’t a sign the team is failing. It’s often a necessary and healthy stage. A team that never storms (because conflict is being suppressed rather than resolved) may actually be stuck in an artificially calm forming stage rather than genuinely performing. A manager who acts like a fire extinguisher is like putting a bandage on a volcano; it only delays the inevitable eruption. The transition from Storming to Norming requires patience, active leadership and a <strong>focus on unity</strong>. By addressing conflicts head-on, clarifying expectations and fostering a <strong>culture of trust</strong>, managers can help their teams move toward a more cohesive and productive phase.</p><p>Note that teams also regress backward through the stages after a significant change (a new member joining, a reorg, losing a key member), so a lead shouldn’t be surprised if a previously high-performing team briefly re-enters storming after a disruption.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa092e1543bd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is an Architecture Decision Record (ADR)?]]></title>
            <link>https://medium.com/@babaknia/what-is-an-architecture-decision-record-adr-fcca28e7ce9b?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/fcca28e7ce9b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Thu, 06 Aug 2026 13:53:45 GMT</pubDate>
            <atom:updated>2026-08-06T13:53:45.935Z</atom:updated>
            <content:encoded><![CDATA[<p>Have you ever been lost in a large codebase that has been under development for years, with none of the original decision-makers on the team or in the company anymore? Have you ever wondered why they chose that approach rather than the other?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GZRuvTT9YnY8RrFp" /><figcaption>Photo by <a href="https://unsplash.com/@theprototype?utm_source=medium&amp;utm_medium=referral">The Prototype</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>An ADR is a short, versioned document that captures a significant architectural decision, the context that prompted it, the options considered, the decision made and its consequences. Written down at the time the decision is made rather than reconstructed from memory later. ADRs are typically stored alongside the code they describe (often as numbered Markdown files in the repository), so they stay discoverable and versioned with the system they document.</p><pre># ADR-0042: Use PostgreSQL for the order service<br><br>## Context<br>The order service needs strong transactional guarantees across<br>related tables, and the team already operates PostgreSQL elsewhere.<br><br>## Decision<br>Use PostgreSQL rather than a NoSQL alternative.<br><br>## Consequences<br>Gains ACID transactions and mature tooling; accepts a fixed schema<br>migration process for future changes.</pre><p>For a Team, ADRs are a cheap and durable way to preserve the “why” (and sometimes “how”) behind a decision. The single most common thing lost when engineers who made a call move to a different team or leave the company. They also make it far easier to revisit a decision later, since the original trade-offs and context are written down rather than reverse-engineered from the code.</p><p>See also:<br><a href="https://martinfowler.com/bliki/ArchitectureDecisionRecord.html">https://martinfowler.com/bliki/ArchitectureDecisionRecord.html</a><br><a href="https://docs.aws.amazon.com/prescriptive-guidance/latest/architectural-decision-records/adr-process.html">https://docs.aws.amazon.com/prescriptive-guidance/latest/architectural-decision-records/adr-process.html</a><br><a href="https://learn.microsoft.com/en-us/azure/well-architected/architect-role/architecture-decision-record">https://learn.microsoft.com/en-us/azure/well-architected/architect-role/architecture-decision-record</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fcca28e7ce9b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Should we trust LLMs?]]></title>
            <link>https://medium.com/@babaknia/should-we-trust-llms-015e632f6f06?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/015e632f6f06</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Thu, 16 Apr 2026 19:34:10 GMT</pubDate>
            <atom:updated>2026-05-02T15:13:08.935Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HQFQ5HXufyElR-OI" /><figcaption>Photo by <a href="https://unsplash.com/@its_tgain?utm_source=medium&amp;utm_medium=referral">Tom Gainor</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>These models and tools are evolving every day and surprisingly getting better and better. They are not AI. Still not AI (artificial intelligence). They don’t understand the content. They generate responses based on patterns in data. They lack reasoning, common sense and the ability to learn or adapt beyond their training data. They don’t set goals or make independent decisions. Their outputs are remixes of existing data, not original ideas or insights. They are advanced tools, not autonomous intelligent agents. Autonomy is widely overvalued because autonomy means that it does what it wants. We’re nowhere near designing bots that have a will of their own or agency of their own. We call them agents, but they’re really delegates.</p><p>The companies behind these tools just keep copying each other day after day. A feature that one has today will be in the other one tomorrow. They spend money to advertise that one model is better and that one other feature beats their competitors. The social media and news are polluted with all this boring and repetitive news.</p><p>Not only are the models black boxes to everyone but also the companies that own the models and tools for obvious reasons keep their product in the dark. We don’t know which rules and restrictions they are applying on top of ours. It’s not yet possible to understand in what detail those tools review (and understand!) our requests and the attached materials. Due to cost-cutting measures or unintended bugs, these companies might reduce the effort put into processing your request. The introduction of skills is also not quite helpful and sometimes makes things even worse as nobody is sure how much data is enough.</p><p>Even in their core strength, which is understanding text, LLMs can sometimes fail. For example, I’m getting into the habit of storing summaries of the books I’m reading in my notes, chapter by chapter, using these tools. Having them reviewed, I noticed that they summarized a couple of chapters of a book completely wrong. I was curious and did some research and figured out that they didn’t check my attached resources for whatever reason but pointed to garbage on social media. From now on, I will always double-check their output.</p><p>The other day, one of the famous tools had a bug. By chance, I noticed that it accessed files that it shouldn’t have. I carefully gave it access to read one specific file in a different folder, but then for the next requests, it fetched the other files in that location, too. I wasn’t able to gather enough evidence to prove it to you. Also, that company introduced a new upgrade after a couple of hours, even though I had already updated it a few hours earlier. I couldn’t reproduce it afterward. Probably they noticed that nasty bug. If you go Yolo, autopilot, or have critical documents and resources, never run them on the same machine. Always run them in isolation with limited resources and access, such as a Docker container. If your machine has sufficient resources, it’s preferred to set up those tools locally. For that, have a look at my other post: <a href="https://medium.com/@babaknia/do-more-pay-zero-c56df3c50ff0">Do More, Pay Zero</a>.</p><p>LLMs are still black boxes and no one fully understands how they make decisions. Even a simple rewording of your prompt (while keeping the same intent) can produce completely different and sometimes incorrect answers (Also, see: <a href="https://hbr.org/2025/12/how-two-leading-llms-reasoned-differently-in-english-and-chinese">LLMs Respond Differently in English and Chinese</a>). You may need to review and revise it several times or request it through different models to be able to verify the result.</p><p>For example, have a look at this: <a href="https://mastodon.world/@knowmadd/116072773118828295">https://mastodon.world/@knowmadd/116072773118828295</a></p><figure><img alt="Q: I want to wash my car. The car wash is 50 meters away. Should I walk or drive? https://mastodon.world/@knowmadd/116072773118828295" src="https://cdn-images-1.medium.com/max/1024/1*JacWEWGG_kR0bpO5dJPExA.png" /></figure><p>Despite what I said, these tools and models are revolutionary great. They are good as a pair of extra eyes to review a plan or code. As a new way of “googling” for something that you don’t know or have forgotten. Excellent for prototyping a new idea. Very handy for adding unit tests and pushing to find the corner cases. And great for generating sample data.</p><p>There are still many uncertainties. It terrifies me to think that managers or politicians (people responsible for products and lives) might carelessly use these tools without proper verification and understanding.</p><p>Never take their results at face value and always verify them before use. Review your prompt and test it across different models. Understand the strengths and limitations of your tools and double-check the results whenever necessary.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=015e632f6f06" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do More, Pay Zero]]></title>
            <link>https://medium.com/@babaknia/do-more-pay-zero-c56df3c50ff0?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/c56df3c50ff0</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Sun, 08 Mar 2026 18:48:27 GMT</pubDate>
            <atom:updated>2026-04-24T17:09:56.956Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*m679VbQOVq-nuJhE" /><figcaption>Photo by <a href="https://unsplash.com/@rominahmadpour?utm_source=medium&amp;utm_medium=referral">Romina Ahmadpour</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Are you tired of handing over your most intimate thoughts and confidential company secrets to the tech giants that promise to ‘know’ you better than anyone? Do you struggle with the constant uncertainty of cloud-based GenAI services, where a single change in their policies can render your entire project obsolete? You’re not alone. The rise of local large language models (LLMs) is a game-changer for anyone who values data privacy, flexibility, and control, and it’s time to rethink the way we approach AI development.</p><p><strong>Data privacy and security — sensitive data stays local</strong></p><p>Local LLMs ensure data privacy and security because sensitive information never leaves your local environment. There’s a rumor that Google knows about your problems before your partner, or even you, because we search for everything there. Today, not only tech giants but also small startups are active in this market. People share private matters and company confidential materials with GenAI applications. Nobody really knows what they’ll do with our data.</p><p><strong>Full control and flexibility — no prompt restrictions or sudden policy changes</strong></p><p>This market is new and highly competitive. They constantly made changes in their products. A prompt that worked yesterday may not work today. A few months ago, while I was working on a hobby project, things suddenly stopped working. Later, I found out that because of a legal issue, they had to make changes to their system prompt, and that caused my program not to work as expected. On the other hand, we can also customize and fine-tune models to better match our specific use cases and requirements. Although it isn’t straightforward, if you or your company has enough data, you can fine-tune your model without leaking your data outside.</p><p><strong>No token limits — no prompt trimming or workarounds</strong></p><p>There is no need to worry about token limits or waste time adjusting prompts to fit within them. You aren’t supposed to pay anyone (except, of course, for your electricity) and try any amount of data at any number of times until you are satisfied with the result.</p><p><strong>Model freedom — use and experiment with all kinds of models</strong></p><p>Because everything runs locally, we can experiment with models that may not be permitted in cloud environments for various reasons. For example, I found that Qwen, a China-based model, performs surprisingly well with our source base. Even if I were allowed to use it in the cloud, I would avoid doing so for obvious reasons.</p><p><strong>Lower latency — no network calls</strong></p><p>Running models locally also reduces latency, as there is no need to send requests over the Internet.</p><p><strong>Efficient on local hardware — even older machines can run models well</strong></p><p>Even older hardware, such as a MacBook Pro M1, can run models efficiently. Many models are already good enough for everyday tasks like text summarization and report comparison. For example, Llama 3.2 works well for these purposes across many workstations.</p><p><strong>Cost savings — local LLMs are free!</strong></p><p>Most importantly, local LLMs are free. This means substantial cost savings, especially for companies looking to optimize expenses. Each model has its own strengths and weaknesses. Using multiple models lets us leverage their complementary capabilities. Running them locally gives us the freedom to experiment with different models, prompts, and configurations, all without worrying about additional costs. Running models locally is an excellent way to prototype and develop ideas without worrying about extra costs.</p><p>There are several options for running a model locally. To start, you can use <a href="https://ollama.com/">Ollama</a>. If you are a programmer, there are official libraries to call from your program. Make sure you don’t get the cloud version of models to stay local. For that, have a look at my other post: <a href="https://medium.com/@babaknia/llms-fight-club-a0d9c11fefac">LLMs fight club</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c56df3c50ff0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[History of the Netherlands in one page]]></title>
            <link>https://medium.com/@babaknia/history-of-the-netherlands-in-one-page-227421b0f195?source=rss-3f20cc1680e8------2</link>
            <guid isPermaLink="false">https://medium.com/p/227421b0f195</guid>
            <category><![CDATA[living-in-the-netherlands]]></category>
            <category><![CDATA[dutch]]></category>
            <category><![CDATA[the-netherlands]]></category>
            <dc:creator><![CDATA[Babak Arjmandnia]]></dc:creator>
            <pubDate>Sun, 22 Feb 2026 10:17:58 GMT</pubDate>
            <atom:updated>2026-02-22T10:17:58.613Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WlW454FASG-CoxM2" /><figcaption>Photo by <a href="https://unsplash.com/@nerecnerec?utm_source=medium&amp;utm_medium=referral">Ceren</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Before 1800</h3><ul><li><strong>Around Year 0:</strong> Romans arrived in the region, leading to the emergence of early cities such as <strong>Maastricht and Utrecht</strong>.</li><li><strong>500–1500:</strong> The period known as the <strong>Middle Ages</strong>.</li><li><strong>1568:</strong> Start of the <strong>80 Years’ War</strong> (the Dutch revolt against Spain) led by William of Orange.</li><li><strong>1574 (October 3):</strong> The <strong>Relief of Leiden</strong>, celebrated annually with bread and herring.</li><li><strong>1584:</strong> <strong>William of Orange was assassinated</strong> in Delft.</li><li><strong>1588:</strong> The Netherlands became a <strong>republic</strong> (Republic of the Seven United Netherlands).</li><li><strong>1600–1700:</strong> The 17th century, known as the <strong>Golden Age</strong>, was characterized by immense wealth from global trade and the flourishing of the arts.</li><li><strong>1648:</strong> The <strong>end of the 80 Years’ War</strong>; the Netherlands became an officially independent state.</li></ul><h3>The 1800s</h3><ul><li><strong>1813:</strong> The Netherlands gained its first king, <strong>King Willem I</strong>.</li><li><strong>1814:</strong> The Netherlands officially became a <strong>kingdom</strong>.</li><li><strong>1815:</strong> The first <strong>Dutch Constitution</strong> (<em>Grondwet</em>) was established.</li><li><strong>1830:</strong> <strong>Belgium</strong> became an independent country, separating from the Netherlands.</li><li><strong>1848:</strong> A major <strong>revision of the Constitution</strong> by Johan Thorbecke, which limited the King’s power and established modern democracy.</li><li><strong>1863:</strong> <strong>Slavery was abolished</strong> in the Dutch colonies.</li><li><strong>1871:</strong> <strong>Aletta Jacobs</strong> became the first Dutch woman to study at a university (to become a doctor).</li><li><strong>1874:</strong> A law was passed <strong>prohibiting child labor</strong> for those under 12.</li></ul><h3>The 1900s</h3><ul><li><strong>1900:</strong> Introduction of <strong>compulsory education</strong> (<em>leerplicht</em>) for children aged 6 to 12.</li><li><strong>1914–1918:</strong> <strong>World War I</strong> occurred; the Netherlands remained neutral.</li><li><strong>1917:</strong> <strong>Universal suffrage</strong> was granted to all men.</li><li><strong>1919:</strong> <strong>Women gained the right to vote</strong> in the Netherlands.</li><li><strong>1930:</strong> A major <strong>economic crisis</strong> hit Europe, leading to widespread poverty.</li><li><strong>1932:</strong> The <strong><em>Wilhelmus</em></strong> became the official Dutch national anthem.</li><li><strong>1940–1945:</strong> <strong>World War II</strong> in the Netherlands; Nazi Germany occupied the country.</li><li><strong>1944:</strong> The <strong>“Hunger Winter”</strong> (<em>Hongerwinter</em>), where many died due to lack of food and fuel.</li><li><strong>1945 (May 5):</strong> <strong>Liberation Day</strong>; the end of the German occupation.</li><li><strong>1945:</strong> <strong>Indonesia</strong> (formerly the Dutch East Indies) became independent.</li><li><strong>1945:</strong> Establishment of the <strong>United Nations</strong> (VN/UN).</li><li><strong>1948:</strong> <strong>Juliana</strong> became Queen of the Netherlands.</li><li><strong>1949:</strong> Establishment of <strong>NATO</strong>.</li><li><strong>1953 (February):</strong> The <strong>North Sea flood</strong> (<em>Watersnoodramp</em>), which led to the creation of the Delta Works.</li><li><strong>1957:</strong> Establishment of the <strong>European Union</strong> (initially as a collaborative agreement between European countries).</li><li><strong>1960s–1970s:</strong> A period of significant <strong>social change</strong> (emancipation, less religious influence) and the arrival of <strong>guest workers</strong> (<em>gastarbeiders</em>) from countries like Morocco and Turkey.</li><li><strong>1975:</strong> <strong>Suriname</strong> became an independent country.</li><li><strong>1980:</strong> <strong>Refugees</strong> began coming to the Netherlands in larger numbers due to safety concerns in their home countries.</li></ul><h3>The 2000s to Present</h3><ul><li><strong>2001:</strong> <strong>Same-sex marriage</strong> became legal in the Netherlands.</li><li><strong>2002:</strong> The <strong>Euro (€)</strong> became the official currency of the Netherlands.</li><li><strong>2007:</strong> Introduction of the <strong>Integration Act</strong> (<em>Inburgeringswet</em>).</li><li><strong>2010:</strong> The <strong>Netherlands Antilles</strong> ceased to exist as a colony.</li><li><strong>2013:</strong> <strong>King Willem-Alexander</strong> was inaugurated as the King of the Netherlands.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=227421b0f195" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>