<?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 Anne-Marie Pritchard on Medium]]></title>
        <description><![CDATA[Stories by Anne-Marie Pritchard on Medium]]></description>
        <link>https://medium.com/@annie_67146?source=rss-183dbf269620------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*18u-WQyS5-DsUQ1b4NzvlA.jpeg</url>
            <title>Stories by Anne-Marie Pritchard on Medium</title>
            <link>https://medium.com/@annie_67146?source=rss-183dbf269620------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 10:44:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@annie_67146/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[Creating accessible reorderable lists in Angular applications]]></title>
            <link>https://medium.com/kudos-engineering/creating-accessible-reorderable-lists-in-angular-applications-8b813e8a00a2?source=rss-183dbf269620------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b813e8a00a2</guid>
            <category><![CDATA[accesibility]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[screen-reader]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Anne-Marie Pritchard]]></dc:creator>
            <pubDate>Mon, 08 Dec 2025 08:56:55 GMT</pubDate>
            <atom:updated>2025-12-08T08:56:55.275Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nskVBAKh70jeqgOEM0853g.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@christinhumephoto?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Christin Hume</a> on <a href="https://unsplash.com/photos/person-sitting-front-of-laptop-mfB1B1s4sMc?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>I recently implemented a list component that lets people use a drag and drop interface to change the order of items in one of our Angular front-end services. The Kudos Engineering team places high importance on making our UI accessible, and I was surprised that even after a fair amount of research I couldn’t find much consensus or guidance on accessible drag and drop. In fact at the time of writing Angular still has <a href="https://github.com/angular/components/issues/25468">an open feature proposal for it, first opened in 2022</a>.</p><p><a href="https://www.darins.page/articles/designing-a-reorderable-list-component">This article by Darin Senneff</a> is the most helpful/comprehensive blog post I found on the topic. Although the code needed to implement the full solution outlined here is extensive, the article provided a lot of inspiration, particularly the idea of offering ‘move up’ and ‘move down’ buttons for each item <em>alongside</em> drag and drop. Users across the board may even prefer to use reorder buttons over drag and drop, especially if they only want to move a few items around, and it is relatively simple to make them accessible.</p><p>Here’s an example of what a drag and drop list with reorder buttons could look like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WJ6bKRux1-v7nlCXJct8sg.png" /></figure><p>Start by implementing your drag-and-drop list using the <a href="https://angular.dev/guide/drag-drop">Angular CDK drag and drop directives</a>. From there, it’s straightforward to get the basic up/down button functionality up and running. If you can access to the parent item of a clicked up/down button and its current position from within your Angular component, you can use the <a href="https://angular.dev/api/cdk/drag-drop/moveItemInArray">moveItemInArray function</a> within the button’s click callback function to move a list item. For accessibility compliance, it’s important to ensure that announcements are given to screen reader users at key moments, and that the list is fully keyboard navigable.</p><h3>Screen reader announcements</h3><p>Screen reader users should be informed when any of the following happen:</p><ol><li>A reorderable item has focus</li><li>A reorder button has focus</li><li>A reorderable item is moved up or down</li></ol><h4><strong>When a reorderable item has focus</strong></h4><p>In my solution, each reorderable item is a list element within an unordered list element that has an aria-label<em>.</em> This is a simplified view of the mark-up (drag and drop is still supported of course, hence the Angular CDK classes on some elements):</p><pre>&lt;ol cdkDropList class=&quot;orderable-list&quot; (cdkDropListDropped)=&quot;drop($event)&quot;&gt;<br> &lt;li<br> attr.aria-label=&quot;{{ item.typeDisplay }}: {{ item.title }}&quot;<br> *ngFor=&quot;let item of orderableList; index as i&quot;<br> cdkDrag<br> tabindex=&quot;0&quot;&gt;<br>   &lt;i class=&quot;fas fa-grip-lines&quot; aria-hidden=&quot;true&quot;&gt;&lt;/i&gt;<br>   &lt;div&gt;<br>   &lt;span class=&quot;item-type&quot;&gt;{{ item.typeDisplay }}&lt;/span&gt;<br>   &lt;div class=&quot;item-name&quot;&gt;{{ item.name }}&lt;/div&gt;<br>   &lt;/div&gt;<br>   &lt;div&gt;<br>   &lt;button<br>   (click)=&quot;moveItemUp($event, item)&quot; tabindex=&quot;0&quot;&gt;<br>   &lt;span class=&quot;sr-only&quot;&gt;Move {{ item.name }} up&lt;/span&gt;<br>   &lt;i class=&quot;icon fas fa-chevron-up&quot; aria-hidden=&quot;true&quot;&gt;&lt;/i&gt;<br>   &lt;/button&gt;<br>   &lt;button (click)=&quot;moveItemDown($event, item)&quot; tabindex=&quot;0&quot;&gt;<br>   &lt;span class=&quot;sr-only&quot;&gt;Move {{ item.name }} down&lt;/span&gt;<br>   &lt;i class=&quot;icon fas fa-chevron-down&quot; aria-hidden=&quot;true&quot;&gt;&lt;/i&gt;<br>   &lt;/button&gt;<br>   &lt;/div&gt;<br> &lt;/li&gt;<br>&lt;/ol&gt;</pre><p>Screen readers consider list elements as part of a ‘group’ and will announce the group item’s name (as per the aria-label value), current position, and the total number of group items, which is all core information.</p><h4><strong>When a reorder button has focus</strong></h4><p>An announcement is given to tell the user what the button does such as: ‘Move [item name] up/down’</p><p>In my case, the styling and mark-up for reorder buttons makes use of a helper to provide an accessible label for the chevron icons, which aren’t informative for screen reader users:</p><pre>&lt;button (click)=&quot;moveItemUp($event, item)&quot; tabindex=&quot;0&quot;&gt;<br>  &lt;span class=&quot;sr-only&quot;&gt;Move {{ item.name }} up&lt;/span&gt;<br>  &lt;i class=&quot;icon fas fa-chevron-up&quot; aria-hidden=&quot;true&quot;&gt;&lt;/i&gt;<br>&lt;/button&gt;</pre><h4><strong>When a reorderable item is moved up or down</strong></h4><p>An announcement is given to tell the user what has happened such as: ‘[item name] moved [up/down] to number [new position]’</p><p>For situations like this when announcements don’t happen as a side effect of the mark-up, you could use the <a href="https://material.angular.dev/cdk/a11y/overview#liveannouncer">LiveAnnouncer</a> provided by the Angular CDK which makes this really easy to achieve in the component logic:</p><pre>this.liveAnnouncer.announce(`${item.name} moved up to number ${nextPosition}`);</pre><h3>Keyboard navigation: Focus management</h3><p>Beyond giving buttons a tabindex of 0 in the mark-up, retaining the expected browser focus when a reorder button is clicked is essential for an acceptable keyboard navigation experience. For example, when an reorder button is clicked we want the focus to remain on the parent item after it has moved. This caught me out as it was not the default behaviour in most browsers and focus would jump to an item elsewhere in the list, throwing the user off. To overcome this, you’ll likely need to restore focus to the item that has moved within the component from within the click callback function. I used the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Event">Event object</a> which is passed as an argument to the callback function (from the component template) to do this:</p><pre>// Within the &#39;up&#39; button callback function<br>const target = event.currentTarget;<br>target.focus();<br><br>setTimeout(() =&gt; {<br>   this.liveAnnouncer.announce(`${item.name} moved up to number ${nextPosition}`);<br>});</pre><p>Any screen reader announcements that are managed within the component (e.g. announcing that a given item has moved) will need to be instigated <strong>after</strong> the element focus is complete otherwise the screen reader will not announce them. To enforce this I call the announce method within a setTimeout function (with no delay parameter) so that it is added to the task queue and runs after the button focus completes.</p><p>Accessibility is of course an extensive topic and I haven’t been able to cover everything (as mentioned, the <a href="https://www.darins.page/articles/designing-a-reorderable-list-component">article by Darin Senneff</a> is very comprehensive), but hopefully I’ve demonstrated that there are simple ways to bolster the accessibility compliance of reorderable lists without too much additional code or mark-up.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b813e8a00a2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kudos-engineering/creating-accessible-reorderable-lists-in-angular-applications-8b813e8a00a2">Creating accessible reorderable lists in Angular applications</a> was originally published in <a href="https://medium.com/kudos-engineering">Kudos Engineering</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 Docker containers to talk to each other in your Google Cloud Build CI/CD pipeline]]></title>
            <link>https://medium.com/kudos-engineering/getting-your-docker-containers-to-talk-to-each-other-in-your-google-cloud-build-ci-cd-pipeline-326025b5c22d?source=rss-183dbf269620------2</link>
            <guid isPermaLink="false">https://medium.com/p/326025b5c22d</guid>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[google-cloud-build]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Anne-Marie Pritchard]]></dc:creator>
            <pubDate>Mon, 26 Jun 2023 10:07:47 GMT</pubDate>
            <atom:updated>2023-06-26T10:07:47.308Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="Golden metal pipes connect softly glowing lightbulbs in an complex, angular network." src="https://cdn-images-1.medium.com/max/1024/1*OSl_ts2W11uJxRUxYPWnzw.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@danedeaner?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Dane Deaner</a> on <a href="https://unsplash.com/s/photos/pipes?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>At Kudos we <a href="https://medium.com/kudos-engineering/how-we-use-google-container-builder-63eeab3eb02b">use Google Cloud Build (GCB)</a> to create build pipelines for our apps and microservices. <a href="https://cloud.google.com/build/docs">GCB pipelines</a> are made up of Docker containers (referred to as ‘build steps’) that can be used to build, test, and deploy applications as part of a continuous integration/continuous delivery (CI/CD) process. This post demonstrates how to create a GCB pipeline that has multiple and concurrently running build steps that can talk to each other on a shared Docker network. We’ll also learn why an awareness of Docker execution models (‘Docker outside of Docker’ vs ‘Docker inside of Docker’) is important to being able to reason about how GCB pipelines behave.</p><p>This example shows a simple <a href="https://go.dev/">Go</a> server being run as a build step, and a later build step making HTTP requests to it to verify that it’s receiving traffic. The Go server (inspired by <a href="https://www.alexedwards.net/blog/an-introduction-to-handlers-and-servemuxes-in-go">Alex Edwards’s post</a>) has one registered route, ‘/health’, which returns ‘OK’ and the current time. It has a Dockerfile so that it can be run as a container in the build pipeline. (By the way, Docker has a <a href="https://docs.docker.com/language/golang/build-images/">great guide</a> on building and running Go containers).</p><h4>Real world application</h4><p>Although the pipeline used here is simplified for the purposes of demonstration, in the real world a similar setup can be used to allow end-to-end testing. For example, you might have an application running as a build step that makes external HTTP service calls as part of its end-to-end test suite, and another build step running API stubs (such as <a href="http://www.mbtest.org/">Mountebank</a> stubs, for example) which would need to receive these requests and return fixed responses for testing.</p><h4>Constructing the Cloud Build pipeline</h4><p>In GCB pipelines, you can run a Docker image as a container directly as a build step, or you can use a Cloud Builder image. <a href="https://cloud.google.com/build/docs/cloud-builders">GCB’s documentation</a> defines Cloud Builder images as ‘<em>Cloud Build/developer community provided container images with common languages and tools installed in them</em>’.</p><p>Pre-built images (ones that are publicly available, such as <a href="https://hub.docker.com/r/curlimages/curl">Curl</a>) are usually ideal for running directly as a build step. We’ll be building the Go server image within the pipeline however, so we’ll need the help of a Cloud builder image. The best one for this purpose is the <a href="https://github.com/GoogleCloudPlatform/cloud-builders/tree/master/docker">Docker Cloud builder image</a>, which can build and run other Docker images using the Docker CLI.</p><p>If the first build step below succeeds, the built Go server image will be run directly as the next build step using the image tag name we gave it:</p><pre>steps:<br>- name: &#39;gcr.io/cloud-builders/docker&#39;<br>  id: &#39;build-server-image&#39;<br>  args:<br>    - build<br>    - --tag=simple-go-server<br>    - &#39;.&#39;<br><br>- name: &#39;simple-go-server&#39;<br>  id: &#39;run-server-image&#39;<br>  waitFor:<br>    - &#39;build-server-image&#39;</pre><p>When we run the Cloud Build pipeline locally, this is the output:</p><pre>Finished Step #0 - &quot;build-server-image&quot;<br>2023/06/08 14:41:12 Step Step #0 - &quot;build-server-image&quot; finished<br>Starting Step #1 - &quot;run-server-image&quot;<br>Step #1 - &quot;run-server-image&quot;: Already have image: simple-go-server<br>Step #1 - &quot;run-server-image&quot;: 2023/06/08 13:41:13 Listening...</pre><p>It seems as though the server is up and running, which is good, but now we want to make sure it’s receiving traffic. In a later build step, a Curl container makes a request to the server’s health endpoint until it gets a success response or exceeds the number of allowed retries. The final build step in the pipeline stops the Go server container so that it isn’t left running when the pipeline finishes.</p><pre>- id: server-ready<br>  name: &#39;curlimages/curl:latest&#39;<br>  waitFor: [&#39;build-server-image&#39;]<br>  args: [<br>    &#39;--retry&#39;, &#39;10&#39;,<br>    &#39;--retry-delay&#39;, &#39;5&#39;,<br>    &#39;--retry-all-errors&#39;,<br>    &#39;localhost:8080/health&#39;<br>  ]<br><br>- id: stop-server<br>  name: &#39;gcr.io/cloud-builders/docker&#39;<br>  waitFor: [&#39;server-ready&#39;]<br>  args: [&#39;stop&#39;, &#39;server&#39;]</pre><p>This doesn’t work, but this isn’t unexpected. In the output below we can see that the Curl container was unable to resolve the Go server’s hostname:</p><pre>Step #2 - &quot;server-ready&quot;: Warning: Problem : timeout. Will retry in 5 seconds. 1 retries left.<br>  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0<br>Step #2 - &quot;server-ready&quot;: curl: (6) Could not resolve host: server<br>Finished Step #2 - &quot;server-ready&quot;<br>2023/06/08 14:50:56 Step Step #2 - &quot;server-ready&quot; finished<br>Finished Step #1 - &quot;run-server-image&quot;<br>2023/06/08 14:50:56 Step Step #1 - &quot;run-server-image&quot; finished<br>2023/06/08 14:50:56 status changed to &quot;ERROR&quot;<br>ERROR<br>ERROR: build step 2 &quot;curlimages/curl:latest&quot; failed: exit status 6<br>2023/06/08 14:50:57 Build finished with ERROR status</pre><p>When GCB runs a build step directly it uses a fixed network configuration for the container. To make sure our server is accessible on the network, we’ll need to:</p><ul><li>Give it a name so that other containers can resolve it via DNS</li><li>Publish the server’s ports so that they’re available outside the container</li></ul><p>Both of these things are possible if we use a Docker Cloud Builder, instead of running the container directly as a build step, because this is the only way we can provide certain <a href="https://docs.docker.com/engine/reference/commandline/run/">Docker run flags </a>to the Docker CLI. This is the updated ‘run-server-image’ step:</p><pre>- name: &#39;gcr.io/cloud-builders/docker&#39;<br>  id: &#39;run-server-image&#39;<br>  waitFor:<br>    - &#39;build-server-image&#39;<br>  args: [<br>    &#39;run&#39;,<br>    &#39;--rm&#39;,<br>    # provide &#39;name&#39; and &#39;publish&#39; flags<br>    &#39;--name&#39;, &#39;server&#39;,<br>    &#39;--publish&#39;, &#39;8080:8080&#39;, <br>    &#39;simple-go-server&#39;<br>  ]</pre><p>Despite the updated Go server configuration, when the pipeline is run again we hit the same problem. What’s going on?</p><h4>Reviewing our mental model of how GCB pipelines work</h4><p>When we imagine how Docker Cloud builders work within a Cloud Build pipeline, we intuitively think of a Docker container (in this case the Go server) running inside of another Docker container (the Docker Cloud Builder), something like:</p><figure><img alt="A diagram showing the Cloud Builder container running on the host machine and the Go server container running inside the Cloud Builder container." src="https://cdn-images-1.medium.com/max/1024/1*m3R7cWFh9UyYeNV4SedsPA.jpeg" /></figure><p>The problem makes a lot more sense when we realise that GCB works using a model called ‘Docker outside of Docker (DooD)’ rather than ‘Docker in Docker (DinD)’. Let’s revise our mental model to look like the following:</p><figure><img alt="A diagram showing the host machine’s docker daemon running the Cloud Builder container and the Go server container as sibling containers." src="https://cdn-images-1.medium.com/max/1024/1*cISp_7ux6bHren33GJKA2g.jpeg" /></figure><p>In the DooD model, the Docker Cloud builder container isn’t running the Go server container within itself using its own docker daemon. Instead it makes a call to the <em>host’s</em> docker daemon and tells it to run the Go server container. As it’s the host’s docker daemon that is responsible for spinning up the Go server container, the Go server is not actually running as a build step but is running<em> as a result</em> of a build step.</p><p>When GCB runs a container as a build step, the fixed network configuration adds it to a network called ‘cloudbuild’. When we run a container using the Cloud Builder container (and the Docker CLI), it gets added to the default ‘bridge’ network. This explains why the other containers can’t talk to the Go server over the cloudbuild network; it’s attached to a completely separate network:</p><figure><img alt="A diagram showing the Docker Cloud builder container and the Curl container running on the cloudbuild network and the Go server container running on the default network. The Curl container is unsuccessfully trying to talk to the Go server." src="https://cdn-images-1.medium.com/max/1024/1*2YxbVL9cRqqC2L7XL-gUZw.jpeg" /></figure><p>Fortunately, the workaround for this is straightforward. We can use the <a href="https://docs.docker.com/engine/reference/commandline/run/#network">Docker run network flag</a> to tell the host’s docker daemon to attach the Go server container to the cloudbuild network instead of the bridge network:</p><pre>- name: &#39;gcr.io/cloud-builders/docker&#39;<br>  id: &#39;run-server-image&#39;<br>  waitFor:<br>    - &#39;build-server-image&#39;<br>  args: [<br>    &#39;run&#39;,<br>    &#39;--rm&#39;,<br>    &#39;--name&#39;, &#39;server&#39;,<br>    &#39;--publish&#39;, &#39;8080:8080&#39;,<br>    &#39;--network&#39;, &#39;cloudbuild&#39;,<br>    &#39;simple-go-server&#39;<br>  ]</pre><p>When the build pipeline is run again, we can see the Curl build step (called ‘server-ready’) is able to resolve the Go server’s hostname and receives a success response when calling the ‘health’ endpoint.</p><pre>Step #2 - &quot;server-ready&quot;: OK: Thu, 08 Jun 2023 15:31:44 UTC<br>Finished Step #2 - &quot;server-ready&quot;<br>2023/06/08 16:31:44 Step Step #2 - &quot;server-ready&quot; finished<br>Starting Step #3 - &quot;stop-server&quot;<br>Step #3 - &quot;stop-server&quot;: Already have image (with digest): gcr.io/cloud-builders/docker<br>Step #3 - &quot;stop-server&quot;: server<br>Finished Step #3 - &quot;stop-server&quot;</pre><p>This seems obvious once you know it, but it can trip you up if you don’t know that GCB uses the DooD model. The final diagram illustrates the Curl build step being able to communicate with the Go server container, now that it’s running on the cloudbuild network.</p><figure><img alt="A diagram showing the Docker Cloud builder container, the Curl container, and the Go server container all running on the clouduild network. The Curl container is making a request to the Go server and getting a success response." src="https://cdn-images-1.medium.com/max/1024/1*y_wPxuunZfOi5lLooU6_rg.jpeg" /></figure><h3>Conclusion</h3><ul><li>Exposing ports and other custom network configurations require running containers manually using the Docker CLI</li><li>When we do that, we don’t benefit from the fixed network configuration used by GCB for containers running as build steps</li><li>We can fix the issue by manually adding our container to the correct network</li><li>Having the right mental model about where the container is running and why helps us to understand and fix issues with sophisticated build pipelines</li></ul><p>It’s also worth noting that the technical issues involved when using DinD within CI/CD pipelines has been discussed and documented over the years (see <a href="https://jpetazzo.github.io/2015/09/03/do-not-use-docker-in-docker-for-ci/">Jérôme Petazzoni’s article</a>). What we’ve been referring to in this post as ‘Docker outside of Docker’ is referred to as ‘Docker socket binding’ or ‘the socket solution’ elsewhere.</p><p>As Jérôme Petazzoni’s article explains, this is because it’s possible to achieve DooD manually by exposing the host’s Docker socket to a container running Docker. As that container has access to the host’s Docker socket it will be able to start up ‘sibling’ containers running outside of itself, and indeed, this is what GCB is doing for us behind the scenes when we use Docker Cloud builders.</p><p>Of course not everyone uses GCB, and CI/CD pipeline tools differ in the ways they use Docker execution models. Some give you the flexibility to choose between DinD and DooD, whereas others run all their build steps in a single virtual machine, rather than as Docker containers. As we’ve seen, being aware of your CI/CD tool’s execution model can be a great help when debugging build pipeline issues.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=326025b5c22d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kudos-engineering/getting-your-docker-containers-to-talk-to-each-other-in-your-google-cloud-build-ci-cd-pipeline-326025b5c22d">Getting your Docker containers to talk to each other in your Google Cloud Build CI/CD pipeline</a> was originally published in <a href="https://medium.com/kudos-engineering">Kudos Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How we approach spikes]]></title>
            <link>https://medium.com/kudos-engineering/how-we-approach-spikes-98b52cd8af6f?source=rss-183dbf269620------2</link>
            <guid isPermaLink="false">https://medium.com/p/98b52cd8af6f</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[kudos]]></category>
            <category><![CDATA[spike]]></category>
            <dc:creator><![CDATA[Anne-Marie Pritchard]]></dc:creator>
            <pubDate>Fri, 08 Mar 2019 08:01:01 GMT</pubDate>
            <atom:updated>2019-03-08T08:01:01.139Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qHl_1aJBhHHG4W5F" /><figcaption>Photo by <a href="https://unsplash.com/@elevatoro?utm_source=medium&amp;utm_medium=referral">Justin Leibow</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>If you have worked according to the agile development methodology then you will most likely already be familiar with spikes. A ‘spike’ can be described as something that requires investigation before it can be estimated and where there is a higher element of unknown complexity relative to other stories. The exact reason behind the descriptive name is matter of opinion but one interpretation is that it is because a spike helps to ‘drive deep into a problem’. This translates to a time-limited and focused period of exploration and experimentation concerning a technology or technique. This may involve writing code, prototyping locally, background research, evaluating products, or a combination of all of these.</p><p>The outcome of a spike may result in code or a process that can be implemented in production but this is not guaranteed. It may simply turn out to be a valuable learning experience or an indication that we need to do something different entirely. In short, spikes allow us to make better informed decisions that benefit us in the long run.</p><h3><strong>Identifying the need for a spike</strong></h3><p>Although generally we aim for a balance of <a href="https://www.pivotaltracker.com/help/articles/adding_stories/#story_types">Features, Chores, and Bugs</a> in our two week sprints, some may be much more spike heavy than others. For example, if a sprint closely precedes the development of a new feature, product, or architectural implementation then it is likely we’ll be working on one or more spikes.</p><p>The need for a spike is usually identified by the team during our sprint planning sessions and engineering team meetings but it might also arise from other discussions. Once agreed, it is added to our <a href="https://medium.com/kudos-engineering/why-we-like-pivotal-tracker-f285d195e936">agile task tool</a> along with a description and a list of starter questions to guide areas of research. We categorise a spike as a chore because this story type does not involve a story point estimate. We’ll also <a href="https://www.pivotaltracker.com/help/articles/tagging_stories_with_labels/">tag it with the label</a> ‘spike’ along with project specific labels to keep track of it and distinguish it from other chores.</p><h3><strong>Allocating work</strong></h3><p>We don’t have any strict rules with regards to allocating work for spikes; every member of the engineering team is eligible to state an interest in or volunteer to work on any spike. We would declare this during our daily stand-up meetings so that everyone is kept informed as to who is doing what. Depending on the nature of the spike we will also decide whether it would be beneficial to split the work or pair on it. Most frequently though, one person will be responsible for undertaking the initial research.</p><h3><strong>Guiding direction and initial research</strong></h3><p>As mentioned above, we have come up with a list of questions that we feel are useful in guiding spike research:</p><p>1. What is the complexity?</p><p>2. What is the latency (to the user)?</p><p>3. How does the user experience differ compared to now?</p><p>4. Is there a skills gap? Have we used this approach before? Are there any documented reports of using this approach?</p><p>5. Is there a cost implication?</p><p>6. Is there a monitoring implication?</p><p>7. Is there an availability implication?</p><p>8. Is there a productivity implication?</p><p>This is usually the starting point for a team member when undertaking a spike. A spike most often involves investigating a number of alternative approaches, methods, or tools so addressing these questions with regards to each one can help us compare them and determine relative strengths, weaknesses, and potential pitfalls. Of course we can and do adapt and extend this question set according to each particular spike.</p><h3><strong>Sharing findings with the rest of the team</strong></h3><p>An important characteristic of a spike is that work on it should be time-limited. Ideally we recommend that the person undertaking the spike report their initial findings to the team after a day or two of focused research. This ensures that work on the spike continues to stay on track and benefits from the feedback and insights of other team members. With this in mind, the person undertaking the spike is responsible for scheduling a team meeting when they are ready to demonstrate or discuss their work so far. Based on this discussion the team will then agree on follow-up actions and decide what the next steps should be.</p><h3><strong>The road to implementation (or not)</strong></h3><p>The initial spike meeting may show that the spike needs more work or iterative discussion. It may be that it allowed us to fail fast (that is, rule out something that is not not viable) or highlight that a completely different approach or line of thinking is needed. If this is the case a follow-up meeting will be scheduled to review the existing spike or a new spike may be created if parameters have changed significantly. On the other hand, it may be possible to commit to a particular approach or to using a particular tool. In this case, the team will then discuss how best to break up the spike into stories that can be estimated and added to future sprints with a view to implementation. Regardless of the outcome the time we take to invest in spikes is always valuable.</p><h3><strong>Examples</strong></h3><p>Here are some examples of previous spikes that did make it to implementation and became great Kudos Engineering blog posts:</p><p><a href="https://medium.com/kudos-engineering/choosing-the-elastic-stack-as-a-time-series-database-9fac202c53ba">Choosing the elastic stack as a time series database</a></p><p><a href="https://medium.com/kudos-engineering/converting-aws-lambdas-from-apex-to-native-go-baf9a6e7cf5">Converting AWS lambdas from Apex to native Go</a></p><p><a href="https://medium.com/kudos-engineering/secret-management-in-kubernetes-and-gcp-the-journey-c76da8de96d8">Secret management in Kubernetes and GCP, the journey</a></p><p><em>If you like what you read and think you could contribute to our team at </em><a href="https://www.growkudos.com/"><em>Kudos</em></a><em> then take a look at </em><a href="https://www.growkudos.com/about/careers"><em>our careers page</em></a><em> to see what roles we currently have open.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98b52cd8af6f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kudos-engineering/how-we-approach-spikes-98b52cd8af6f">How we approach spikes</a> was originally published in <a href="https://medium.com/kudos-engineering">Kudos Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>