<?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 Joris van der Aalsvoort on Medium]]></title>
        <description><![CDATA[Stories by Joris van der Aalsvoort on Medium]]></description>
        <link>https://medium.com/@jorisvdaalsvoort?source=rss-9170fb52f2e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*93CHb8QtgkM-DMxszDQS6g.jpeg</url>
            <title>Stories by Joris van der Aalsvoort on Medium</title>
            <link>https://medium.com/@jorisvdaalsvoort?source=rss-9170fb52f2e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 03:34:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jorisvdaalsvoort/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[AI Doesn’t Change Software Engineering. It Changes the Economics of Software.]]></title>
            <link>https://medium.com/@jorisvdaalsvoort/ai-doesnt-change-software-engineering-it-changes-the-economics-of-software-2ef1880efdae?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ef1880efdae</guid>
            <category><![CDATA[economics]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[future]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Wed, 01 Jul 2026 07:04:08 GMT</pubDate>
            <atom:updated>2026-07-01T07:04:08.930Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GhadUeqOB6m1MHF6" /><figcaption>Photo by <a href="https://unsplash.com/@amstram?utm_source=medium&amp;utm_medium=referral">Scott Graham</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Whenever a new AI model is released, the conversation follows a familiar pattern.</p><ul><li>How much faster is it?</li><li>How much code can it generate?</li><li>Can it build an application from a single prompt?</li></ul><p>They’re all reasonable questions, but the more I think about them, the more I feel they’re focused on the wrong thing. I don’t think AI fundamentally changes software engineering. I think it changes the economics of software.</p><p>And that feels like a much bigger shift.</p><p>Technology has always changed economics. Not because technology changes what people want, but because it changes what becomes abundant.</p><p>There was a time when storage was expensive. Developers carefully decided what to keep. Today, storage is so cheap that most of us rarely think about deleting data. The same happened with compute. The same happened with bandwidth.</p><p>At first, these felt like technological improvements. Only later did we realize they had changed the economics of computing.</p><p>Whenever something becomes dramatically cheaper, we gradually stop optimizing for it. Our attention moves somewhere else. The constraints change. And with them, value moves.</p><p>I wonder whether software engineering is entering exactly that phase.</p><p>For decades, implementation was one of the dominant constraints. Writing software required significant time and effort. Every new feature represented a meaningful investment.</p><p>We optimized almost everything around reducing the cost of implementation.</p><ul><li>Programming languages became more expressive.</li><li>Frameworks removed boilerplate.</li><li>Cloud platforms simplified infrastructure.</li><li>CI/CD reduced deployment friction.</li><li>Developer experience became a discipline of its own.</li></ul><p>Seen through that lens, AI doesn’t feel like a completely new direction. It feels like the next step in a decades-long effort to reduce the cost of turning ideas into software.</p><p>The difference is the scale. Previous improvements reduced implementation costs incrementally. AI appears to reduce them by an order of magnitude and that feels fundamentally different.</p><p>If that’s true, another question becomes interesting.</p><p>What happens when implementation is no longer the dominant constraint? Economists often describe technological progress as changing the relative cost of production. The product itself doesn’t necessarily change. The cost structure does.</p><p>Software might be entering exactly that phase.</p><p>We’re still building applications.</p><p>We’re still solving business problems.</p><p>We’re still writing software.</p><p>But the cost structure behind software development is beginning to shift and whenever the dominant cost changes, organizations eventually reorganize around whatever becomes scarce next.</p><p>Most conversations about AI still focus on productivity.</p><ul><li>How much faster engineers become.</li><li>How many pull requests AI can generate.</li><li>How much time can be saved.</li></ul><p>Those are useful questions.</p><p>But I can’t help wondering whether they’re measuring yesterday’s bottleneck. They’re all measuring implementation.</p><p>If implementation becomes dramatically cheaper, continuously optimizing implementation becomes less valuable. Not because implementation stops mattering but because organizations rarely optimize around abundance. They optimize around scarcity and scarcity has a habit of moving.</p><p>History suggests this happens surprisingly often.</p><ul><li>Factories eventually stopped optimizing manual labor once machines became dramatically more efficient.</li><li>Cloud computing changed the economics of owning infrastructure.</li><li>Cheap storage changed how we think about data.</li></ul><p>None of those shifts simply made existing work faster. They changed what organizations considered valuable.</p><p>Software engineering is unlikely to be different. The biggest impact of AI may not be that we write software faster. It may be that software organizations gradually begin optimizing for completely different things.</p><p>I suspect we’re still asking first-generation AI questions.</p><ul><li>How fast?</li><li>How accurate?</li><li>How autonomous?</li></ul><p>Those questions matter. Today.</p><p>A Year from now, I don’t think AI will be remembered because it helped us write software faster.</p><p>I think it will be remembered because it changed what software organizations optimize for.</p><blockquote>Every major technological shift changes what is scarce. Whenever scarcity changes, value moves with it and I’m starting to think that’s the real story of AI.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ef1880efdae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Engineers in the Age of AI’s Breakneck Speed]]></title>
            <link>https://medium.com/getaway-group-tech-blog/engineers-in-the-age-of-ais-breakneck-speed-8fecca1d9fb9?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/8fecca1d9fb9</guid>
            <category><![CDATA[learning]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Wed, 08 Oct 2025 19:23:21 GMT</pubDate>
            <atom:updated>2025-10-09T05:22:06.344Z</atom:updated>
            <content:encoded><![CDATA[<p>This is a revolution in a scale that not many of us have witnessed before. Engineers face a paradox. On the one hand, it’s ultra exciting to be part of it. On the other hand, it’s super overwhelming and hard to keep pace. New frameworks, new models and new tools are emerging on a weekly basis. And how should we keep up?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SGb8B1fl6_6mot4Q" /><figcaption>Photo by <a href="https://unsplash.com/@jefflssantos?utm_source=medium&amp;utm_medium=referral">Jefferson Santos</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Some of us have kids to take care of, a lot of us have a partner to spend time with and all of us have friends and hobbies we don’t want to neglect. Of course we are software engineers and we love it, but we are also humans, right? So how can we manage to keep up to date?</p><h3><strong>From Stability to Information Overload</strong></h3><p>Until a few years ago we all were able to rely on our frameworks, languages and knowledge we gained over the course of our careers. Although we can still rely on that, AI is changing our perspective. It is changing how we build software, how we fix bugs, how we learn and how fast everything changes.</p><p>But to be fair, the challenge isn’t just speed. AI is more than machine learning. It is about infrastructure, data engineering, model architectures, prompt design, security and even ethics. All of it evolving at the same time. To keep up, engineers must jump between disciplines and that constant context switch drains time, energy and focus.</p><p>And then you have FOMO. Do I need to read that new research paper? Do I need to test this new released model? Is scanning the headlines enough? The fear of missing a critical trend can be paralyzing, but also trying to follow everything often leads to overload.</p><h3><strong>From Overload to Opportunity</strong></h3><p>But it’s not all dark in the engineering world. The barriers to entry have never been lower. Communities actively share resources, cutting-edge models are available through simple API’s.</p><blockquote>Those who can balance specialization with selective trend-watching can achieve remarkable progress in a short span of time.</blockquote><p>So, the pace of AI is both blessing and a curse. For engineers, it means that standing still is not an option. But it also means that no one can master everything.</p><p>In this article I want to share some tips and tricks to keep up to date without losing sanity, or your private life ;-)</p><h3><strong>How to stay sane while staying up to date</strong></h3><h4><strong>1. Sort your sources</strong></h4><p>Don’t follow everything. Pick a handful of trusted newsletters, podcasts or youtube channels that give you the highlights. That way you don’t waste energy on the noise, but you still know what’s going on.</p><p>Here are some examples if you’re looking for some sources:</p><p>- <a href="https://tldr.tech/">TLDR</a></p><p>- <a href="https://huggingface.co/papers/trending">Huggingface Paperswithcode</a></p><p>- <a href="https://ethical.institute/mle.html">The Machine Learning Engineer Newsletter</a></p><p>- <a href="https://www.deeplearning.ai/">The Batch</a></p><p>- <a href="https://www.aimlengineer.io/">the ai engineer</a></p><h4><strong>2. Go deep only when it matters</strong></h4><p>Not every new thing will change your world. Sometimes scanning the release notes is enough. If something keeps popping up again and again, then it’s worth your time to dive in.</p><h4><strong>3. Learn by doing</strong></h4><p>Instead of reading more and more articles about new tools, set up a small demo project. Play around with it for 30 minutes. Often that gives you insights and the knowledge you gain will stick better than trying to memorize theory.</p><h4><strong>4. Build in learning time</strong></h4><p>It sounds boring, but it is my favorite tip of all. Even a focused 30 minutes a day will keep you sharp without eating up all your valuable time. Treat it like going to the gym. Small and regular sessions are the key.</p><p>Personally, I block time in my calendar 3 times a week for 30–60 minutes. That space gives me the chance to read, reflect, and learn without distractions.</p><h4><strong>5. Share and talk</strong></h4><p>I’m not sure if the quote “If you can’t explain it simply, you don’t understand it well enough” really comes from Albert Einstein or if it’s just one of those myths from the internet but i think it is true. The best way to understand something is to explain it. Write a short post, talk with your colleagues or present a quick demo. Teaching others forces you to deeply understand it.</p><p>At GetAway, we kicked off our AI-Tuesday Brown Bag Lunch a few months ago. It’s a 30 minute open session where everyone is welcome, no matter if you’re in sales, marketing, design, finance, or any other department. We meet to share what we’ve built, discuss experiments that didn’t quite work, and exchange ideas. I’m especially proud of this initiative because it makes AI accessible to everyone. Very soon after the first sessions, people started building their own custom ChatGPT agents or creating n8n workflows to automate daily tasks. And the best part? We also dive into ethical and security topics. People bring questions like “How vulnerable are we to prompt injection?” or “Can I safely connect Outlook to n8n?”. Sparking discussions that help us all learn and grow.</p><p>We also run an AI-Friday within our TPD (Tech, Product and Design) department. These sessions are a bit more technical: every week, someone presents a self selected topic for about 60 minutes. This format gives us the chance to dive deeper, ask detailed questions, and really expand our knowledge together.</p><h3><strong>Final Thoughts</strong></h3><p>The speed of AI isn’t going to slow down, it will probably accelerate even more. But that doesn’t mean we need to burn ourselves out trying to chase every new shiny thing.</p><p>With a bit of focus, some boundaries and a healthy dose of “good enough”, we can stay in the game and still have time for kids, partners, friends and other hobbies.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8fecca1d9fb9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/getaway-group-tech-blog/engineers-in-the-age-of-ais-breakneck-speed-8fecca1d9fb9">Engineers in the Age of AI’s Breakneck Speed</a> was originally published in <a href="https://medium.com/getaway-group-tech-blog">GetAway Group Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inside AI #4: How Neural Networks Learn — Backpropagation and Gradient Descent Explained]]></title>
            <link>https://medium.com/getaway-group-tech-blog/inside-ai-4-how-neural-networks-learn-backpropagation-and-gradient-descent-explained-67301b4c5578?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/67301b4c5578</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Mon, 28 Apr 2025 19:47:49 GMT</pubDate>
            <atom:updated>2025-04-28T19:47:49.016Z</atom:updated>
            <content:encoded><![CDATA[<h3>Inside AI #4: How Neural Networks Learn — Backpropagation and Gradient Descent Explained</h3><p><strong>A weekly series on how AI models really work — from learning to creating.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*hRFc55XSAzIxUqyjrI_AMQ.png" /></figure><p><em>In our last article we explored the core idea that weights and biases control how a neural network responds to data.But a much bigger question is: how do those values actually get learned?</em></p><p><a href="https://medium.com/getaway-group-tech-blog/inside-ai-3-what-are-weights-and-bias-in-a-neuron-969fd38f0fe4">Inside AI #3: What Are Weights and Bias in a Neuron?</a></p><p>In this article, we’ll break down the full learning process of a neuron, step by step, using a simple spam detection example. We’ll show not just what the steps are, but why they’re necessary — and how they fit together.</p><h3>The Learning Goal</h3><p>Imagine you want to train a neural network to detect spam. The input could be how often a certain word like “free” appears in an email. The goal: predict whether the email is spam (1) or not (0).</p><p>We’ll use a single-neuron model (one input, one output) to walk through how learning works in the most minimal case. This is like the “atom” of neural networks — and understanding it is the key to understanding deep learning as a whole.</p><h3>Step 1: Forward Pass</h3><p>Make a prediction based on current knowledge.</p><h4>Why?</h4><p>Before we can know whether the model is right or wrong, we need to make a prediction based on the current weights and bias.</p><h4>What happens?</h4><p>The neuron combines the input with its weight and bias, then runs it through an activation function (sigmoid) to get a probability between 0 and 1.</p><p><strong>Let’s say:</strong></p><ul><li>Input x = 2.0 (e.g. “free” appears twice)</li><li>Initial weight w = 0.5</li><li>Initial bias b = 0.0</li></ul><p><strong>We calculate:</strong></p><blockquote>z = w * x + b = 0.5 * 2.0 + 0.0 = 1.0</blockquote><p><strong>Activation Function (Sigmoid):</strong></p><blockquote>y_pred = 1 / (1 + exp(-z)) ≈ 0.731</blockquote><h4><strong>Conclusion</strong></h4><p>The neuron currently believes there’s a 73.1% chance this email is spam.</p><h3>Step 2: Loss Function</h3><p>Measure how wrong the prediction is.</p><h4>Why?</h4><p>To improve, the model must know how far off its guess was from the truth. The loss quantifies this difference — it’s the feedback signal that tells the model “you’re close” or “way off”.</p><h4>What happens?</h4><p>We use binary cross-entropy, which is well-suited for binary classification problems:</p><blockquote>Loss = — (y * log(y_pred) + (1 — y) * log(1 — y_pred))</blockquote><p>Let’s say the true label is y = 1 (this email is indeed spam):</p><blockquote>Loss = — (1 * log(0.731) + (1–1) * log(1–0.731)) ≈ 0.313</blockquote><h4><strong>Conclusion</strong></h4><p>The prediction wasn’t terrible, but it wasn’t perfect either. The goal now is to reduce this loss.</p><h3>Step 3: Backpropagation</h3><p>Understand which parameters caused the error.</p><h4>Why?</h4><p>If the loss is too high, which weight or bias is to blame? Backpropagation answers that by calculating gradients — how sensitive the loss is to each parameter.</p><h4><strong>What happens?</strong></h4><p>We apply the chain rule to compute how the loss changes with respect to each parameter.</p><blockquote>dz = y_pred — y = 0.731–1 = -0.269</blockquote><blockquote>dw = dz * x = -0.269 * 2.0 = -0.538</blockquote><blockquote>db = dz = -0.269</blockquote><h4>Conclusion</h4><p>The neuron predicted too low (0.731 instead of 1.0). So we need to increase the weight and bias slightly to push the prediction higher.</p><h3>Step 4: Gradient Descent</h3><p>Take a small step in the right direction.</p><h4><strong>Why?</strong></h4><p>Now that we know which way the weights and biases should move to reduce the loss, gradient descent performs the actual update. It adjusts parameters so the model learns.</p><h4><strong>What happens?</strong></h4><p>We subtract a portion of the gradient (scaled by the learning rate) from each parameter.</p><p><strong>Updates with learning rate 0.1:</strong></p><blockquote>w = 0.5–0.1 * (-0.538) = 0.5538</blockquote><blockquote>b = 0.0–0.1 * (-0.269) = 0.0269</blockquote><p>Let’s do one more forward pass with the new values:</p><blockquote>z = 0.5538 * 2.0 + 0.0269 ≈ 1.1345</blockquote><blockquote>y_pred = 1 / (1 + exp(-1.1345)) ≈ 0.757</blockquote><h4>Conclusion</h4><p>The model is now slightly better — it’s nudged in the right direction. This change is small, but if we repeat this process with many examples, the model gets more accurate over time.</p><p>The prediction improved from 73.1% to 75.7% and with more training, it’ll get even closer to 100%.</p><p>This is learning: the model makes predictions, checks how wrong it was, figures out what to change, and improves over time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67301b4c5578" width="1" height="1" alt=""><hr><p><a href="https://medium.com/getaway-group-tech-blog/inside-ai-4-how-neural-networks-learn-backpropagation-and-gradient-descent-explained-67301b4c5578">Inside AI #4: How Neural Networks Learn — Backpropagation and Gradient Descent Explained</a> was originally published in <a href="https://medium.com/getaway-group-tech-blog">GetAway Group Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inside AI #3: What Are Weights and Bias in a Neuron?]]></title>
            <link>https://medium.com/getaway-group-tech-blog/inside-ai-3-what-are-weights-and-bias-in-a-neuron-969fd38f0fe4?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/969fd38f0fe4</guid>
            <category><![CDATA[learning]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[weights-and-biases]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Mon, 14 Apr 2025 06:02:23 GMT</pubDate>
            <atom:updated>2025-04-14T06:02:23.528Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>A weekly series on how AI models really work — from learning to creating.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lY7N8KFfDEnaIj8Zb_FvEQ.png" /></figure><p>In our last article …</p><p><a href="https://medium.com/getaway-group-tech-blog/inside-ai-2-neural-networks-demystified-and-explained-bfec1f4f3add">Inside AI #2: Neural Networks — Demystified and Explained</a></p><p>… we explored the basic concept of a neuron — the building block of neural networks. This time, we’re going a step deeper: Why are two little terms — weights and bias — so essential for artificial intelligence?</p><h3>1. Weights — How Much Does an Input Matter?</h3><p>A neuron takes in one or more inputs, processes them, and produces an output. That output is calculated using this formula:</p><blockquote>z = x1 * w1 + x2 * w2 + … xn + wn + b</blockquote><h4>What is a weight?</h4><p>A weight is a numerical value assigned to each input. It determines how much influence that input has on the neuron’s decision.</p><h4>Example</h4><p>Let’s say we’re training a neuron to classify whether an email is spam. Two possible inputs might be:</p><ul><li>x₁: Does the email contain the word “Free”?</li><li>x₂: Does it have a lot of exclamation marks?</li></ul><p>Let’s assume both inputs are 1 (i.e. “yes”), and the weights are:</p><ul><li>w₁ = 1.5 (the word “Free” is a strong spam signal)</li><li>w₂ = 0.5 (exclamation marks are a weaker signal)</li></ul><p>The weighted sum would be:</p><blockquote>z = (1.5 * 1) + (0.5 * 1) = 2.0</blockquote><p>So, “Free” counts three times more than exclamation marks.</p><h4><strong>Why are weights important?</strong></h4><ul><li>They shape the neuron’s sensitivity to each feature.</li><li>They are the <strong><em>primary thing a neural network learns</em></strong> during training.</li></ul><h3>2: Bias — The Neuron’s Tuning Knob</h3><h4><strong>What is the bias?</strong></h4><p>The bias is an additional number added to the weighted sum. You can think of it as the neuron’s default tendency to fire or not — independent of the inputs.</p><h4><strong>What does the bias actually do?</strong></h4><p>It shifts the threshold at which the neuron activates. Without a bias, a neuron might only activate if the weighted sum equals exactly zero — which is extremely limiting.</p><h4>What Does It Mean for a Neuron to “Fire”?</h4><p>When we say a neuron “fires”, we mean that it produces a strong output — usually a value close to 1.</p><p>In biological neurons, a firing neuron sends an electrical signal. In artificial neurons, it means the activation function outputs a high value, which signals to the next layer: “Yes, this pattern is present.”</p><p>Depending on the activation function:</p><ul><li>If the output is close to <strong>1</strong>, the neuron is considered “active”</li><li>If the output is close to <strong>0</strong>, it’s considered “inactive”</li></ul><h3>Interpreting our Real Example (Spam Classification)</h3><p>Let’s say our spam neuron receives inputs and computes a weighted sum plus bias of:</p><blockquote>z = -0.5</blockquote><p>Now we apply the Sigmoid activation function, which maps any real number to a value between 0 and 1:</p><blockquote>sigma(-0.5) ≈ 0.377</blockquote><p>This means: The neuron is 37.7% “confident” that the email is spam. If the decision threshold is 0.5, this would be interpreted as: Not spam — the neuron is not confident enough to “fire”.</p><p><strong>Summary:</strong></p><ul><li>The output of a neuron is not just “yes” or “no”.</li><li>It’s a probability, and the system decides based on a threshold whether to act on it.</li></ul><h3>How Weights and Bias Work Together</h3><p>Only <strong>together</strong> do weights and bias give the neuron the flexibility to make meaningful decisions.</p><p>In a geometric sense:</p><ul><li>Weights determine the orientation of a decision boundary.</li><li>Bias shifts that boundary left or right, up or down.</li></ul><p>This is critical in classification problems, like distinguishing dogs from cats in images — the data patterns are rarely aligned with the origin.</p><h3>Summary &amp; Final Thoughts</h3><ul><li><strong>Weights</strong> control how much each input affects the output.</li><li><strong>Bias</strong> shifts the neuron’s overall tendency to activate.</li><li><strong>Firing</strong> means the neuron is confident (e.g., output near 1).</li><li>Together, they give neurons the power to recognize patterns and make decisions.</li></ul><p>Understanding weights and bias is key to demystifying how neural networks actually “think.” While these components may seem simple on the surface, they are the core of how machines learn patterns, make predictions, and improve over time.</p><p>Together, weights and bias define how flexible and powerful a neuron can be — and when scaled across thousands or millions of neurons, they allow neural networks to perform everything from spam detection to image recognition and natural language understanding.</p><p>In the next article, we’ll peel back the next layer and explore how these parameters get adjusted during training — through gradient descent, backpropagation, and the optimization process that teaches neural networks to get better with experience.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=969fd38f0fe4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/getaway-group-tech-blog/inside-ai-3-what-are-weights-and-bias-in-a-neuron-969fd38f0fe4">Inside AI #3: What Are Weights and Bias in a Neuron?</a> was originally published in <a href="https://medium.com/getaway-group-tech-blog">GetAway Group Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inside AI #2: Neural Networks — Demystified and Explained]]></title>
            <link>https://medium.com/getaway-group-tech-blog/inside-ai-2-neural-networks-demystified-and-explained-bfec1f4f3add?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/bfec1f4f3add</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[neural-networks]]></category>
            <category><![CDATA[travel-technology]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Tue, 08 Apr 2025 06:01:38 GMT</pubDate>
            <atom:updated>2025-04-08T16:11:09.145Z</atom:updated>
            <content:encoded><![CDATA[<h3>Inside AI #2: <strong>Inside a Single Neuron: The Building Block of AI</strong></h3><p><strong>A weekly series on how AI models really work — from learning to creating.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Mx-1FN4FnJ1Xvr6y" /><figcaption>Photo by <a href="https://unsplash.com/@alinnnaaaa?utm_source=medium&amp;utm_medium=referral">Alina Grubnyak</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><em>In the first article, we explored how Generative AI differs from traditional Machine Learning:</em></p><p><a href="https://medium.com/getaway-group-tech-blog/inside-ai-1-generative-ai-vs-traditional-machine-learning-c4530c95b8d1">Inside AI #1: Generative AI vs. Traditional Machine Learning</a></p><p>Today, we want to talk about neurons in neural networks — a term most people have heard, especially in recent years with the rise of AI. But what <em>is</em> a neuron, really?</p><p>Artificial intelligence and neural networks often seem like magical black boxes that somehow transform raw data into meaningful insights. But behind the curtain, there’s no magic — just math and clever optimization. In this article, we’ll pull back the curtain and explain what really happens inside a single neuron.</p><h3>A Neuron is just a calculator</h3><p>No intelligence, no magic — just addition and multiplication.</p><p>A neuron in a neural network isn’t a thinking entity. It doesn’t understand, reason, or make decisions. It simply performs a mathematical operation: it takes input values, multiplies each by a weight, adds them up, and includes a bias term. The result is then passed through an <em>activation function</em>, which determines how strongly the signal should be passed along.</p><p>The core formula is:</p><blockquote>z = x1 * w1 + x2 * w2 + … xn + wn + b</blockquote><ul><li>x: Input value — Raw data fed into the network.</li><li>w: Weight — A parameter adjusted during training to influence how important an input is.</li><li>b: Bias — A value that helps shift the function output independently of the input.</li></ul><p>The output <strong>z</strong> is called the <em>pre-activation output</em> — it represents how “activated” the neuron is, before any non-linear transformation.</p><h3>What goes into a neural network?</h3><p>Before we go deeper into what a neuron does, let’s take a step back:</p><p>What kind of data does a neural network actually process?</p><p>Neural networks don’t usually work directly with raw physical units like “60% humidity” or “800 W/m² of sunlight.” Instead, the data is <em>scaled</em> or <em>normalized</em>, often into a range between 0 and 1.</p><p>For example:</p><ul><li>A sunlight value of 0.8 might represent 800 W/m², if 1000 W/m² is the maximum observed in the dataset.</li><li>A humidity input of 0.6 would represent 60% relative humidity.</li></ul><p>This scaling makes training more stable and ensures that all inputs contribute proportionally.</p><h4><strong>Practical Example: Predicting Temperature</strong></h4><p>Let’s say we want to predict temperature based on humidity and sunlight:</p><ul><li>Input: [0.6, 0.8] → 60% humidity, 80% of maximum sunlight</li></ul><p>These aren’t raw physical values like “60%” or “800 W/m²”, but scaled inputs.</p><p>In machine learning, we often normalize features to fall between 0 and 1.</p><p>So, 0.8 sunlight just means 80% of the max sunlight observed in the dataset.</p><ul><li>Weights: [0.2, 0.4]</li><li>Bias: 0.1</li></ul><p>Calculation:</p><blockquote>z = (0.6 * 0.2) + (0.8 * 0.4) + 0.1 <br> = 0.12 + 0.32 + 0.1 = 0.54</blockquote><p>What does the result 0.54 mean?</p><p>For example, If the model was trained with an output range from 0 to 40°C, then:</p><blockquote>0.54 * 40 = 21.6°C</blockquote><p>If the model were trained for classification instead — for example, to answer the question <em>“Is it a hot day?”</em> — we’d apply a sigmoid activation function to interpret the result as a probability:</p><blockquote>sigma(0.54) ≈ 0.63</blockquote><p>That means a 63% chance it’s a hot day.</p><p>In an upcoming article, we’ll dive deeper into the role of weights and biases: how they’re learned, why they matter, and how they shape the behavior of a neural network.</p><h3>From Simple Math to Smart Behavior</h3><p>At this point, you might be thinking: <em>“Wait, that’s it?”</em></p><p>Just some inputs, weights, a bias, and a bit of multiplication?</p><p>Exactly. And that’s what makes it so interesting.</p><p>The real magic doesn’t come from the individual neuron, but from how millions or even billions of them are connected and trained together. Each one does something simple, but together they form patterns, hierarchies, and ultimately, <em>intelligent behavior</em>.</p><p>Of course, we’ve only scratched the surface here. In an upcoming article, we’ll dive deeper into the role of weights and biases — how they’re learned, why they matter, and how they shape the behavior of a neural network.</p><h3>Final Thoughts: It’s Simple — and Still Remarkable</h3><p>In this series, we’re aiming to make the core ideas of AI more accessible. And sometimes, that means intentionally simplifying things.</p><p>Because yes, a neuron in a neural network is, at its core, just a basic calculator. No intelligence. No awareness. Just weighted sums, biases, and some math.</p><p>Still, as I wrap up this article, I can’t help but feel a little bit of discomfort. Not because anything we’ve said is wrong. But saying a neuron is just math is like saying a novel is just letters and punctuation. Technically true. But it misses the point.</p><p>What makes today’s AI so impressive isn’t the math alone — it’s the vision, creativity, and relentless effort of the people who made it work.</p><p>Because when billions of these simple neurons are connected, trained, and fine-tuned with purpose, something truly powerful emerges.</p><p><strong>So yes, it’s simple. But don’t mistake that for ordinary.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfec1f4f3add" width="1" height="1" alt=""><hr><p><a href="https://medium.com/getaway-group-tech-blog/inside-ai-2-neural-networks-demystified-and-explained-bfec1f4f3add">Inside AI #2: Neural Networks — Demystified and Explained</a> was originally published in <a href="https://medium.com/getaway-group-tech-blog">GetAway Group Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inside AI #1: Generative AI vs. Traditional Machine Learning]]></title>
            <link>https://medium.com/getaway-group-tech-blog/inside-ai-1-generative-ai-vs-traditional-machine-learning-c4530c95b8d1?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4530c95b8d1</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[learning]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Tue, 01 Apr 2025 06:02:07 GMT</pubDate>
            <atom:updated>2025-04-01T06:02:07.907Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>A weekly series on how AI models really work — from learning to creating.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wbfB0TNhIypTBpcVyAzdhA.jpeg" /></figure><p>We’re excited to kick off this new article series on the fundamentals of Artificial Intelligence!</p><p>The goal? To provide anyone — whether you’re a developer, product manager, analyst, or just curious — with a clear and structured way to understand what’s really going on behind the scenes in AI. What do all those buzzwords actually mean? How do the models work? And why does any of it matter? We don’t yet know how many parts there will be — but we’re aiming to release a new article every week.</p><p>Step by step, we’ll break down how AI works, how different types of models behave, and how to make sense of the fast-moving AI landscape we live in.</p><p>This is the first article in the series so let’s start with the foundation:</p><p><strong>What is Generative AI, and how does it differ from traditional machine learning models?</strong></p><h3><strong>1. Traditional Machine Learning: Learning to Predict</strong></h3><p>Traditional machine learning is all about using data to make predictions or find patterns. Most models in this space fall into three main categories:</p><ul><li><strong>Supervised learning</strong> (with labeled data)</li><li><strong>Unsupervised learning</strong> (with unlabeled data)</li><li><strong>Reinforcement learning</strong> (learning through feedback from actions)</li></ul><p>Let’s take a closer look at each.</p><h4>1.1 Supervised Learning</h4><p>In supervised learning, a model is trained on data that includes both inputs and the correct outputs. Think of it as learning by example.</p><p>For instance, you might train a model on emails that are already labeled as either “spam” or “not spam.” Over time, the model learns how to classify new emails based on the patterns it has seen.</p><p>Common use cases include:</p><ul><li>Spam detection</li><li>House price prediction</li><li>Sentiment analysis</li></ul><p>Supervised models can be either:</p><ul><li><strong>Discriminative</strong>: Focused on mapping input to a label (e.g. “is this email spam?”)</li><li><strong>Generative</strong>: Rare, but possible — for instance, some models learn how the data and labels are jointly distributed.</li></ul><p>We’ll dive deeper into the difference between discriminative and generative models in Section 3.</p><h4>1.2 <strong>Unsupervised Learning</strong></h4><p>Unsupervised learning works without labeled data. The model tries to discover patterns, clusters, or structures in the data on its own.</p><p>Examples:</p><ul><li>Grouping customers by behavior (clustering)</li><li>Detecting anomalies in system logs</li><li>Reducing data complexity (dimensionality reduction)</li></ul><h4>1.3 Reinforcement Learning</h4><p>Reinforcement learning is a different paradigm entirely.</p><p>Here, models learn by interacting with an environment and receiving feedback in the form of rewards or penalties.</p><p>This is how systems like AlphaGo or self-driving cars learn: by trying actions, seeing the results, and adjusting over time to maximize success.</p><h3>2. Discriminative vs. Generative Models</h3><p>Beyond the basic types of learning (supervised, unsupervised, reinforcement), another important distinction is between <strong>discriminative</strong> and <strong>generative</strong> models.</p><p>This isn’t a type of learning on its own — it’s more about <em>how</em> a model learns to represent data, and what it’s ultimately designed to do.</p><h4>2.1 Discriminative Models: Focused on Decisions</h4><p>Discriminative models are trained to tell the difference between categories or outcomes. Their goal is to make the best possible prediction based on the input.</p><p>They learn the direct relationship between inputs (like text, images, or numbers) and labels (like spam or not spam, dog or cat).</p><p>They don’t try to model the data itself — just the boundary between classes.</p><h4>2.2 Generative Models: Focused on Creation</h4><p>In contrast, generative models try to understand the structure of the data itself — including how data points relate to each other.</p><p>They’re not just asking “What is this?” but also:</p><ul><li>“What else could look like this?”</li><li>“What would be a plausible continuation?”</li><li>“How could I recreate something similar from scratch?”</li></ul><p>They’re capable of <strong>creating new outputs</strong> that resemble the data they were trained on — such as generating text, images, music, or code.</p><h3>3. Generative AI: Learning to Create</h3><p>This is where things get more creative. While traditional models are focused on identifying, predicting, or classifying, <strong>generative models are designed to create</strong>.</p><p>They don’t just analyze data — they learn its structure and style so they can produce entirely new content. That could mean writing an article, generating a realistic image, composing music, or even coding.</p><h4>3.1 What Generative Models Learn</h4><p>Generative models learn to understand the underlying patterns in data — not just how to recognize it, but how to recreate something that <em>looks, sounds, or reads</em> like it belongs in the same world.</p><p>Rather than asking, “What is this?” they learn to answer questions like:</p><ul><li>“What might come next in this sentence?”</li><li>“What would an image in this style look like?”</li><li>“How would a human continue this line of code?”</li></ul><h4>3.2 <strong>How They Work</strong></h4><p>Generative models are usually trained on massive datasets. They analyze thousands or millions of examples to learn the “rules” of how language, images, or other data types are structured.</p><p>Once trained, they can generate new outputs one element at a time — a word, a pixel, a note — based on everything they’ve seen before.</p><p>For example, if you give a language model the prompt:</p><blockquote><em>“Once upon a time,”</em></blockquote><blockquote><em>it might continue with:</em></blockquote><blockquote><em>“there was a robot who dreamed of learning Python.”</em></blockquote><p>This technique is called <strong>autoregressive generation</strong> — predicting each next piece based on what came before.</p><h3>4. Generative vs. Discriminative — Key Differences</h3><p>Let’s break down the core differences in plain text:</p><ul><li><strong>Discriminative models</strong> predict labels. They are used for tasks like classification and regression. Their strength lies in precision and efficiency.</li><li><strong>Generative models</strong> create data. They can produce text, images, audio, and more. Their strength lies in creativity, flexibility, and versatility.</li></ul><p>Discriminative models are trained on labeled data and aim to answer: <strong>“What is this?”</strong></p><p>Generative models are trained to understand the distribution of data and aim to answer: <strong>“What comes next?” or “What would something like this look like?”</strong></p><h3>5. When to Use What?</h3><p>Use a <strong>discriminative model</strong> when:</p><ul><li>You need a clear yes/no or category classification</li><li>Speed and accuracy are important</li><li>Your data is labeled and structured</li></ul><p>Use a <strong>generative model</strong> when:</p><ul><li>You want to create content (text, images, code, etc.)</li><li>Your task is open-ended or creative</li><li>You want conversational, flexible interfaces</li></ul><h3>6. Wrapping Up</h3><p>AI isn’t just one technology — it’s a toolbox. While generative AI is exciting and powerful, traditional ML approaches are still essential and often more appropriate for focused, structured tasks.</p><p>Understanding the difference between:</p><ul><li>Supervised and unsupervised learning</li><li>Discriminative and generative models</li></ul><p>…helps you make smarter choices when designing intelligent systems.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4530c95b8d1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/getaway-group-tech-blog/inside-ai-1-generative-ai-vs-traditional-machine-learning-c4530c95b8d1">Inside AI #1: Generative AI vs. Traditional Machine Learning</a> was originally published in <a href="https://medium.com/getaway-group-tech-blog">GetAway Group Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Foundation to Testing: Our Journey Toward Better Software]]></title>
            <link>https://medium.com/getaway-group-tech-blog/from-foundation-to-testing-our-journey-toward-better-software-0331c63ae7b7?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/0331c63ae7b7</guid>
            <category><![CDATA[automated-testing]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[testing-strategies]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Mon, 31 Mar 2025 06:52:20 GMT</pubDate>
            <atom:updated>2025-03-31T06:52:20.751Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_ar4jxlzk6VrNmKC" /><figcaption>Photo by <a href="https://unsplash.com/@flowforfrank?utm_source=medium&amp;utm_medium=referral">Ferenc Almasi</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Around two months ago, our CTO opened this blog with a look at our mission here at GetAway. Since then, we’ve shared how we approach things from the ground up, because we’re convinced that building anything great starts with a strong foundation.</p><p>Throughout the series, you’ve seen that we’re not just chasing the next cool feature. In fact, our article on Dependency Containers in Legacy Systems</p><p><a href="https://medium.com/getaway-group-tech-blog/introducing-the-symfony-dependency-injection-container-in-legacy-code-7ea0c2508980">Introducing the Symfony Dependency Injection Container in Legacy Code</a></p><p>showed that we’re also deep in the trenches maintaining and evolving legacy code. And in <em>How We Use Quality Tools at GetAway</em>,</p><p><a href="https://medium.com/getaway-group-tech-blog/how-we-use-quality-tools-at-getaway-bcd0698ef066">How we use quality tools at GetAway</a></p><p>we walked through how we keep our code quality high — or push it even higher.</p><p>Once those fundamentals were in place, the next logical step for us was to define a testing strategy. And as we got into it, we realized something unexpected: shaping this process wasn’t just valuable — it was genuinely fun and full of insights.</p><h3>Starting Point: The Need for Clarity</h3><p>It all began with a desire for clarity. Within the team, there were early attempts to introduce integration tests into a few of our applications. Everyone had ideas, there were discussions, Slack threads, and spontaneous proposals — but most of them focused on a single specific use case. It felt like we were circling around the same problem from different angles, without a common direction.</p><p>That’s when we decided to take a step back. We brought together a small group to start thinking more strategically: What kind of testing approach actually fits <em>our</em> systems and needs? What level of coverage makes sense, and where should we draw the line between unit and integration tests?</p><h3>The Process: From Confusion to Clarity</h3><p>As we kicked off our first working session, it didn’t take long for us to realize: we weren’t even speaking the same language. The discussions quickly became intense, not because we fundamentally disagreed — but because we were using the same terms to mean different things.</p><p>What exactly is an integration test? What’s considered a functional test? Everyone had a slightly different understanding. So we hit pause and took a few steps back to align on terminology. That’s the first and perhaps most important tip I can give:</p><blockquote><strong>Start by clarifying your definitions</strong>. Agree on what you mean by <em>unit</em>, <em>integration</em>, and <em>functional</em> tests. Write those definitions down in your documentation and point back to them whenever confusion arises.</blockquote><p>Once we had that common foundation, I brought up the next big topic — and the one I knew would spark debate: <strong>code coverage</strong>.</p><p>At first, we were united in our thinking: <em>“Let’s go for 100% coverage.”</em> But the moment we dug deeper, the real questions started: Should only unit tests count? What about controllers or DTOs with no logic? Are we really writing tests for every getter and setter? Of course, 100% code coverage can even become an obstacle if the tests are poorly written or if the production code lacks quality. That’s why we’ll focus on maintaining a high level of quality from the very beginning — in both our code and our tests.</p><p>The deeper we went, the more detailed and nuanced our conversations became. To avoid further misunderstandings, we took a step that turned out to be incredibly helpful: we switched to a visual approach.</p><p>We created a Miro board with realistic examples based on our architecture. That helped us clearly map out which layers we wanted to test with which types of tests — and in which situations we should mock dependencies.</p><p><strong>Second Tip:</strong></p><blockquote><strong>Use visual tools early</strong>. It helped us tremendously to get everyone on the same page. Later, those diagrams even became part of our documentation — serving as concrete, shared reference points for future discussions.</blockquote><p>When it came to code coverage, we agreed on a structured approach:</p><p>Only <strong>unit tests</strong> would contribute to the coverage measurement for the <strong>core business logic</strong> — the inner layers of our architecture. Meanwhile, the <strong>integration and functional tests</strong> would cover the <strong>system’s entry and exit points</strong>, such as APIs, queues, or external service interfaces. This lets us keep coverage expectations realistic, while still testing the system holistically and with purpose.</p><p>To be clear: we still write integration and functional tests across different layers of the system — but <strong>only</strong> those that validate behavior at the system boundaries are considered in our coverage metrics.</p><h3>Building Consensus: Addressing the Doubts</h3><p>We knew that not everyone would immediately agree with the strategy we had outlined — especially when it came to our approach to test coverage and the balance between test types. Some of the concerns were familiar and expected:</p><ul><li><em>“It takes too much time to write all these tests.”</em></li><li><em>“Tests are only as good as the developer who writes them.”</em></li><li><em>“Every time we change something, we have to update the tests too.”</em></li></ul><p>These arguments are easy to counter once you dig a little deeper:</p><ul><li>Yes, tests take time — but not writing them costs <em>more</em> in the long run through bugs, regressions, and late-night fire drills.</li><li>The “quality of the developer” argument applies to all code — not just tests. That’s why we do code reviews, pair programming, and have guidelines in place.</li><li>Updating tests during refactoring is not a burden — it’s a feature. If a change breaks a test, it’s likely touching important behavior that should be verified.</li></ul><p>That said, let’s be honest: writing good tests <em>does</em> take time. And while we believe it’s time well invested, it’s still a cost that needs to be managed. To avoid test bloat, low-quality coverage, or long-term maintenance headaches, we added a dedicated <strong>Test Maintenance Strategy</strong> alongside our main testing approach.</p><p>This strategy helps us avoid common pitfalls:</p><p><strong>Avoid Flaky Tests</strong></p><p>Flaky tests that randomly pass or fail are frustrating and dangerous.</p><p>We mitigate this by Eliminating race conditions (e.g., database access or time-based logic), ensuring each test runs independently and consistently and choosing the right level of isolation:</p><ul><li>Unit tests mock or stub all dependencies</li><li>Integration tests use real components, but stub external systems</li><li>End-to-end tests use the full stack, stubbing only critical externals (e.g., payment providers)</li></ul><p><strong>No Redundant Tests</strong></p><ul><li>No duplicated assertions across tests</li><li>Each test must have a unique purpose</li><li>Overlapping or duplicate tests are reviewed and removed</li></ul><p><strong>Regular Test Reviews</strong></p><ul><li>Outdated tests are refactored to match new business logic</li><li>Obsolete tests are identified and deleted</li><li>Test quality is discussed during reviews, just like implementation code</li></ul><p><strong>Clean Test Code</strong></p><ul><li>Tests must be just as readable and maintainable as production code</li><li>Descriptive names, clear assertions, and short, focused test cases are key</li></ul><p><strong>And that brings me to the third tip I want to share:</strong></p><blockquote><strong>Treat your test code with the same respect as your production code. </strong>If you neglect your test suite, it will come back to haunt you. But if you give it the same care and attention, it will become your strongest safety net.</blockquote><h3>Outro: Simple by Design</h3><p>In the end, it didn’t take long for us to reach a shared understanding within the team. Sure, our testing strategy might seem simple at first glance — and that’s entirely by design. <em>Keep it simple</em> was our guiding principle from the start.</p><p>We weren’t aiming for a perfect, all-encompassing framework. Our goal was to create a foundation that everyone could agree on, something that gives us direction without overwhelming us with complexity. From there, everything else can evolve naturally over time.</p><p>And that’s exactly what’s happening. The document we created isn’t finished — it’s alive. As new edge cases appear, we’ll discuss them, make decisions, and document them. It’s a growing, adapting guide that reflects our current thinking, not an unchangeable rulebook.</p><p><strong>Fourth and final tip:</strong></p><blockquote><strong>Let the strategy evolve: </strong>Nothing is set in stone. Assumptions made early on might not hold up later, and that’s okay. Encourage the team to challenge decisions, revisit ideas, and iterate together. A strategy that can adapt will always outlast one that tries to be perfect from day one.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0331c63ae7b7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/getaway-group-tech-blog/from-foundation-to-testing-our-journey-toward-better-software-0331c63ae7b7">From Foundation to Testing: Our Journey Toward Better Software</a> was originally published in <a href="https://medium.com/getaway-group-tech-blog">GetAway Group Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Where Are the Women in AI? And Why It’s a Problem]]></title>
            <link>https://medium.com/@jorisvdaalsvoort/where-are-the-women-in-ai-and-why-its-a-problem-bc0294df353f?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc0294df353f</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[women]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Mon, 10 Mar 2025 07:01:43 GMT</pubDate>
            <atom:updated>2025-03-10T07:01:43.563Z</atom:updated>
            <content:encoded><![CDATA[<h3>Women in AI: How Neutral Is Artificial Intelligence Really?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q_FtvERoEvrqsUb1RE17HQ.jpeg" /></figure><p>AI is becoming very important part of our daily lives. I use AI tools such as ChatGPT regularly as an aid to increase efficiency and I always assumed that AI, especially LLMs, are designed to be as neutral as possible.</p><p>But on International Women’s Day, while I was working in my small wood workshop, one thought kept circling in my mind: <strong>“Can an AI truly be neutral if most of its developers are men?”</strong></p><h3>The Invisible Bias in AI</h3><p>Bias in AI doesn’t appear out of nowhere. It starts at the very core:</p><ul><li>Coding and Development: Who writes the code? Who makes the critical decisions about how AI should function?</li><li>Data Selection: What information is used to train AI models?</li><li>Testing and Validation: Who is testing the system, and whose experiences are prioritized?</li></ul><h4>A simple example: speech recognition software</h4><p>Not too long ago these systems struggled to understand female voices as accurately as male voices. Why? Because the training data primarily contained male voices. This is not an isolated case but part of a larger issue in AI development.</p><h3>The Development Process: Who Holds the Power?</h3><p>When the majority of AI developers are men, it of course influences key aspects of development:</p><ul><li>Which questions are considered important? A male-dominated team might not recognize or prioritize gender-specific challenges.</li><li>Which ethical concerns are discussed? Topics like bias and fairness might not be addressed with a diverse perspective.</li><li>How are tests conducted? If mainly men test an AI system, they may overlook issues that affect women differently.</li></ul><h3>Learning from Biased Data</h3><p>AI learns from vast amounts of text — books, academic papers, online articles, and more. However, these sources are not neutral:</p><ul><li>Women are cited less frequently in academic research.</li><li>Historical and literary texts often portray women in stereotypical roles.</li><li>Language itself contains bias — technical professions, for example, are often associated with male pronouns.</li></ul><p>Even an AI trained to be “objective” can unintentionally absorb and reinforce societal biases present in its training data.</p><h3>AI in Action: Who Benefits?</h3><p>Bias doesn’t stop at development. It continues into real-world applications. AI systems optimized mainly for male-centric data and use cases might serve men better than women. This can manifest in various ways:</p><ul><li>Job recommendation algorithms favoring male candidates.</li><li>Medical AI missing gender-specific symptoms in diagnoses.</li><li>AI-generated content reflecting male-dominated narratives.</li></ul><p>If AI is shaping our future, then ensuring diverse representation in its development is not just about fairness, it’s about building better, more effective technology for everyone.</p><h3>Final Thoughts</h3><p>To create truly inclusive AI, we need more women in AI development — not just as users, but as decision-makers. More diverse teams lead to more balanced perspectives, improved technology, and fairer outcomes.</p><p>I think the question is not whether AI is biased, it’s about how we ensure that its future is shaped by diverse voices. Because AI is not just about code and algorithms; it’s about the people behind them. And right now, we need more women in that equation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc0294df353f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Walking Skeletons in Software Architecture]]></title>
            <link>https://medium.com/@jorisvdaalsvoort/walking-skeletons-in-software-architecture-894168276e3f?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/894168276e3f</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Mon, 03 Mar 2025 07:02:54 GMT</pubDate>
            <atom:updated>2025-03-03T07:02:54.651Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FrS-1OVxbykdS8x2rKJGog.jpeg" /></figure><p>I’ve been in software development for over a decade, and if there’s one thing I’ve learned, it’s this: <strong>your architecture will either set you up for success or become your biggest nightmare.</strong></p><blockquote>The <strong>Walking Skeleton </strong>was introduced by Alistair Cockburn in <em>Writing Effective Use Cases</em> (2000), and it’s essentially a <strong>technical proof of concept, </strong>a way to test your architecture before sinking months into development.</blockquote><p>I first heard this term from my Engineering Manager (Rest in peace my friend) when I was a junior developer. At the time I was young and even more impatient then today. I thought, “Why waste time building a ‘skeleton’ instead of jumping straight into features?” I mean, we can fix stuff when it appears, right?</p><p>But as I gained experience, I saw firsthand how this approach <strong>saves teams from massive refactoring disasters</strong>. Helped to communicate within the Team and when it’s kept up to date is an awesome source for documentation.</p><p>A Walking Skeleton <strong>minimizes risk</strong> and lets you <strong>validate assumptions early</strong>, making sure your system can evolve smoothly instead of forcing painful rewrites down the road. Think of software architecture like assembling IKEA furniture without instructions. You can guess how the pieces fit together, but until you start putting them in place, you won’t know for sure.</p><h3>What is a Walking Skeleton?</h3><p>Martin Fowler described the walking skeleton as</p><blockquote>“a minimal implementation of a system that is functional from end to end.”</blockquote><p>It is used to ensure that nobody invests too much time in implementing an architecture based on hypotheses. It should be the <strong>simplest, working version</strong> of your system that implements all major components — UI, backend, database, you name it…</p><p>So instead of spending weeks and months designing, you build something small and functional <strong>right away</strong> to make sure to catch flaws early and iterate efficiently.</p><h3><strong>Why Use a Walking Skeleton?</strong></h3><p>Being wrong and making mistakes is really hard, and even to this day, I struggle with it but it is important to learn from them. However, you don’t want to be wrong when it’s too late. You don’t want your team to invest too much time in implementing a software architecture that you were involved in when it was planned.</p><p>The concept of a walking skeleton helps mitigate these risks because:</p><h4><strong>Early Feedback</strong></h4><p>Developers and stakeholders get <strong>immediate validation</strong> on whether architectural decisions hold up in practice.</p><h4><strong>Risk Mitigation</strong></h4><p>Problems surface early, before they become expensive fixes.</p><h4>Foundation for Continuous Integration</h4><p>Since it runs end to end, a Walking Skeleton is <strong>CI/CD-ready</strong> from the start.</p><h4>Flexibility &amp; Iteration</h4><p>You’re not locked into rigid plans; the system evolves as you refine it.</p><h4>Team Alignment</h4><p><strong>A</strong> running system gives everyone a <strong>shared understanding</strong> of how things are supposed to work — less guessing, fewer misunderstandings.</p><h3>How to Build a Walking Skeleton</h3><p><strong>Initial Planning</strong></p><ul><li>Identify the <strong>core functionality</strong> you need to validate</li><li><strong>Keep it as simple as possible in terms of business value</strong></li></ul><p><strong>Setting Up the Architecture</strong></p><ul><li>Choose a <strong>tech stack</strong> that aligns with the project needs.</li><li>Sketch a high-level <strong>architecture diagram, </strong>just enough to show how components interact.</li><li>Document as much as possible. It doesn’t have to be perfect, but your future self will thank you for it.</li></ul><p><strong>Building the First Functional Slice</strong></p><ul><li>Develop a <strong>basic but working</strong> feature that runs through all layers (UI, backend, database, and any external integrations).</li><li>Ensure <strong>data flows properly</strong> (e.g., an API request hits the backend, queries the database, and returns a response).</li></ul><p><strong>Continuous Integration &amp; Deployment</strong></p><ul><li>Set up <strong>CI/CD pipelines</strong> early — automate builds, testing, and deployment.</li><li>Implement <strong>automated tests</strong> to prevent regressions.</li><li>Deploy to a <strong>test environment</strong> and validate that it actually works.</li></ul><p><strong>Iterative Refinement &amp; Expansion</strong></p><ul><li>Monitor system performance and gather feedback.</li><li>Add features <strong>gradually</strong> while keeping the system stable.</li><li>Continuously <strong>refactor and optimize</strong> as the application grows.</li></ul><h3>Keeping Your Walking Skeleton Alive</h3><p>A Walking Skeleton isn’t just a temporary tool — it should be the <strong>backbone of your development process</strong>. Here’s how to make sure it stays useful:</p><ul><li>Use it as a <strong>blueprint</strong> for future development.</li><li>Keep it <strong>updated</strong> as requirements change.</li><li>Maintain it in the <strong>CI/CD pipeline</strong> to catch issues early.</li><li>Review it regularly to ensure it still aligns with <strong>business goals</strong>.</li></ul><p>When maintained properly, a Walking Skeleton also serves as a <strong>great onboarding tool</strong> for new team members, helping them understand the system’s architecture from day one.</p><h3>Walking Skeleton vs. Minimum Viable Product (MVP)</h3><p>I hear this question <strong>all the time</strong>, so let’s set the record straight:</p><ul><li><strong>A Walking Skeleton</strong> is a <strong>technical proof of concept</strong>, built to validate that all parts of the system work together. It’s minimal in <strong>features</strong> but complete in <strong>architecture</strong>.</li><li><strong>An MVP (Minimum Viable Product)</strong> is a <strong>business-driven</strong> approach — just enough features to be useful to early adopters and gather user feedback.</li></ul><p>A Walking Skeleton typically comes <strong>before</strong> an MVP, ensuring the MVP has a <strong>solid technical foundation</strong> instead of collapsing under its own weight.</p><h3><strong>Final Thoughts</strong></h3><p>A Walking Skeleton is one of the <strong>most valuable techniques</strong> I’ve used to keep projects on track. It prevents <strong>technical debt</strong>, enables <strong>early feedback</strong>, and gives teams a <strong>clear starting point</strong> to build upon. Especially in agile teams and startups, skipping this step can mean the difference between <strong>smooth development</strong> and a <strong>nightmare of constant rewrites</strong>.</p><p>Have you ever built a Walking Skeleton? Or did you learn the hard way why it’s necessary? Drop a comment — I’d love to hear your experiences!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=894168276e3f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hidden Pitfalls: Why empty(), strpos(), and More Are Often Misunderstood]]></title>
            <link>https://medium.com/@jorisvdaalsvoort/the-hidden-pitfalls-why-empty-strpos-and-more-are-often-misunderstood-43800c88be33?source=rss-9170fb52f2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/43800c88be33</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Joris van der Aalsvoort]]></dc:creator>
            <pubDate>Mon, 24 Feb 2025 07:02:17 GMT</pubDate>
            <atom:updated>2025-02-24T07:02:17.137Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v5mA0UaQGSUa47iT2aLxPQ.jpeg" /></figure><p>Have you ever stared at your PHP code, wondering why your carefully crafted logic isn’t working as expected? You double-check your syntax, scan for typos, and yet, something is off. If you’ve ever been betrayed by empty(), left scratching your head over strpos(), or baffled by in_array(), you&#39;re not alone. These functions seem simple on the surface, but their behavior can be deceptive. They lure developers into a false sense of security—only to strike with unexpected results when you least expect it.</p><p>PHP, for all its power and flexibility, has its quirks. And some of the most commonly used functions harbor behaviors that are unintuitive, leading to subtle yet frustrating bugs. empty() might flag a perfectly valid value as &quot;empty,&quot; strpos() can return 0 in ways that break conditionals, and in_array() may lead to loose comparisons that bite back. In this article, we&#39;ll unravel the mystery behind these misunderstood functions, explore why they behave the way they do, and—most importantly—show you how to use them correctly.</p><h3>The empty() Trap</h3><p>empty() is often misunderstood because it doesn&#39;t just check if a variable is set—it also considers a range of values as &quot;empty&quot; that might actually be valid in a given context.</p><h4>Unexpected Behavior</h4><pre>$var = &quot;0&quot;;  <br>if (empty($var)) {  <br>    echo &quot;This is empty!&quot;;<br>}</pre><p>You might expect that since $var contains &quot;0&quot;, it shouldn&#39;t be empty. But PHP considers 0, &quot;0&quot;, false, null, and an empty array ([]) all as &quot;empty&quot; values. This can cause unexpected results, especially when handling user input or form validation.</p><h4>How to Fix It</h4><p>Instead of empty(), use isset() or explicit comparisons:</p><pre>if ($var === &quot;&quot; || $var === null) {  <br>    echo &quot;This is actually empty!&quot;;<br>}</pre><p>Or, if you must use empty(), ensure you check the type before acting on the result.</p><h3>The strpos() Confusion</h3><p>strpos() is used to find the position of a substring inside a string. It returns the index of the first occurrence of the substring or false if not found. The problem? It returns 0 if the substring is found at the very beginning, and since 0 evaluates to false in a conditional statement, it can cause misleading results.</p><h4>Unexpected Behavior</h4><pre>$pos = strpos(&quot;hello world&quot;, &quot;hello&quot;);  <br>if (!$pos) {  <br>    echo &quot;Not found!&quot;;  <br>} else {  <br>    echo &quot;Found at position $pos&quot;;  <br>}</pre><p>Since &quot;hello&quot; starts at position 0, the if (!$pos) condition evaluates to true, and PHP incorrectly assumes &quot;hello&quot; wasn&#39;t found.</p><h4>How to Fix It</h4><p>Always use a strict comparison (!== false) when checking the result of strpos():</p><pre>$pos = strpos(&quot;hello world&quot;, &quot;hello&quot;);  <br>if ($pos !== false) {  <br>    echo &quot;Found at position $pos&quot;;  <br>} else {  <br>    echo &quot;Not found!&quot;;  <br>}</pre><h3>The in_array() Loose Comparison Problem</h3><p>in_array() is another seemingly simple function that can cause trouble due to PHP’s loose comparison rules. By default, in_array() performs type-juggling, which can lead to unexpected matches.</p><h4>Unexpected Behavior</h4><pre>$array = [0, 1, 2];  <br>if (in_array(&quot;0&quot;, $array)) {  <br>    echo &quot;Found!&quot;;<br>}</pre><p>Even though &quot;0&quot; is a string and 0 is an integer, in_array() considers them equivalent because of PHP&#39;s type coercion.</p><h4>How to Fix It</h4><p>Use the strict comparison flag (true as the third argument):</p><pre>if (in_array(&quot;0&quot;, $array, true)) {  <br>    echo &quot;Strict match found!&quot;;<br>} else {  <br>    echo &quot;No match!&quot;;<br>}</pre><p>Now, &quot;0&quot; will not be considered the same as 0, preventing unintended matches.</p><h3>The array_search() Surprise</h3><p>Like strpos(), array_search() returns false when a value isn&#39;t found but also returns 0 if the value is found at the beginning of the array. This can cause misleading results when used in conditions.</p><h4>Unexpected Behavior</h4><pre>$array = [&quot;apple&quot;, &quot;banana&quot;, &quot;cherry&quot;];  <br>$pos = array_search(&quot;apple&quot;, $array);  <br>if (!$pos) {  <br>    echo &quot;Not found!&quot;;  <br>}</pre><p>Since &quot;apple&quot; is at index 0, the condition evaluates to false, leading to incorrect behavior.</p><h4>How to Fix It</h4><p>Use strict comparison:</p><pre>$pos = array_search(&quot;apple&quot;, $array);  <br>if ($pos !== false) {  <br>    echo &quot;Found at position $pos&quot;;  <br>} else {  <br>    echo &quot;Not found!&quot;;  <br>}</pre><h3>Final Thoughts</h3><p>PHP is a powerful language, but its built-in functions often have quirks that can lead to subtle bugs if misunderstood. The best way to avoid these pitfalls is to understand their behavior deeply and use strict comparisons where needed.</p><ul><li>Use isset() or explicit comparisons instead of blindly relying on empty().</li><li>Always check strpos() results using !== false.</li><li>Use in_array() with strict mode to avoid type juggling.</li><li>Be careful with array_search() when handling position checks.</li></ul><p>By mastering these nuances, you’ll write more reliable and bug-free PHP code. Happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43800c88be33" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>