<?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 Mattias Sluis on Medium]]></title>
        <description><![CDATA[Stories by Mattias Sluis on Medium]]></description>
        <link>https://medium.com/@mattias.sluis?source=rss-102c9f4b965d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*qzHZy07eOlyCbGaKLznOHQ.jpeg</url>
            <title>Stories by Mattias Sluis on Medium</title>
            <link>https://medium.com/@mattias.sluis?source=rss-102c9f4b965d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 08:24:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mattias.sluis/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[Left on read: the hidden cost of corporate ghosting]]></title>
            <link>https://medium.com/mattiassluis/left-on-read-the-hidden-cost-of-corporate-ghosting-cfe49d7c5496?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/cfe49d7c5496</guid>
            <category><![CDATA[mental-health]]></category>
            <category><![CDATA[ghosting]]></category>
            <category><![CDATA[work]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Fri, 08 May 2026 13:03:49 GMT</pubDate>
            <atom:updated>2026-05-08T13:04:46.070Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yZPAwI5Cf5hkiYTNryKh-w.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@sxoxm?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Sven Mieke</a> on <a href="https://unsplash.com/photos/a-sign-on-a-brick-wall-Xg2kpP3bomw?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p><strong>Corporate “ghosting” (the sudden, unexplained end of communication), seems to be a growing problem that is not only rude, it is also a massive productivity killer. And I am guilty of it myself.</strong></p><p>As a member of a department that provides a lot of support to a lot of people this is something I encounter a lot: someone asks for help, you provide a potential solution and then… nothing. You never hear if you actually solved the problem. The worst variation? Someone shows up with urgency, a lot of noise, demanding immediate help only to disappear completely when you ask for additional input.</p><p>First and foremost: <strong>this behaviour is unprofessional and rude</strong>. But the impact goes beyond that and on the long run we will pay the price for it. This particularly applies to chat based environments where there is an expectation of quick response. When you ask a question, someone pauses their work, makes time to switch the context and gives you their attention. There is an expectation of interaction and they will not directly get back to their original work. Instead they wait, trying to avoid another context switch, to remain available. Time spent waiting… for nothing.</p><h3>Impact 1: Context switching</h3><p>There is a lot written about <a href="https://www.atlassian.com/work-management/project-management/context-switching">context switching</a> and the impact of it. Some studies suggest that frequent context switching can consume up to 40% of someone’s productive time. Other studies say that it switching takes between 1 minute and more than 2 hours (with an average of <a href="https://dl.acm.org/doi/10.1145/1054972.1055017">25 minutes</a>). This particularly applies to deep knowledge work like software engineers “in the zone”. The more complex (amount of context your brain needs) the work, the longer it takes to switch back. You can imagine how much valuable time we are waisting with this.</p><h3>Impact 2: Work loss</h3><p>Beyond context switching, there’s additional time loss.<br>The first time loss occurs while waiting for a response.<br>The second happens when, driven by a sense of responsibility, we start filling in the gaps ourselves: investigating, finding sources, check monitoring. We might attempt to find the information we need ourselves and move a few steps ahead, anticipating the response. More often than I’d like to admit, I find myself deep down the rabbit hole, only to realise later that it was never needed.</p><h3>Impact 3: Dopamine absence</h3><p>When we invest effort into something, especially helping others, our brain anticipates a reward. Properly answering a question, being found helpful, being part of the solution, these all trigger dopamine. <a href="https://www.health.harvard.edu/mind-and-mood/dopamine-the-pathway-to-pleasure">Dopamine</a> gives us a “high”, that happy feeling of accomplishment. When we get ghosted, our brain expects dopamine to come but it never gets released. This can explain why being ghosted can lead to frustration or other negative emotions. Over time, this creates a bigger issue: we begin to expect ghosting. As a result we may become slower to respond, less engaged or less friendly when approached. This isn’t intentional; it’s simply how our brains adapt.</p><h3>Why are we ghosting?</h3><p>There are likely more negative side effects of ghosting. So why do we do it? Being aware of the problem, I still catch myself ghosting doing it. That tells me it’s rarely intentional. We are all very busy. We juggle multiple tasks, face ever increasing expectations and deal with constant pressure. When work (or life) isn’t the cause of pressure we tend to “self impose” pressure. We want to get (more) things done ourselves. A lot of the stress we experience says a lot about ourselves and in this fast paced world we need to develop the skills to handle it. In that sense, ghosting is often not a choice, it is a symptom. A symptom of people that are overwhelmed, stressed or too busy.</p><blockquote>Feeling overwhelmed or stressed? Make sure to talk about with your manager or friends. There are also a lot of online resources and self-help tools available.</blockquote><h3>Quick fix?</h3><p>I don’t believe there is 1 solution to this, or a quick fix to resolve this. But a bit of awareness and reminding each other can certainly help reduce the impact a bit. Let’s make sure that we value the time of others and be respectful about it no matter how important or urgent your work is. With the nice spring weather, encourage each other to take a break, go for a walk, do some exercise.</p><blockquote><strong>Let’s try to follow this simple rule:</strong> if someone helps you, always close the feedback loop. A simple thumbs up, thank you or “still working on it” makes a big difference.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cfe49d7c5496" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mattiassluis/left-on-read-the-hidden-cost-of-corporate-ghosting-cfe49d7c5496">Left on read: the hidden cost of corporate ghosting</a> was originally published in <a href="https://medium.com/mattiassluis">Mattias Sluis’ blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I would still learn software development if AI would replace all developers next year]]></title>
            <link>https://medium.com/mattiassluis/i-would-still-learn-software-development-if-ai-would-replace-all-developers-next-year-0a6002b1ae5a?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/0a6002b1ae5a</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Thu, 31 Jul 2025 14:39:37 GMT</pubDate>
            <atom:updated>2025-08-12T10:34:21.646Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cqQvLrRBysg8FVyZx8Xb7A.jpeg" /></figure><p>For many years software engineering and computer science were recommended fields of study with a promising career ahead. Lot’s of companies created “bootcamps” and internal “academies” to skip long studies in an attempt to attract more talent and close the gap between demand and availability of software engineers.</p><p>However, when we open popular tech news sites or LinkedIn today, we will be flooded with big headlines: “big tech companies are announcing <a href="https://www.tomtom.com/newsroom/press-releases/earnings-other/29121/tomtom-advances-its-product-led-strategy-and-realigns-its-organization/">large layoffs</a>”, “we should stop <a href="https://x.com/DarkModeDigest/status/1759968681159807210?s=20">learning</a> how to code” and it has become much harder to find a job (especially with the — sometimes ridiculous — high compensations). The reason for it all, you guessed it: AI.</p><p>AI is, supposedly, going to replace our development jobs and many others. We could start a whole debate on the current and future state of AI, LLMs, code assistants and AI agents but enough articles are being written on this topic.</p><h4>Skills vs Code</h4><p>Assuming AI will replace all software developers by next year (or in 10 for that matter). The skills I developed from learning software development have not suddenly become useless. Of course, my knowledge and experience in to writing Python code will not be relevant but it would be foolish to believe that software development is primarily about writing syntactically and functionally correct code. Code is merely the output of our applied skills.</p><p>While building software systems we, often subconsciously, apply a whole spectrum of skills like interpreting language (code, designs, requirements), analysis, math, problem solving, critical- and creative thinking. These skills are not restricted to software development, in fact, we use these skills on a day to day basis in all aspects of our lives.</p><blockquote>My wife would probably tell you that I should apply less “problem solving” and more “active listening”.</blockquote><p>All of these skills (and more) I developed while learning and practicing software development and by staying curious about the technologies I used. This has brought me where I am today, not only in my professional career but also personally.</p><h4>When programming as we know it disappears</h4><p>Change is constant when working with technology. The way we develop software today looks in many ways very different from 10–15 years ago and will look very different in the next decade as well. As developers it means our job changes along with it and we adapt. Like with most new technologies, AI has an exponential effect and change might happen more rapidly than ever before.</p><p>When we adapt, our work changes. We might shift from writing code to reviewing code and maybe to only architecting code. The job might change so much that some developers do not enjoy their field anymore. It has happened in the past and it will continue to happen.</p><p>Thankfully, if the job disappears or if you don’t like it anymore, you developed the skills that allow you to quickly become proficient in a different field. Skills that we learned through programming. So, if I had to start over, I would still learn software development.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0a6002b1ae5a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mattiassluis/i-would-still-learn-software-development-if-ai-would-replace-all-developers-next-year-0a6002b1ae5a">I would still learn software development if AI would replace all developers next year</a> was originally published in <a href="https://medium.com/mattiassluis">Mattias Sluis’ blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop installing patches on your servers]]></title>
            <link>https://medium.com/mattiassluis/stop-installing-patches-on-your-servers-460b2774ca6b?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/460b2774ca6b</guid>
            <category><![CDATA[patching]]></category>
            <category><![CDATA[vulnerability-management]]></category>
            <category><![CDATA[immutable-objects]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Fri, 27 Sep 2024 13:49:07 GMT</pubDate>
            <atom:updated>2024-09-27T13:49:07.992Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pwtM88_xqNibzS6JQLDHjQ.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/ko/@bonniekdesign?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Bonnie Kittle</a> on <a href="https://unsplash.com/photos/MUcxe_wDurE?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p><strong>Yes, you read that right! For once not another reminder on patch management but quite the opposite: a call to stop patching your servers in the cloud, and yes that includes security patches..</strong></p><p>This blog was originally written a year ago and published internally at my work after being triggered by a quick survey that indicated that a lot of teams had a regular task of patch management.</p><blockquote>Before I continue let me explain that this is not for everyone, nor am I suggesting that you stop securing your servers. In most cases my story will be applicable but there are always specific situations where this doesn’t apply. I will address this later in this article as well. Oh and I might be a bit opinionated :)</blockquote><h3>Our pets</h3><p>Public cloud opens a whole new world of possibilities when it comes to running and maintaining our applications. We dropped the traditional VMs in favor of managed services, containers and serverless solutions. But there are also still a lot of use cases where we use VMs to run our apps. When you run your own servers you also have to maintain them and make sure they stay secure (both your application and the OS). Although we run these servers in public cloud we tend to treat them exactly the same as the servers in data centers: as pets.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oniDX8NFn3qBdXQcCTGDwg.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@krista?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Krista Mangulsone</a> on <a href="https://unsplash.com/s/photos/pets?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>When we treat our servers as pets, we create them when we need them and take good care of them. We do our best to keep them alive, clean them up, apply patches and use good CI/CD practices to automatically update the application that is running inside the server. If our application needs to scale we add new servers, install updates and install our application on them using provisioning scripts or by updating our CI/CD to include the new servers as well. This does mean that scaling up takes a decent amount of time.</p><h3>Cattle</h3><p>When we move to cloud we should adopt “cloud native practices” which is a nice term for your Cloud Bingo card and covers a wide variety of practices and vendor promises. In this case I am referring to the part where servers in public cloud are disposable: it is extremely is easy to create and destroy servers at any moment in time. And we should leverage this possibility to our advantage. Instead of maintaining and patching our servers we simply create new servers and dispose the old ones: like cattle.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_JD5m9JmzYxj1ldVwp8Gsg.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/es/@weanimalsmedia?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Jo-Anne McArthur</a> on <a href="https://unsplash.com/s/photos/farm-animals?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>When we take this approach we can leverage a nice set of related practices to take full advantage.</p><h4>Deployment strategies</h4><p>There are several different deployment strategies that can be applied when we replace servers instead of updating them:</p><ul><li><strong>Rolling deployments</strong>: introduce small amounts of new instances at the time and, when those are ready and healthy, dispose a few older instances. Continue this until all server instances have been replaced (and monitor in the mean time for errors in case you need to revert)</li><li><strong>Blue-Green deployments</strong>: create the full set of new servers and, once they are all ready, switch traffic to the new servers. If there are no issues the old servers can be disposed.</li><li><strong>Canary deployments</strong>: before moving to a rolling upgrade first create a few instances and test if there are no errors happening when they accept traffic.</li></ul><p>And of course combinations and variations of the above. You can read more about this in the documentation of <a href="https://docs.aws.amazon.com/whitepapers/latest/introduction-devops-aws/deployment-strategies.html">AWS</a> and <a href="https://learn.microsoft.com/en-us/azure/virtual-machines/linux/tutorial-devops-azure-pipelines-classic">Azure</a>.</p><h4>Immutable images</h4><p>A common practice when configuring a server is to apply updates, install agents (like virusscanners, etc) and install your application. This is a task that can be time consuming if it needs to be done every time a server starts. Because not all servers start at the same time you have the risk of differences between servers (some new patch might have come out).</p><p>A better practice would be to create an image, a snapshot of a fully configured VM, that can then be used to spawn new instances without the need to install anything additionally. Images are immutable so they fit in perfectly with CI/CD, Infrastructure as Code and GitOps practices. This concept has been there for a long time and is used for base VMs on-premise by sysadmins. On public cloud we can do this ourselves and, more importantly, we can automate this.</p><p>You can have a monthly/(bi-)weekly/daily job that creates a new image of your application on a VM (including all the latest security updates) and/or create a new image when you want to release a new version of your application. In case there is an urgent patch required you simply trigger the job to create a new image.</p><p>Pre-build images are significantly faster to start and use for scaling, they provide stability and if something goes wrong on your system you don’t have to do full deployments or have dependency on build systems.</p><p>On AWS you can create <a href="https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/tkv-create-ami-from-instance.html">AMIs</a> and on Azure you can make <a href="https://learn.microsoft.com/en-us/azure/virtual-machines/image-builder-overview?tabs=azure-powershell">VM Images</a>.</p><h3>When not to do this</h3><p>There are always plenty of reasons to not do this. Some, especially vendor delivered, system might not support this way of upgrading systems. Sometimes to scale up or create additional instances we would get stuck because of licenses. In other cases you might be able to apply this partially but still need to deploy your application separately. If your application has complicated upgrade processes that require downtime or manual steps you are also limited.</p><p>So if this is impossible to do, would cause more impact to the customer, or is so much more work to realise that it is not worth the effort: don’t do it, stick to your regular patching methods (but at least try to maximise the automation).</p><p>In a lot of cases it might just require that you change your perspective. Challenge the status quo. You might have to put in the effort for automation or rethink how you build application so you can release without downtime. Moving from click-ops and manual operations to infrastructure as code and full CI/CD can feel especially challenging.</p><p><em>Regardless of what you do, we all have the responsibility to make sure our systems are secure. Also, if you are running containers or serverless, you still need to make sure that your dependencies are up to date. You’d be surprised how often developers build and deploy containers that are running old dependencies.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=460b2774ca6b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mattiassluis/stop-installing-patches-on-your-servers-460b2774ca6b">Stop installing patches on your servers</a> was originally published in <a href="https://medium.com/mattiassluis">Mattias Sluis’ blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting your Terragrunt plans as comment on your pull request in GitHub]]></title>
            <link>https://medium.com/mattiassluis/getting-your-terragrunt-plans-as-comment-on-your-pull-request-in-github-660a29b73457?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/660a29b73457</guid>
            <category><![CDATA[terragrunt]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[terraform]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Fri, 27 Sep 2024 12:51:21 GMT</pubDate>
            <atom:updated>2026-05-08T12:57:14.678Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rJz0MjTUynVwddoGYnI4-Q.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@jan_huber?utm_content=creditCopyText&amp;utm_medium=referral&amp;utm_source=unsplash">Jan Huber</a> on <a href="https://unsplash.com/photos/grayscale-photo-of-trees-and-mountains-JW39Q6WMNdo?utm_content=creditCopyText&amp;utm_medium=referral&amp;utm_source=unsplash">Unsplash</a></figcaption></figure><blockquote>A lot has changed since I initially posted this, most relevant is the <a href="https://github.com/borchero/terraform-plan-comment/releases/tag/v2.6.0">2.6.0 release</a> of Borchero’s terraform-plan-comment action. This resolved the limitations we initially faced. Newer releases of Terragrunt changed certain variables, commands, etc so make sure to check that out.</blockquote><p>I am writing this not because I have a lot of knowledge on Terraform/Terragrunt or GitHub Actions but simply because I wanted the plans from my Terragrunt definitions as comments on my pull request. Sharing this hopefully helps someone else!</p><p>If you are using Terraform/OpenToFu to define your infrastructure and deploy it to multiple places chances are pretty good that you have started using Terragrunt as glue on top, to ease the re-use of modules. If you use GitHub and GitHub actions there is a really nice action on the market place called <a href="https://github.com/marketplace/actions/terraform-plan-comment">Terraform Plan Comment</a> that can read a Terraform plan and write/update a comment on your pull request so you have a nicely formatted overview of the changes that will happen on the environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dzREUzUy19oBCKjFpOIp2A.png" /><figcaption>Example comment to see Terraform changes in your PR (taken from the plugin docs)</figcaption></figure><h4>Terragrunt challenges</h4><p>When using Terragrunt you don’t interact directly with Terraform, instead Terragrunt will perform all the actions for you. In the background it understands which Terraform definitions should be executed and in what order. The “downside” of this, is that you don’t use native Terraform commands and their options and output and working directories might not be exactly where you expect them to be. The relative directory for file locations will be a subfolder of the .terragrunt-cache folder of a definition instead of the current working directory.</p><pre>infrastructure<br> |-- modules  # terraform modules<br> |   |-- database<br> |        |-- inputs.tf<br> |        |-- main.tf<br> |        |-- outputs.tf<br> |-- staging  # staging env<br> |    |-- database<br> |        |-- .terragrunt-cache<br> |        |     |-- &lt;random-id&gt;<br> |        |          |-- &lt;other-id&gt;  # &lt;-- is working directory<br> |        |               |-- modules<br> |        |               |-- ...<br> |        |-- terragrunt.hcl<br> |-- prod...</pre><p>While Terragrunt is great, it doesn’t work directly with the terraform-plan-comment action because the plan is placed in a different place by default. Instead the plan is somewhere in .terragrunt-cache/random-id/other-id/.planfile. To fix this you need to be explicit to where the plan needs to be:</p><pre>- name: Plan Terraform<br>  id: plan<br>  shell: bash<br>  run: |<br>    cd &lt;work-dir&gt;<br>    terragrunt plan -out $(pwd)/.planfile<br>    echo &quot;planfile=$(pwd)/.planfile&quot; &gt;&gt; $GITHUB_OUTPUT</pre><ul><li>We use $(pwd) to provide an absolute path for the .planfile</li><li>We save the file location as output for the step so we can refer to it later</li></ul><p>You can then use the terraform-plan-comment action to comment on the PR:</p><pre>- name: Post PR comment<br>  uses: borchero/terraform-plan-comment@v2<br>  env:<br>    TERRAGRUNT_NO_COLOR: 1<br>    TERRAGRUNT_FORWARD_TF_STDOUT: 1<br>  with:<br>    token: ${{ github.token }}<br>    working-directory: &lt;workdir&gt;<br>    planfile: ${{ steps.plan.outputs.planfile }}<br>    terraform-cmd: terragrunt<br>    header: &quot;Terraform Plan for &lt;resource&gt;&quot;</pre><p>The important things to note here:</p><ul><li>The terraform-plan-comment action will execute additional terraform commands to interpret the changes and you have no control over them.</li><li>Terragrunt does some additional formatting (especially since <a href="https://github.com/gruntwork-io/terragrunt/releases/tag/v0.67.5">0.67.5</a>) that would mess up the output to stdout. To prevent this we add the TERRAGRUNT environment variables as alternative to passing the flags to the command.</li><li>The header needs to be specific, the action will use it as unique item to update the comment if the pull request is updated</li></ul><h4>Creating a composite action for reusability</h4><p>Now these steps together need to be executed for each resource of an environment which is why we should combine them into a composite action (placed in your .github/actions/terragrunt-plan-comment/action.yml):</p><pre># .github/actions/terragrunt-plan-comment/action.yml<br>name: Terragrunt Plan with Comment<br>description: Plan the Terraform changes and post a comment on the PR<br><br>inputs:<br>  workdir:<br>    description: &#39;Working directory&#39;<br>    required: true<br>    type: &#39;string&#39;<br><br>runs:<br>  using: &quot;composite&quot;<br>  steps:<br>    - name: Plan Terraform<br>      id: plan<br>      shell: bash<br>      run: |<br>        cd ${{ inputs.workdir }}<br>        terragrunt plan -out $(pwd)/.planfile<br>        # The planfile location must be specific because terragrunt prefers to drop it in the .terragrunt-cache directory<br>        echo &quot;planfile=$(pwd)/.planfile&quot; &gt;&gt; $GITHUB_OUTPUT<br><br>    - name: Post PR comment<br>      uses: borchero/terraform-plan-comment@v2<br>      env:<br>        TERRAGRUNT_NO_COLOR: 1<br>        TERRAGRUNT_FORWARD_TF_STDOUT: 1<br>      with:<br>        token: ${{ github.token }}<br>        working-directory: ${{ inputs.workdir }}<br>        planfile: ${{ steps.plan.outputs.planfile }}<br>        terraform-cmd: terragrunt<br>        header: &quot;Terraform Plan for ${{ inputs.workdir }}&quot;</pre><p>We can then use this action in our GitHub workflow like this:</p><pre># .github/workflows/pull_request_infra.yaml<br>name: Pull Request CI for Terraform changes only<br>on:<br>  pull_request:<br>    types: [opened, synchronize, reopened]<br><br>permissions:<br>  contents: read<br>  # We need pull-requests: write to allow the token to write the comments<br>  pull-requests: write <br><br>jobs:<br>  plan-staging:<br>    # We need to plan all resources individually because they each have their own plan to send as comment<br>    name: Plan Terraform Non Prod<br>    container:<br>      image: alpine/terragrunt:tf1.9.5<br>    steps:<br>      - name: Checkout<br>        uses: actions/checkout@v4<br><br>      - name: Plan Terraform Module DB<br>        uses: &#39;./.github/actions/terragrunt-plan-comment&#39;<br>        with:<br>          workdir: infrastructure/staging/database</pre><p>When I implemented this solution both the marketplace action and Terragrunt went through some changes so certain things broke and needed fixing. The alpine/terragrunt image is always using the latest terragrunt versions. It only has tags for specific terraform versions which makes you vulnerable to breaking changes (i.e: today the alpine/terragrunt:tf1.9.5 image might be using terragrunt 0.67.5 and next week that same tag might be updated to use terragrunt 0.69.2). To prevent this you might opt for a a different image or even creating your own.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=660a29b73457" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mattiassluis/getting-your-terragrunt-plans-as-comment-on-your-pull-request-in-github-660a29b73457">Getting your Terragrunt plans as comment on your pull request in GitHub</a> was originally published in <a href="https://medium.com/mattiassluis">Mattias Sluis’ blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I love being a software engineer at D-Nitro]]></title>
            <link>https://medium.com/mattiassluis/why-i-love-being-a-software-engineer-at-d-nitro-6078cb643d45?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/6078cb643d45</guid>
            <category><![CDATA[accelerate]]></category>
            <category><![CDATA[d-nitro]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[developer-experience]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Mon, 26 Sep 2022 13:39:50 GMT</pubDate>
            <atom:updated>2022-09-30T12:49:04.507Z</atom:updated>
            <content:encoded><![CDATA[<p>D-Nitro is a developer productivity and enablement team, we help 2000 other engineers with a team of 5. What’s that like, and what is it really that I do?</p><p><em>Originally published at </em><a href="https://medium.com/kpn-developers/why-i-love-being-a-software-engineer-at-d-nitro-fad593960060?source=your_stories_page-------------------------------------"><em>https://medium.com</em></a><em> on September 26, 2022.</em></p><blockquote>This blog is part of a series of blog posts of my and my team members. Make sure to checkout the posts of my teammates Jevon, Pooja, <a href="https://www.418teapot.net/2022/09/30/life-of-a.html">Alex</a>, <a href="https://medium.com/@anita.bendelja/day-in-the-life-of-software-engineer-d-nitro-wfh-edition-fd15fb730fd9">Anita</a> and <a href="https://medium.com/@bylalafranca/love-being-a-scrum-master-in-d-nitro-80f3dce5b37d">Lais</a>.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*C8WNCNZEswGXdN-v.png" /></figure><p>We started our D-Nitro team 4.5 years ago with the purpose of helping DevOps teams achieve <em>quality at speed</em> by providing tools and guiding them on using these tools. This happened in the middle of our digital transformation as more and more teams started to apply DevOps principles. We were only 5 engineers, public cloud was considered evil and our infra team had just started exploring Kubernetes.</p><p>Fast forward to today and we find 400 applications on public cloud, most of them using Kubernetes and applying CI/CD principles. <br>That doesn’t mean everything is perfect, there is still a lot to improve and many teams still need to make the step to real continuous deployment. There is more than enough left for us to do but what does that look like in practice?</p><blockquote>We want mature DevOps teams that function fully autonomous and have full ownership on everything they build and maintain.</blockquote><p>As a team we agreed to write a series of blogs in an attempt to show what we are doing. “A day in the life”, so to speak, except my days, weeks and even months are so different from each other. So instead of taking a day, let me tell you what things I have been working on.</p><h4>The basics of the team</h4><p>Currently the team consists of 3 seasoned software engineers and 2 amazing young talents that we hope to grow into excellent engineers. As a team we work hybrid and try to come to the office twice a week, on Monday and Thursday, to meet face-to-face. Those are the days to focus on collaboration and connection and we try to be there as much as possible. Of course every day we have our (extended) daily standup where we catch up on tasks as well as on life. We make it a point to prioritise personal and team happiness over anything else. This is also why every week we have an hour dedicated to playing Uno (or games) with snacks. We call this “Jennie’s Hour”, referring to our former team member Jennie who started this tradition. She was the one that showed us the importance of friendship and connection in the team.</p><blockquote>We make it a point to prioritise personal and team happiness over anything else.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-5tnVzdS0w-sO1o2.jpeg" /><figcaption>Team paintball event earlier this year</figcaption></figure><p>We currently practice a combination of Scrum and Kanban which is the result of experimenting on the best way of working for us. Something that needs to be revisited from time to time as the team, the work and our environment changes. This way of working also includes other activities like retrospectives, demo’s and the refinement of tasks/stories. Like with anything we do, we look to continuously improve the way we work so it enables us to be successful.</p><p>As a team we provide services and tools to all other engineers inside the company and this results in questions and other operational tasks like updating infrastructure, etc. At the same time we work on other initiatives including the development of a few application we created. To reduce the distractions we rotate our “Operator of the week”, leaving 1 person dedicated to answer any questions, take meetings and use the remaining time to work on general improvements (ideally to reduce the number of questions and other operational work). This leaves the rest of the team more focus on planned work.</p><blockquote>We look to continuously improve the way we work so it enables us to be successful.</blockquote><h4>Fun Friday</h4><p>The Friday within our department focusses on learning and self development. “Future Fit Friday” and other initiatives within KPN provide courses and workshops both internally and through external educational institutes. We also give each other the space on Friday to work on something different, explore new technologies, build something fun. By exploring and playing we can learn new things and discover if those are relevant to our team or the organisation. We do need to remind each other to do fun things so we don’t get caught up in our tasks. Some of our best and most creative features originate from Fun Friday.</p><h4>The work I do</h4><p>I love doing operations because I get to connect with other engineers, find out what they are struggling with, help them solve problems and teach them better practices. Often we answer the usual questions or help people figure out why their own pipeline is not working. From time to time we give workshops or presentations on solutions or inspire/consult teams with the automation possibilities. The time that I have left I invest in improving our documentation, creating new self service tools or working on new features on our Slack bot “D-3PO” that wanders around our Slack channels to ask clarifying questions and provide answers to common questions so we don’t have to. This gives us space to dive in to deeper issues and make additional improvements. The less others are dependant on us the more autonomy they have, which is what we want: mature DevOps teams that function fully autonomous and have full ownership on everything they build and maintain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/307/0*FbVKTEvhTZyJvaLN.png" /><figcaption>D-3PO gives users quick access to our knowledge base and provides answers to common questions</figcaption></figure><p>When I am not “on Ops”, I usually work on one of the two primary pieces of software we maintain. The Console, our own self service developer portal or Katka, our release orchestration tool. Katka enables teams to do continuous deployment in a way that also complies with the regulations that our organisation has to follow. Katka can save teams several hours a week and encourages teams to release after each merged pull request.</p><p>Our backends are primarily written in Python in a mix of <a href="https://www.djangoproject.com/">Django</a> and <a href="https://docs.aiohttp.org/en/stable/">Aiohttp</a> while we our frontends use <a href="https://vuejs.org/">VueJS</a>. I like the fact that the work is full stack so that we can make our own ideas fully come to life.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2c2M2on4N1lpom6d.png" /><figcaption>Katka, our release orchestration tool, helps to continuous deploy in a compliant way.</figcaption></figure><blockquote>Building Katka is part of the work we do to “close the gap” between the different tools that we use and the processes that we need to follow.</blockquote><p>Building, maintaining and supporting solutions is not very different of course from a regular software development team. The best part of it is the really close feedback loop we have with our engineers. If something is wrong the teams will inform us faster than our monitoring and, them being smart engineers, they usually also know better on how to resolve the issue. They will also be very vocal on the solutions that we create and on what they want.</p><p>Lately I have been also in the business of creating video content. Content that we share regularly we are putting into short, bite-size video’s for people to watch. This gives us an opportunity to spread our knowledge on additional channels and point people to video’s where before we had to give the same presentation again and again. This doesn’t mean I don’t want the conversation with the teams, I do, but if they have seen the basics we can use the conversations and meetings to dive deeper into the matter at hand. I must confess that recording and <em>editing video’s of myself</em> is still very uncomfortable and really stretches me.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7V9yZlif8mSujy1A.png" /><figcaption>A capture of the bumper for our series on DORA</figcaption></figure><h4>Accelerate: Next level promoting and knowledge sharing</h4><p>Everything we build, create or want to see implemented we need to promote. We enable teams but have no authority, we can’t force anything (and we wouldn’t want to if we could). To increase the use and adoption of our solutions we find different, creative ways to spread our message. From being involved in the onboarding program of new engineers to virtual treasure hunts that have people searching all over our infrastructure and documentation.</p><p>At this moment we have the focus on “Accelerate” which is our big internal technology conference. We aim to get 500 of our colleagues together for a day full of inspiration and knowledge sharing. Together with technology partners and vendors that have talks and booths and prizes to win. With multiple keynotes and 25 different breakout sessions from internal and external speakers, we take inspiration and knowledge sharing to the next level.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GKdGo3yioUpgQa5e.png" /><figcaption>Accelerate: for developers, by developers</figcaption></figure><blockquote>Fun Friday: Fridays are to work on something different, explore new technologies, build something fun.</blockquote><h4>What’s love got to do with it</h4><p>As you probably have picked up, my work is extremely diverse. Every day looks different and some days are super inspiring and creative while other days are about hard work and difficult questions. Regardless of the work, I am always surrounded by inspiring, talented people. We have fun together but also support each other when things are though at work and at home. Individual and team happiness is our number one priority which makes the work we do so much more fun. Those people, my teammates, are the best part of D-Nitro.</p><blockquote>We are hiring! If you read the above or the blogs of my teammates and are interested in joining us you are in luck, for the first time in 4,5 years we have a public vacancy so make sure to check it out.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6078cb643d45" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mattiassluis/why-i-love-being-a-software-engineer-at-d-nitro-6078cb643d45">Why I love being a software engineer at D-Nitro</a> was originally published in <a href="https://medium.com/mattiassluis">Mattias Sluis’ blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I love being a software engineer at D-Nitro]]></title>
            <link>https://medium.com/kpn-developers/why-i-love-being-a-software-engineer-at-d-nitro-fad593960060?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/fad593960060</guid>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[d-nitro]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[accelerate]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Mon, 26 Sep 2022 08:26:14 GMT</pubDate>
            <atom:updated>2023-11-03T08:32:42.983Z</atom:updated>
            <content:encoded><![CDATA[<p>D-Nitro is a developer productivity and enablement team, we help 2000 other engineers with a team of 5. What’s that like, and what is it really that I do?</p><blockquote>This blog is part of a series of blog posts of my and my team members. Make sure to checkout the posts of my teammates <a href="https://medium.com/@jevonwirjono/day-in-a-life-as-software-engineer-in-d-nitro-team-b9d39d5cbaef">Jevon</a>, <a href="https://medium.com/@poojaniranjanshetty/my-day-as-software-engineer-trainee-in-d-nitro-team-kpn-5cf0cb569b75">Pooja</a>, <a href="https://www.418teapot.net/2022/09/30/life-of-a.html">Alex</a>, <a href="https://medium.com/@anita.bendelja/day-in-the-life-of-software-engineer-d-nitro-wfh-edition-fd15fb730fd9">Anita</a> and <a href="https://medium.com/@bylalafranca/love-being-a-scrum-master-in-d-nitro-80f3dce5b37d">Lais</a>.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lk6It03Np5AeLZuXSdhwdA.png" /></figure><p>We started our D-Nitro team 4.5 years ago with the purpose of helping DevOps teams achieve <em>quality at speed</em> by providing tools and guiding them on using these tools. This happened in the middle of our digital transformation as more and more teams started to apply DevOps principles. We were only 5 engineers, public cloud was considered evil and our infra team had just started exploring Kubernetes.</p><p>Fast forward to today and we find 400 applications on public cloud, most of them using Kubernetes and applying CI/CD principles. <br>That doesn’t mean everything is perfect, there is still a lot to improve and many teams still need to make the step to real continuous deployment. There is more than enough left for us to do but what does that look like in practice?</p><blockquote>We want mature DevOps teams that function fully autonomous and have full ownership on everything they build and maintain.</blockquote><p>As a team we agreed to write a series of blogs in an attempt to show what we are doing. “A day in the life”, so to speak, except my days, weeks and even months are so different from each other. So instead of taking a day, let me tell you what things I have been working on.</p><h4>The basics of the team</h4><p>Currently the team consists of 3 seasoned software engineers and 2 amazing young talents that we hope to grow into excellent engineers. As a team we work hybrid and try to come to the office twice a week, on Monday and Thursday, to meet face-to-face. Those are the days to focus on collaboration and connection and we try to be there as much as possible. Of course every day we have our (extended) daily standup where we catch up on tasks as well as on life. We make it a point to prioritise personal and team happiness over anything else. This is also why every week we have an hour dedicated to playing Uno (or games) with snacks. We call this “Jennie’s Hour”, referring to our former team member Jennie who started this tradition. She was the one that showed us the importance of friendship and connection in the team.</p><blockquote>We make it a point to prioritise personal and team happiness over anything else.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wjFS2vOoGW8ozJFNjzQ22A.jpeg" /><figcaption>Team paintball event earlier this year</figcaption></figure><p>We currently practice a combination of Scrum and Kanban which is the result of experimenting on the best way of working for us. Something that needs to be revisited from time to time as the team, the work and our environment changes. This way of working also includes other activities like retrospectives, demo’s and the refinement of tasks/stories. Like with anything we do, we look to continuously improve the way we work so it enables us to be successful.</p><p>As a team we provide services and tools to all other engineers inside the company and this results in questions and other operational tasks like updating infrastructure, etc. At the same time we work on other initiatives including the development of a few application we created. To reduce the distractions we rotate our “Operator of the week”, leaving 1 person dedicated to answer any questions, take meetings and use the remaining time to work on general improvements (ideally to reduce the number of questions and other operational work). This leaves the rest of the team more focus on planned work.</p><blockquote>We look to continuously improve the way we work so it enables us to be successful.</blockquote><h4>Fun Friday</h4><p>The Friday within our department focusses on learning and self development. “Future Fit Friday” and other initiatives within KPN provide courses and workshops both internally and through external educational institutes. We also give each other the space on Friday to work on something different, explore new technologies, build something fun. By exploring and playing we can learn new things and discover if those are relevant to our team or the organisation. We do need to remind each other to do fun things so we don’t get caught up in our tasks. Some of our best and most creative features originate from Fun Friday.</p><h4>The work I do</h4><p>I love doing operations because I get to connect with other engineers, find out what they are struggling with, help them solve problems and teach them better practices. Often we answer the usual questions or help people figure out why their own pipeline is not working. From time to time we give workshops or presentations on solutions or inspire/consult teams with the automation possibilities. The time that I have left I invest in improving our documentation, creating new self service tools or working on new features on our Slack bot “D-3PO” that wanders around our Slack channels to ask clarifying questions and provide answers to common questions so we don’t have to. This gives us space to dive in to deeper issues and make additional improvements. The less others are dependant on us the more autonomy they have, which is what we want: mature DevOps teams that function fully autonomous and have full ownership on everything they build and maintain.</p><figure><img alt="An image with the logo of D-3PO and its introduction to users." src="https://cdn-images-1.medium.com/max/307/1*03t4X1JLZTljx7tHSbQZ1Q.png" /><figcaption>D-3PO gives users quick access to our knowledge base and provides answers to common questions</figcaption></figure><p>When I am not “on Ops”, I usually work on one of the two primary pieces of software we maintain. The Console, our own self service developer portal or Katka, our release orchestration tool. Katka enables teams to do continuous deployment in a way that also complies with the regulations that our organisation has to follow. Katka can save teams several hours a week and encourages teams to release after each merged pull request.</p><p>Our backends are primarily written in Python in a mix of <a href="https://www.djangoproject.com/">Django</a> and <a href="https://docs.aiohttp.org/en/stable/">Aiohttp</a> while we our frontends use <a href="https://vuejs.org/">VueJS</a>. I like the fact that the work is full stack so that we can make our own ideas fully come to life.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pXKU0Rvvu-syGlxvhGFthw.png" /><figcaption>Katka, our release orchestration tool, helps to continuous deploy in a compliant way.</figcaption></figure><blockquote>Building Katka is part of the work we do to “close the gap” between the different tools that we use and the processes that we need to follow.</blockquote><p>Building, maintaining and supporting solutions is not very different of course from a regular software development team. The best part of it is the really close feedback loop we have with our engineers. If something is wrong the teams will inform us faster than our monitoring and, them being smart engineers, they usually also know better on how to resolve the issue. They will also be very vocal on the solutions that we create and on what they want.</p><p>Lately I have been also in the business of creating video content. Content that we share regularly we are putting into short, bite-size video’s for people to watch. This gives us an opportunity to spread our knowledge on additional channels and point people to video’s where before we had to give the same presentation again and again. This doesn’t mean I don’t want the conversation with the teams, I do, but if they have seen the basics we can use the conversations and meetings to dive deeper into the matter at hand. I must confess that recording and <em>editing video’s of myself</em> is still very uncomfortable and really stretches me.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5DS-LeSeIH4a_mJB6N0Klg.png" /><figcaption>A capture of the bumper for our series on DORA</figcaption></figure><h4>Accelerate: Next level promoting and knowledge sharing</h4><p>Everything we build, create or want to see implemented we need to promote. We enable teams but have no authority, we can’t force anything (and we wouldn’t want to if we could). To increase the use and adoption of our solutions we find different, creative ways to spread our message. From being involved in the onboarding program of new engineers to virtual treasure hunts that have people searching all over our infrastructure and documentation.</p><p>At this moment we have the focus on “Accelerate” which is our big internal technology conference. We aim to get 500 of our colleagues together for a day full of inspiration and knowledge sharing. Together with technology partners and vendors that have talks and booths and prizes to win. With multiple keynotes and 25 different breakout sessions from internal and external speakers, we take inspiration and knowledge sharing to the next level.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3cedBBRBlRu9VhSGJy6Pfg.png" /><figcaption>Accelerate: for developers, by developers</figcaption></figure><blockquote>Fun Friday: Fridays are to work on something different, explore new technologies, build something fun.</blockquote><h4>What’s love got to do with it</h4><p>As you probably have picked up, my work is extremely diverse. Every day looks different and some days are super inspiring and creative while other days are about hard work and difficult questions. Regardless of the work, I am always surrounded by inspiring, talented people. We have fun together but also support each other when things are though at work and at home. Individual and team happiness is our number one priority which makes the work we do so much more fun. Those people, my teammates, are the best part of D-Nitro.</p><blockquote><a href="https://jobs.kpn.com/nl/nl/job/KPBRNL17099EXTERNALNLNL/DevOps-Engineer-D-Nitro">We are hiring</a>! If you read the above or the blogs of my teammates and are interested in joining us you are in luck, for the first time in 4,5 years we have a <a href="https://jobs.kpn.com/nl/nl/job/KPBRNL17099EXTERNALNLNL/DevOps-Engineer-D-Nitro">public vacancy</a> so make sure to check it out.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fad593960060" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kpn-developers/why-i-love-being-a-software-engineer-at-d-nitro-fad593960060">Why I love being a software engineer at D-Nitro</a> was originally published in <a href="https://medium.com/kpn-developers">KPN Developers Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Goodbye Elements]]></title>
            <link>https://medium.com/@mattias.sluis/goodbye-elements-cb662225204f?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb662225204f</guid>
            <category><![CDATA[goodbye]]></category>
            <category><![CDATA[work]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[elements]]></category>
            <category><![CDATA[growth]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Sun, 31 Oct 2021 19:10:45 GMT</pubDate>
            <atom:updated>2021-10-31T19:10:45.212Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b4I2boWTlHfo_Wa8yL4xEw.jpeg" /><figcaption>Team picture during company weekend in Barcelona</figcaption></figure><p>It was march 2012, nearly 10 years ago, when I joined Elements Interactive. After carefully weighing my different options I felt that Elements’ friendly atmosphere, informal management style and their diverse assortment of clients and projects was a perfect fit for me to continue my career as a software engineer. Back then I was a self proclaimed medior level developer with 2 years experience as a full time software developer and within Elements I found my self surrounded by an amazing mix of peers, young talents and experienced seniors. This turned out to be the perfect incubator environment for me to grow by learning, sharing and leading.</p><p>In the first week I was presented a large design document for a new client project with lots of complex business logic (complexity in such a way that I had to explain it back to the client and others many times). The lead developer threw me in the deep end to see what I would do and what my thoughts were on coming up with a solution. I was somewhat frightened but also directly felt that this company was looking to bring out the best of me, seeing past my layers of insecurities. At the same time I felt the confidence this company showed in me from the start making me feel safe, supported and trusted, knowing I would have others I could lean on and that would back me in case I would mess up. Throughout all my time at Elements I have always felt this support and trust and the challenge to be the become the best version of myself.</p><p>When I joined Elements I was still part time studying for my Bachelor in IT, requiring me to visit college at night several days a week next to doing my full time job. We agreed that Elements would provide me with a thesis project that I could do as part of my job. Elements joined forces with one of their clients and found a great project that made everyone benefit which was so much more empowering than to do some in-house automation project that many of my fellow students had to deal with. Working more directly with and at clients, learning a lot of new technologies and practices probably was one of the best career boosters I have encountered. My thesis project became a great success and we continued my collaboration with the client for another year.</p><p>Up until this point my development always focussed on both frontend and backend projects, usually mixed but then I switched to a new project, backend only. I didn’t think I would last for more than 3 months, thinking I would get bored. When working at a company that serves different clients you never know what kind of work will come your way. Of course Elements only takes projects that matches the capabilities of their engineers but all projects are different just like developers also like different aspects of the work. I would try the project and if it wasn’t making me happy we could always look for a different project to work on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9eUht4vcpkzKHlMd_AmIWg.jpeg" /><figcaption>PyCon US at the Oregon Convention Center</figcaption></figure><p>Fast forward 7 years and I found myself still working for this client. Most years spend on backend development but meanwhile frontend and other non-development work came my way. Even if that didn’t fit the usual work that Elements would offer they supported me in my journey. Helping me find relevant learning to attend, offering coaching and other ways of personal development, always helping me find my next challenge to make me grow. I found myself learning many new skills and discovering new ways to find satisfaction in my work. Encouraging me to visit international conferences I got to travel the world and through their participation in sport events I started to enjoy running, the one activity I still do to not just keep my brain in shape but also physically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*HVpJal2u7DgOFs6ThXaWzQ.jpeg" /><figcaption>Running the Almere City Run with Elements</figcaption></figure><p>Now we are 9.5 years later and the time has come to say goodbye. Sometimes good things come to an end and while I am super excited about what is ahead of me I am also sad to leave Elements behind. This company has played such a vital role in my professional growth but also very much in my personal growth. I like to think that I am a better person now. I feel better, improved my soft skills and for sure have gained a lot more confidence in work and in life. Looking back I am filled with so much gratitude for all the opportunities and trust that has been given to me for all these years.</p><p>Thank you Elements for everything!</p><blockquote>If you are a young developer looking for a place to grow or if you are a seasoned engineer looking to help others grow. In Elements you will find a company with a very diverse and international group of people and cool projects to work on. Providing many opportunities to develop yourself and grow, with leaders and management that wants to help you advance your career while having fun. Check out their recent projects and vacancies as well as their recently updated growth path for engineers: <a href="https://www.elements.nl/">www.elements.nl</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb662225204f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pets to Cattle: writing disposable code]]></title>
            <link>https://medium.com/mattiassluis/pets-to-cattle-writing-disposable-code-1faeda03c45?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/1faeda03c45</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[cattle]]></category>
            <category><![CDATA[quality]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[disposable]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Fri, 26 Jul 2019 14:45:05 GMT</pubDate>
            <atom:updated>2019-07-26T14:45:05.078Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HPRQ0D774Xf5R6O5FigsKQ.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@steve_j?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Steve Johnson</a> on <a href="https://unsplash.com/search/photos/paper-trash?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><h3>The struggle of the past</h3><p>For the longest time developers have been struggling with old technology. We would see great technology developments happen but it would take years before we could actually use it: old browsers held back web development, stable linux packages and long release cycles would keep us from using new versions of languages like Java, Python, PHP. There were work arounds, of course, but sysadmins weren’t to keen on installing custom repo’s or compiling your own binaries and your clients would like to still support the users on Internet Explorer.</p><p>Having overcome technology issues one way or the other our development process faced additional issues: security and QA departments slowed us down with slow processes, extensive but unpredictable testing, false findings and security tests that had you go back to the drawing board after weeks of development.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*acYmw-sLiwDfra_6z3ew7A.png" /><figcaption>Data by <a href="http://gs.statcounter.com/browser-market-share#monthly-200905-201905">StatCounter</a></figcaption></figure><h3>Pets vs Cattle</h3><p>But the world has changed: the rise of Docker, Kubernetes and public cloud have rapidly evolved our infrastructure in recent years. We have created CI/CD processes with automated tests and “shifted left” our security. Browsers are updated automatically and almost everyone has access to the latest and greatest technologies.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*15fi9Es7PNtRRt17Fu1uSw.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@simuradi?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Muradi</a> on <a href="https://unsplash.com/search/photos/cattle?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>If you started working with cloud and/or containers you must have heard about the pets vs cattle analogy. In the past we used to treat our servers and infrastructure as pets: we nurtured it, spend time optimising and treated it with care. Now it is easy to get infrastructure on-demand and we have all the tools to spin up new containers or servers whenever we need to. This is where we change our mindset on infrastructure. If something breaks we can now simply dispose it like cattle and spin up a fresh server or container. It is the old “turning it off and on again” in a new jacket still doing the same old trick.</p><h3>Our pets</h3><p>Back to software development. I like to think that most developers are like me: we care about the code we develop and we treat it like pets. We have high standards on everything around our code when it comes to style, testing and interfaces. We are opinionated and become protective of our ‘pets’. We feel responsible for the quality, flexibility, maintainability, security, performance, how it runs and monitoring.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3YbeIgCYLY67m4eQtZ0Trw.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@nathanhanna?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Nathan Hanna</a> on <a href="https://unsplash.com/search/photos/pet-cuddle?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>But while everything around us develops at high speed we spend a lot of time developing long-living, flexible, high quality applications which, to be honest, are often outdated once they are released (at the very least from a technology perspective). Our applications start to run behind on the innovation on technology and infrastructure and the frameworks we are using are replaced by something more fancy by the time deliver our MVP.</p><p>To keep up with the world we have to change: we need to start treating our <strong>code as cattle</strong> rather than pets.</p><h3>Code as cattle</h3><p>Just like our containers we should consider our code (and applications) as short lived and disposable. Since we are considering it short lived we should re-evaluate our standards. When our code is cattle:</p><ul><li>We write as if our code will only be there for several months instead of years</li><li>We should not spend time in making it pretty (it should still be readable though): prefer scripting over organised code.</li><li>It should do what it needs to do, nothing more or less. There is no need for making this future proof for additional changes or scenario’s</li><li>We need to limit our tests and our test coverage: Focus on testing the public interface (if I enter A do I get B back, rather than unit testing every little detail and scenario).</li><li>We consider monitoring the new testing: test in production using processes like canary testing. Your users will test your code way better than you can write your tests in the first place.</li><li>We write our code in a way that we don’t regret disposing it. (Most of us don’t like our code from a year ago anyway).</li><li>We prefer rewrite/replace over maintenance.</li><li>Consider hard coding more (I am not talking configuration here!) and using less of the fancy design patterns.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m0HePp8iuGN1BHaPWi7dDg.jpeg" /><figcaption>Monitoring is the new testing — Carlos Sanchez @ Accelerate India</figcaption></figure><h4>Bad code?!</h4><p>So am I suggesting to write bad code? No, or not entirely, but I suggest that reevaluate the standards that we have for our code. If you write software for medical appliances you need to use a (significant) higher standard than a “simple” consumer web service. But most of the applications and code I see is closer to the latter than the first so let’s find a new balance.</p><p>I will be honest with you, I have been fighting for high standards, 100% coverage, well tested and smell-free code, it is almost hardwired into my brain. So moving to a more pragmatic way of development goes against a lot of things I have stood for for years. I do believe this is a difficult change for a lot of good developers but I also believe it is a change that is very much needed. We need to move faster, deliver faster, become more “agile”, lower our standards, decrease the “Definition of Done” requirements, stop over-complicating and accept that our code is cattle. Code just needs to do what it needs to do today.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1faeda03c45" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mattiassluis/pets-to-cattle-writing-disposable-code-1faeda03c45">Pets to Cattle: writing disposable code</a> was originally published in <a href="https://medium.com/mattiassluis">Mattias Sluis’ blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Takeaways from DevOps World 2018 — Part II]]></title>
            <link>https://medium.com/elements/takeaways-from-devops-world-2018-part-ii-501dbecb3c80?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/501dbecb3c80</guid>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[groovy]]></category>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[shared-libraries]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Mon, 29 Oct 2018 09:49:00 GMT</pubDate>
            <atom:updated>2018-11-23T13:17:21.835Z</atom:updated>
            <content:encoded><![CDATA[<h3>Takeaways from DevOps World 2018 — Part II</h3><h4>Shared pipeline libraries in Jenkins</h4><p>This is my second post that is inspired by my visit to <a href="https://www.cloudbees.com/devops-world/san-francisco">DevOps World 2018</a>. My <a href="https://medium.com/elements/take-aways-from-devops-world-2018-part-i-e8aac7ec39e8">first post</a> was about continuous deployment (CD) using <a href="https://jenkins.io/">Jenkins</a> and <a href="https://kubernetes.io/">Kubernetes</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*a__WOPlXOv0Y7OtRIGcTNA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/mhUsz2ezlXQ?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Crystal Kwok</a> on <a href="https://unsplash.com/search/photos/pipes?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>One of the recurring topics on DevOps World was the use of <em>shared pipeline libraries</em>. A Jenkins pipeline is a groovy script that defines your Jenkins job. If you don’t know it, <a href="https://jenkins.io/solutions/pipeline/">read about it</a>! It is awesome and an extremely powerful way to define your CI/CD process. Jenkins pipelines have been the preferred way for defining your jobs since the release of Jenkins 2 in 2016.</p><p>Although we used pipelines already, I did not get proper hands-on experience until earlier this year when we started a couple new projects. It didn’t take long until I found myself repeating most of the pipeline code (with minor differences of course) in different projects. For instance, I wrote a <a href="https://gist.github.com/mattiassluis/aafa7ffa8a4b0fe59e86a7169e223da1">80+ lines snippet</a> of Groovy code to determine the new version number which we copy-pasted in all our pipelines. We, obviously, created a ticket on the backlog to create a ‘Jenkins plugin’ that would make this functionality available and shareable.</p><p>I learned that a pipeline library consists of one or more reusable functions and or classes that you can access from your Jenkins pipelines. You can share them by putting them in a Git repository (or something similar). Pipeline libraries were actually exactly what we needed. We can write functions and use them in all our pipelines. Which has many benefits like:</p><ul><li>We have only one place to maintain the code (keeping it <a href="https://en.wikipedia.org/wiki/Don%27t_repeat_yourself">DRY</a>)</li><li>We can share useful functions with other projects, teams and organisations</li><li>Our Jenkins pipelines become shorter and more readable</li></ul><p>This last point was also subject of a talk called “<a href="https://sched.co/F9Nc">Concise Pipelines with Shared Libraries</a>” by Liam Newman. He pointed out that pipelines should be readable by anyone, they should not contain complex Groovy code but only consist of simple steps. He recommended that you put most of your Groovy code into shared libraries even if you don’t need it for sharing, just to simplify your Jenkins pipelines.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7SQew9Kae0avF_QC2gr1tw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-5fuUFqClSc_-1grOZu00A.jpeg" /></figure><p>So how do we create a pipeline library? We create a repository first and in this empty repository we create a folder named vars. Say we want to create a function getLatestTag to get the latest tag on the repository. We will create two files in our vars directory:</p><ol><li><a href="https://github.com/mattiassluis/jenkins-pipeline-library/blob/master/vars/getLatestTag.groovy">getLatestTag.groovy</a> (the groovy file that contains our logic)</li><li><a href="https://github.com/mattiassluis/jenkins-pipeline-library/blob/master/vars/getLatestTag.txt">getLatestTag.txt</a> (the documentation on our function)</li></ol><p>By convention, the filename is what the function name will be. Now, let’s write the logic. In our getLatestTag.groovy we have to define a function named call which is the function that is called when calling getLatestTag from our Jenkinsfile. Let’s look at the definition:</p><pre>def call() {<br> def cmd = &#39;git tag --sort=v:refname | tail -n 1&#39;<br> return sh(returnStdout: true, script: cmd).trim()<br>}</pre><p>It is a very simple shell script that calls git tag and sorts based on version number and it picks the last line. We capture the output by setting returnStdout to true and return whatever the output is.</p><p>In our getLatestTag.txt we write our documentation:</p><blockquote>Function that will get the latest tag from git. Requires tags to be fetched during checkout (this is not Jenkins standard git checkout behaviour).</blockquote><p>That should clear things up (this documentation will become available in the Pipeline Syntax reference inside your Jenkins instance). Now we commit our code and push our commit to the remote repository. To make this function available to our Jenkins pipelines we will have to <a href="https://jenkins.io/doc/book/pipeline/shared-libraries/#global-shared-libraries">configure Jenkins</a> to use our repository as shared library. Make sure to tick the Load implicitly box so we don’t have to do anything special to use our library.</p><p>Now that we have it all configured we can call getLatestTag from anywhere in our Jenkins pipeline:</p><pre>// defined outside the stage so we can use it in other stages<br>def latestTag</pre><pre>node {<br> stage(&#39;Prepare&#39;) {<br> checkout scm<br> latestTag = getLatestTag()<br> }<br>}</pre><p>See also the <a href="https://jenkins.io/doc/book/pipeline/shared-libraries/#global-shared-libraries">official documentation</a> on Shared libraries where they share more possibilities of writing and using shared libraries.</p><p>If you need some inspiration for your library have a look at these public libraries:</p><ul><li><a href="https://github.com/vfarcic/jenkins-shared-libraries">https://github.com/vfarcic/jenkins-shared-libraries</a></li><li><a href="https://github.com/SAP/jenkins-library">https://github.com/SAP/jenkins-library</a></li><li><a href="https://github.com/fabric8io/fabric8-pipeline-library">https://github.com/fabric8io/fabric8-pipeline-library</a></li><li><a href="https://github.com/abnamrocoesd/jenkins-pipeline-library">https://github.com/abnamrocoesd/jenkins-pipeline-library</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=501dbecb3c80" width="1" height="1" alt=""><hr><p><a href="https://medium.com/elements/takeaways-from-devops-world-2018-part-ii-501dbecb3c80">Takeaways from DevOps World 2018 — Part II</a> was originally published in <a href="https://medium.com/elements">Elements blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Takeaways from DevOps World 2018 — part II]]></title>
            <link>https://medium.com/mattiassluis/take-aways-from-devops-world-2018-part-ii-89988a56a3ff?source=rss-102c9f4b965d------2</link>
            <guid isPermaLink="false">https://medium.com/p/89988a56a3ff</guid>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[groovy]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[shared-libraries]]></category>
            <dc:creator><![CDATA[Mattias Sluis]]></dc:creator>
            <pubDate>Fri, 12 Oct 2018 03:49:17 GMT</pubDate>
            <atom:updated>2018-10-17T03:46:12.460Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a__WOPlXOv0Y7OtRIGcTNA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/mhUsz2ezlXQ?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Crystal Kwok</a> on <a href="https://unsplash.com/search/photos/pipes?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><h3>Takeaways from DevOps World 2018 — part II</h3><h4>Shared pipeline libraries in Jenkins</h4><p>This is my second post that is inspired by my visit to DevOps World 2018. My <a href="https://medium.com/mattiassluis/take-aways-from-devops-world-2018-part-i-ba99c4582435">first post</a> was about Continuous Deployment using Jenkins and Kubernetes.</p><p>One of the recurring topics on DevOps World was the use of “shared pipeline libraries”. A Jenkins pipeline is a groovy script that defines your Jenkins job. If you don’t know it, <a href="https://jenkins.io/solutions/pipeline/">read about it</a>! It is awesome and an extremely powerful way to define your CI/CD process. Jenkins pipelines have been the preferred way for defining your jobs since the release of Jenkins 2 in 2016.</p><p>Although we used pipelines already, I did not get proper hands-on experience until earlier this year when we started a couple new projects. It didn’t take long until I found myself repeating most of the pipeline code (with minor differences of course) in different projects. For instance, I wrote a <a href="https://gist.github.com/mattiassluis/aafa7ffa8a4b0fe59e86a7169e223da1">80+ lines snippet</a> of Groovy code to determine the new version number which we copy-pasted in all our pipelines. We, obviously, created a ticket on the backlog to create a ‘Jenkins plugin’ that would make this functionality available and shareable.</p><p>I learned that a pipeline library consists of one or more reusable functions and or classes that you can access from your Jenkins pipelines. You can share them by putting them in a Git repository (or something similar). Pipeline libraries were actually exactly what we needed. We can write functions and use them in all our pipelines. Which has many benefits like:</p><ul><li>We have only 1 place to maintain the code (keeping it DRY)</li><li>We can share useful functions with other projects, teams and organisations</li><li>Our Jenkins pipelines become shorter and more readable</li></ul><p>This last point was also subject of a talk called “<a href="https://sched.co/F9Nc">Concise Pipelines with Shared Libraries</a>” by Liam Newman. He pointed out that pipelines should be readable by anyone, they should not contain complex Groovy code but only consist of simple steps. He recommended that you put most of your Groovy code into shared libraries even if you don’t need it for sharing, just to simplify your Jenkins pipelines.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7SQew9Kae0avF_QC2gr1tw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-5fuUFqClSc_-1grOZu00A.jpeg" /></figure><p>So how do we create a pipeline library? We create a repository first and in this empty repository we create a folder named vars. Say we want to create a function getLatestTag to get the latest tag on the repository. We will create 2 files in our vars directory:</p><ol><li><a href="https://github.com/mattiassluis/jenkins-pipeline-library/blob/master/vars/getLatestTag.groovy">getLatestTag.groovy</a> (the groovy file that contains our logic)</li><li><a href="https://github.com/mattiassluis/jenkins-pipeline-library/blob/master/vars/getLatestTag.txt">getLatestTag.txt</a> (the documentation on our function)</li></ol><p>By convention the filename is what the function name will be. Now, let’s write the logic. In our getLatestTag.groovy we have to define a function named call which is the function that is called when calling getLatestTag from our Jenkinsfile. Let’s look at the definition:</p><pre>def call() {<br>  def cmd = &#39;git tag --sort=v:refname | tail -n 1&#39;<br>  return sh(returnStdout: true, script: cmd).trim()<br>}</pre><p>It is a very simple shell script that calls git tag and sorts based on version number and it picks the last line. We capture the output by setting returnStdout to true and return whatever the output is.</p><p>In our getLatestTag.txt we write our documentation:</p><pre>Function that will get the latest tag from git. Requires tags to be fetched during checkout (this is not Jenkins standard git checkout behaviour).</pre><p>That should clear things up (this documentation will become available in the Pipeline Syntax reference inside your Jenkins instance). Now we commit our code and push our commit to the remote repository. To make this function available to our Jenkins pipelines we will have to <a href="https://jenkins.io/doc/book/pipeline/shared-libraries/#global-shared-libraries">configure Jenkins</a> to use our repository as shared library. Make sure to tick the Load implicitly box so we don’t have to do anything special to use our library.</p><p>Now that we have it all configured we can call getLatestTag from anywhere in our Jenkins pipeline:</p><pre>// defined outside the stage so we can use it in other stages<br>def latestTag</pre><pre>node {<br>  stage(&#39;Prepare&#39;) {<br>    checkout scm<br>    latestTag = getLatestTag()<br>  }<br>}</pre><p>See also the <a href="https://jenkins.io/doc/book/pipeline/shared-libraries/#global-shared-libraries">official documentation</a> on Shared libraries where they share more possibilities of writing and using shared libraries.</p><p>If you need some inspiration for your library have a look at these public libraries:</p><ul><li><a href="https://github.com/vfarcic/jenkins-shared-libraries">https://github.com/vfarcic/jenkins-shared-libraries</a></li><li><a href="https://github.com/SAP/jenkins-library">https://github.com/SAP/jenkins-library</a></li><li><a href="https://github.com/fabric8io/fabric8-pipeline-library">https://github.com/fabric8io/fabric8-pipeline-library</a></li><li><a href="https://github.com/abnamrocoesd/jenkins-pipeline-library">https://github.com/abnamrocoesd/jenkins-pipeline-library</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=89988a56a3ff" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mattiassluis/take-aways-from-devops-world-2018-part-ii-89988a56a3ff">Takeaways from DevOps World 2018 — part II</a> was originally published in <a href="https://medium.com/mattiassluis">Mattias Sluis’ blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>