<?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 Lamak Qaizar on Medium]]></title>
        <description><![CDATA[Stories by Lamak Qaizar on Medium]]></description>
        <link>https://medium.com/@lamak-qaizar?source=rss-c016b9a3b681------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*nYYVbWOtEh5SFthc5Uvozg.jpeg</url>
            <title>Stories by Lamak Qaizar on Medium</title>
            <link>https://medium.com/@lamak-qaizar?source=rss-c016b9a3b681------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 18:48:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@lamak-qaizar/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[How to Prioritise “Engineering Work” in Product Teams]]></title>
            <link>https://medium.com/bazaar-tech/how-to-prioritise-technical-improvements-in-product-teams-da91e9a04156?source=rss-c016b9a3b681------2</link>
            <guid isPermaLink="false">https://medium.com/p/da91e9a04156</guid>
            <category><![CDATA[prioritization]]></category>
            <category><![CDATA[technical-debt]]></category>
            <dc:creator><![CDATA[Lamak Qaizar]]></dc:creator>
            <pubDate>Sun, 02 Oct 2022 05:39:51 GMT</pubDate>
            <atom:updated>2022-11-10T13:03:36.603Z</atom:updated>
            <content:encoded><![CDATA[<p>Are you an engineer battling to prioritise technical improvements in a product roadmap?</p><p>There are several things we could do. We could brush up our negotiation skills. We could develop the capability to valuate technical improvements in terms of business KPIs to make a better case for them. But neither of these ideas address the root of the problem: should we even have to prioritise between technical and product improvements in the first place?</p><p>Before we answer that, let’s start by defining the two types of work. We’ll call them “feature work” and “engineering work”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JHPqwp5j1mdGecPimWi1xA.png" /></figure><ul><li>Feature work is like a customer order, i.e. it is work requested for by a customer. It changes the behaviour of a system.</li><li>Engineering work on the other hand does not change the behaviour of a system. It is no less important though. Neglect of engineering work will eventually slow down feature work.</li></ul><p>Yes, that is right. Engineering work is not fancy, fun work that engineers want to do. It is a requirement to keep the system productive. Engineering work comes in various forms, e.g. technical debt, refactoring and technology upgrades.</p><p>Now that know what each form of work is…</p><h4>How do we prioritise between feature and engineering work?</h4><p>Well, we don’t.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UNT-RWrxT512sRbdP4K8pA.png" /></figure><p>For the most part, we bake in the time required for engineering work into feature work. A few analogies to illustrate why:</p><ol><li>A surgeon does not ask their patients if they should put on surgical gear. The act of putting on the gear is a part of the surgery itself.</li><li>A manufacturer does not ask their customers whether machines should be oiled or serviced. These procedures are accounted for in the production schedule.</li><li>A chauffeur does not ask their passengers whether to fill the tank or clean up. Maintenance of the vehicle is baked into the service being offered.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pG-uB0NIoiQYLdv0LjMnHQ.png" /></figure><p>Why don’t these professionals ask their customers whether to put on safety gear or keep their tools and machines in tip-top shape? Because they know better. They are the “professionals” after all.</p><p>We too are professionals. We don’t need to negotiate the writing of a test or refactoring of a piece of code. Our objective always remains feature work, where engineering work is often a means to it. In fact, engineering work would not exist if not for feature work. If we accept this symbiotic relationship, it becomes clear that it is futile to compare one against the other. They are simply meant to co-exist.</p><h4><strong>So where does engineering work go on a product roadmap?</strong></h4><p>Whether it’s a roadmap, a work-board, a backlog or a set of goals, we should stop attempting to stack rank or prioritise engineering work against feature work. The sole purpose of the board is to track and prioritise what the customer wants. Engineering work is an implied part of it all.</p><p>This does not mean that we stop tracking engineering work, such as technical debt, when tracking would be beneficial. We can do that elsewhere. We just don’t want to mix up it up with feature work and end up prioritising between them.</p><p>There can be exceptions though…</p><h4><strong>What if engineering work is going to impede our ability to do feature work?</strong></h4><p>When a piece of engineering work is larger than usual, we can add a placeholder in our roadmap to indicate why we won’t be able to take on our usual volume of feature work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VHD5tEvZFcNczoXWXH1VFQ.png" /></figure><p>In the example of the manufacturing factory, this could be a machine replacement that is not routine. While the machine is being replaced, a lower intake of customer orders is expected, therefore a placeholder for “machine replacement” is placed on the order list to indicate reduced capacity for customer orders.</p><p>For us, this could be major architectural rework that significantly reduces our capacity to do feature work.</p><p>Keep in mind, instances of engineering work appearing on feature prioritisation boards should be the exception, not the rule.</p><h3>Disclaimer:</h3><p><a href="https://www.bazaartech.com/"><strong>Bazaar Technologies</strong></a> believes in sharing knowledge and freedom of expression, and it encourages it’s colleagues and friends to share knowledge, experiences and opinions in written form on it’s <a href="https://medium.com/bazaar-tech">medium publication</a>, in a hope that some people across the globe might find the content helpful. However the content shared in this post and other posts on this medium publication mostly describe and highlight the opinions of the authors, which might or might not be the actual and official perspective of Bazaar Technologies.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da91e9a04156" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bazaar-tech/how-to-prioritise-technical-improvements-in-product-teams-da91e9a04156">How to Prioritise “Engineering Work” in Product Teams</a> was originally published in <a href="https://medium.com/bazaar-tech">Bazaar Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[In Search of “Engineering Excellence” — 5 Ideas To Grow Technical Skills And Keep The Team Engaged]]></title>
            <link>https://lamak-qaizar.medium.com/in-search-of-engineering-excellence-5-ideas-to-grow-technical-skills-and-keep-the-team-engaged-9f48517fbd4f?source=rss-c016b9a3b681------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f48517fbd4f</guid>
            <category><![CDATA[engineering-management]]></category>
            <category><![CDATA[team-building]]></category>
            <category><![CDATA[coaching]]></category>
            <category><![CDATA[software-craftsmanship]]></category>
            <category><![CDATA[leadership]]></category>
            <dc:creator><![CDATA[Lamak Qaizar]]></dc:creator>
            <pubDate>Thu, 21 Jul 2022 13:53:30 GMT</pubDate>
            <atom:updated>2022-07-25T07:26:58.800Z</atom:updated>
            <content:encoded><![CDATA[<h3>In Search of “Engineering Excellence” — 5 Ideas To Grow Technical Skills And Keep The Team Engaged</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HPlS0DFl9RdaqK58" /><figcaption>Photo by <a href="https://unsplash.com/@dlerman6?utm_source=medium&amp;utm_medium=referral">Daniel Lerman</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Several years ago, I was leading a full-stack team of super ambitious engineers. We were tasked with developing the customer support experience for our ride-hailing app. We were developing it end-to-end — from the mobile app experience to back-office systems for our support staff.</p><p>The domain was new to us, and that kept us busy for a while. That, and numerous layers of legacy code. As the charm of a new domain and tech stack wore off, the team asked, “What’s next?”</p><blockquote>“What’s next?” — a team with an insatiable hunger to learn</blockquote><p>I had to help the team find answers. To help the team learn and grow. To elevate the quality and throughput of our delivery. And of course, to keep the team engaged. I didn’t find the answers alone. We worked together to define and execute a few experiments, which we describe below.</p><h3>1. Create a visual Tech-Roadmap</h3><p>To kick things off, we listed down the tools and technologies that we were using at the time. Followed by those that we weren’t using but saw potential in. We did this activity as a team.</p><p>Specifically, each team member filled out an empty radar. The quadrants represented a tech category, namely “Language or Framework”, “Tool”, “Platform”, or “Technique”. The rings of the radar indicated where the technology stood in its lifecycle relative to our organisation. Was it a technology that we needed to “Adopt”, “Trial”, “Assess” or “Hold”?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y9YrpPOuLh0m97XZSR75gg.jpeg" /><figcaption>A quadrant of the Tech Radar</figcaption></figure><p>Discussions followed and we consolidated all the ideas into a single “<a href="https://www.thoughtworks.com/radar">Tech Radar</a>”, a format that we borrowed from ThoughtWorks. Doing the activity as a team ensured buy-in, and more importantly, resulted in a set of ideas that neither of us could have come up with on our own.</p><p>Had we created a textual roadmap, it may not have stimulated as much discussion. A map not only made for better conversation, but the visual cues and spatial aspect helped communicate a lot more information with a fraction of the content. We could also put it up on a wall to spark discussions and keep the roadmap evolving.</p><h3>2. Accelerate adoption of high-potential tech</h3><p>We called this the “Technology Accelerator Program”, or TAP for short (no rights reserved 🙂). The goal was to fast-track technologies identified in the “Adopt” and “Trial” segments of the Tech Radar. We could not focus on everything we had listed, so we voted for the top three interest areas and formed working groups around them.</p><p>The objective was to learn the technologies without worrying about how and where we would apply them. Our newfound knowledge would enable us to make better design decisions, even if we couldn’t find an application for the technology straight away.</p><p>The technologies we picked were Kafka, Kubernetes and Kotlin. Kafka, because we wanted to explore event-driven and event-sourced architectures. Kubernetes, because platform teams were evaluating it as a cost-effective solution to host our microservices, and as a product team we could get a head start. Kotlin, because we wanted to explore the functional paradigm with a language that could interop with existing applications written in Java.</p><p>We dedicated half a day every week to this program. Admittedly, we struggled to make the time for it on most occasions because we hadn’t yet ironed out our ability to deliver sprints on a consistent basis. We had high work-in-progress and quality issues that required fixing first, something the next section of this article helped us with. Nevertheless, the knowledge we gained proved beneficial and all three technologies that we researched were incorporated into our tech stack in the months to come.</p><h3>3. Set out on a journey to master “Techniques”</h3><p>The “Tech Radar” included a quadrant for “Techniques”. These are practices that have applications beyond any specific tool or technology. We had to stretch our imagination to fill out this section, looking beyond well-known practices and principles such as unit tests and SOLID.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*M32GrFyPECKaVb_I" /><figcaption>Photo by <a href="https://unsplash.com/es/@nhoizey?utm_source=medium&amp;utm_medium=referral">Nicolas Hoizey</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Fortunately, we discovered a depth in our discipline that we did not know existed. We discovered how to improve the design of existing code in Martin Fowler’s book “Refactoring”, how to write tests in Kent Beck’s “TDD by Example”, how to design Object Oriented code while leaning on tests for feedback in Freeman and Pryce’s “Growing Object-Oriented Software Guided by Tests”… and much, much more.</p><p>We discovered practices that have stood the test of time. Investment in them was likely to last a career, unlike languages or frameworks that get booted every few years.</p><p>We set out to learn these skills in a series of “Learn Together”<strong> </strong>activities. We read chapters of “The Pragmatic Programmer”, practised TDD and Refactoring through <a href="https://kata-log.rocks/">Coding Katas</a>, watched the “Clean Coder” series by Uncle Bob and saw Sandi Metz <a href="https://youtu.be/OMPfEXIlTVE">refactor to Object-Oriented patterns</a> that we didn’t know existed.</p><p>Learning and practising these techniques together in a safe environment, away from production code, proved to be one of our most rewarding experiences. As we went on to apply what we had learnt, the quality of code and throughput of our delivery improved. We released to production in hours and days instead of weeks. Processes improved as our understanding of principles such as “Lean” evolved; we could onboard engineers in as little as a week as compared to the months that it took us in the past.</p><p>This brought us to an important realization: to improve and master our craft, we must study and practice beyond the writing of production code. Deliberate practice is a part of every profession. If a surgeon operated only on live patients, we would be hesitant to get under their knife and scalpel. For that very reason, surgeons practice in simulated environments, developing skills in relative safety away from the real-world operating table. Why should software engineering be devoid of deliberate practice?</p><p>These realizations led to meet-ups within the organization, such as this series of learning activities described <a href="https://medium.com/careem-tech/a-week-of-learning-agile-development-1975062b3b97">here</a>, as well as the formation of a vibrant community outside, i.e. <a href="https://software-crafters-karachi.github.io/past-meetups.html">Software Crafters in Pakistan</a>.</p><h3>4. Enlist the services of a coach</h3><p>As we went about mastering engineering “Techniques”, we encountered a barrier that we could not break through on our own— “Pair Programming”. It sounded simple, in theory. Two programmers working together, sharing knowledge on the go, collectively solving problems and continuously reviewing code. But what was the role of each partner? How could we keep both partners engaged? Who should pair up with whom?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PklTC33GqqmQJXaw" /><figcaption>Photo by <a href="https://unsplash.com/@johnschno?utm_source=medium&amp;utm_medium=referral">John Schnobrich</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>To help get us started, we flew in a <a href="https://www.linkedin.com/in/dstepanovic/">member of a fellow team</a> from Berlin to code with us for a week. That person was a seasoned expert in “Extreme Programming”. They programmed with us through a few Coding Katas as well as production problems, and soon enough, we could pair program on our own.</p><p>The coach additionally assessed where we were on our journey towards mastering various techniques and guided us on what to pursue next — things like DDD, Simple Design, and Mob Programming. We were set for a few more years to come.</p><p>We were lucky to find a coach within our organization. If you cannot find someone with the skills that you require, make a case to get one from the outside. It may be well worth the investment.</p><h3>5. Strive for “Engineering Excellence”, but measure it first</h3><p>Thanks (once again) to our coach, we came across a book titled “Accelerate: Building and Scaling High Performing Technology Organizations”. There are four metrics identified in the book that researchers correlate with organizational performance, along with benchmarks for each. These helped us establish goals for ourselves. Goals that we could measure and strive towards.</p><p>It may be argued that these metrics are not perfect, and indeed they cannot substitute for anything that measures business performance. They do however give us some objectivity in an opinionated world. As Sandi Metz says in one of her <a href="https://youtu.be/8bZh5LMaSmE">talks</a>, “metrics are fallible, but human opinion is no more precise”.</p><p>The metrics are listed in the table below. We were nowhere near the benchmarks, to begin with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p1yVOozi7mS28hjob4D3fQ.png" /><figcaption>Benchmarks from “Accelerate”</figcaption></figure><p>We set up automated scripts that tapped into infrastructure, such as build pipelines and monitoring dashboards, to capture the metrics. These mechanisms were non-intrusive in nature so that we could capture a baseline without modifying existing processes or human behaviour.</p><p>With data in hand, we identified the first bottleneck. As we eliminated it, the constraint shifted to another part of the system. We gathered more data and repeated the process.</p><p>It is worth noting that we captured these metrics at the team level. It may have been counter-productive to capture them for individuals within the team as internal competition would have led to friction in collaboration and local optimization. “Peopleware” has a great chapter on this topic titled “Competition” (Chapter 25).</p><blockquote>“The journey of a thousand miles begins with a single step” — Lao Tzu</blockquote><p>The goals seemed quite audacious at first but as we started to hit one milestone after the other, belief set in. The journey itself is the subject of another <a href="https://lamak-qaizar.medium.com/improving-software-delivery-using-data-a-case-study-b704f88541fb">article</a>, so we won’t delve into too much detail here.</p><p>In the end, we created something that was far greater than the product of each experiment — a culture of continuous learning and improvement. Having undertaken the journey to learn and improve together, as a team, made the experience all the more rewarding. We developed deeper relationships with one another and found it easier to put our newfound skills into practice.</p><p>Our journey goes on, and we hope that you find our learnings useful to fuel yours. Bon voyage! ️⚓️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f48517fbd4f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Started with Pair & Mob Programming]]></title>
            <link>https://lamak-qaizar.medium.com/getting-started-with-pair-mob-programming-a8a6aa7bc69?source=rss-c016b9a3b681------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8a6aa7bc69</guid>
            <category><![CDATA[agile-development]]></category>
            <category><![CDATA[mob-programming]]></category>
            <category><![CDATA[pair-programming]]></category>
            <category><![CDATA[collaboration]]></category>
            <dc:creator><![CDATA[Lamak Qaizar]]></dc:creator>
            <pubDate>Mon, 09 May 2022 09:41:21 GMT</pubDate>
            <atom:updated>2022-07-24T20:29:13.316Z</atom:updated>
            <content:encoded><![CDATA[<h3>A Practical Guide To Getting Started with Pair and Mob Programming</h3><blockquote>“How can we be productive if we separate people who should be working together?” — Woody Zuill</blockquote><p>You may have heard that coding together sets up a platform for continuous learning. That it breaks down knowledge silos and accelerates the feedback loop, enabling teams to deliver higher quality software, faster.</p><p>You may also have tried coding together only to discover that the stated benefits did not materialise. What could have gone wrong?</p><p>Consider a team of sportsmen. It is highly unlikely that they would play well just by being on the field together. Or a group of surgeons. That they would operate effectively just by being in the operating theatre together. In the same way, coding together doesn’t work just by seating two or more individuals together.</p><p>We must define roles and processes for the practice to be effective. Or at the very least, to help us get started.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XiyaPQ9Jm9pwddszvUCe3Q.jpeg" /><figcaption><a href="https://www.linkedin.com/in/shakeel-hussain-696464108">Shakeel</a> and <a href="https://www.linkedin.com/in/ramizansari/">Rameez</a> pair up on a coding kata</figcaption></figure><p>There are several formations for coding together that we can consider. One that works well in most situations, and extends seamlessly into mob programming, is “Strong-Style” pair programming. The rule of this formation is:</p><blockquote>“For an idea to go from your head into the computer, it must go through someone else’s hands” — Llewellyn Falco</blockquote><h3>Roles</h3><p>There are two key roles in this form of coding together:</p><ol><li>The driver, and</li><li>One or more navigators</li></ol><p>A person may additionally be nominated to facilitate the session.</p><h4>Driver</h4><p>The driver is the person at the keyboard. They take high-level instruction from the navigator and translate it into code. The driver is focused on solving the specific problem at hand.</p><blockquote><em>“For best results, you must believe that the solution to the problem you’re working on lies buried in another person’s subconscious mind.” —</em>Oozie Ligus, <em>29 Guidelines for Successful Pair Programming</em></blockquote><p>The driver should not implement a change unless the intent is expressed by the navigator. If the driver has an idea, they should wait their turn to navigate or request for the navigator to switch roles.</p><p>If the driver is new to the team or technology, they may stay on in this role for an extended period of time. This is to allow the driver to familiarise themselves before taking on the role of navigator.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2d1kY2YdYAhr6_ohrmQ6lw.jpeg" /><figcaption>The Driver-Navigator formation. Image courtesy <a href="https://commons.wikimedia.org/wiki/File:1987_South_India_Rally_-_Vicky_Chandok_in_Sipani_Dolphin.jpg">Wikimedia Commons</a></figcaption></figure><h4>Navigator</h4><p>The navigator keeps a holistic view of the problem statement and guides the driver from one problem to the next. Navigators generally provide a high level of instruction but may drop to lower levels, such as when the driver is not fluent with the development environment at hand.</p><p>When the “Strong-Style” formation is extended to mob programming, there is more than one navigator. It can be overwhelming for the driver to receive instructions from multiple navigators, therefore one of the navigators is nominated as the primary navigator. The primary navigator discusses ideas with other navigators, before providing the final instruction to the driver.</p><h4>Facilitator</h4><p>A facilitator may be nominated in each session until the team is accustomed to the rules and roles of coding together. A facilitator keeps time, manages rotation, ensures breaks are taken and that the driver/navigators stick to their respective roles. Facilitators may also conduct a short retrospective at the end of each session to gather feedback and discuss learnings.</p><h3>Rotation</h3><p>The driver and navigator switch roles at a predefined time interval, e.g. every 5 or 10 minutes. Switching roles at short intervals may seem difficult at first, but the constraint forces participants to break down work into smaller increments of working software.</p><p>With experience, rotation can occur naturally.</p><p>When rotating while mob programming, the driver makes a good candidate for taking on the navigator role. The driving seat allows team members to get into context, and then continue on from where the previous navigator left off.</p><h3>Maintain a TODO list</h3><p>When kicking off a pair or mob programming session, it is useful to spend a few minutes creating a TODO list together. This is to allow all navigators, even those that are new to the team, to have a bearing on where the session is headed, and how to get there. The TODO list may change over the course of a session as new knowledge is discovered.</p><h3>Practice, practice, practice!</h3><p>It can be overwhelming to try out a new skill in a production environment. Consider setting up a few practice sessions with the team to learn how to code together before moving on to real-world problems. Try coding together on coding katas listed here: <a href="https://kata-log.rocks/pair-programming">kata-log.rocks</a>.</p><p>Here are a few questions that often come up when getting started:</p><h3>Can coding-together cause burnout?</h3><p>Pair programming is more susceptible to burnout. The activity can be exhausting because both partners keep each other focused and in a state of flow. It is important to take frequent breaks to recharge. There can also be stress associated with being available for one another, as whenever either partner is not around, work stops.</p><p>Mob programming helps mitigate the risk of burnout. It ensures work goes on even when a team member is unavailable. Individuals can take a break or leave without having to worry about impeding work.</p><h3>What is the ideal size of a mob?</h3><p>In my experience, it is 4 to 6 individuals. Team members can take vacations and breaks, join in late or drop off early, without impeding work.</p><h3>Should we code together on all tasks?</h3><p>By default, yes. We might assume that coding together on trivial tasks is an inefficient use of time. However, if it is painful to work together on certain tasks, it may indicate that the process itself has room for improvement. And process improvement is usually not a trivial task.</p><blockquote>“Where an individual tolerates wasteful practices, a mob amplifies and addresses those.” — Maaret Pyhäjärvi, Ensemble Programming Guidebook</blockquote><p>An exception is R&amp;D, where you may choose to try out various solutions independently. These are known as <a href="http://www.jamesshore.com/v2/books/aoad1/spike_solutions#:~:text=A%20spike%20solution%2C%20or%20spike,spike%20will%20answer%20the%20question.">Spike Solutions</a>. Code produced from the experiments is subsequently discarded, and the team proceeds to co-create production code.</p><h3>We are working remotely. Can we still code together?</h3><p>Of course! Try setting up a “Virtual Room” — a static meeting link to make it easier for team members to find each other.</p><p>And that’s it, you are well on your way to co-creating code! This guide is by no means definitive, it is just to help get started. Once you learn to follow the rules, adapt and keep improving.</p><blockquote>“Agile software development is an ongoing process of learning and improvement. Never stop practicing, experimenting, and evolving.”— James Shore, The Art of Agile Development</blockquote><h3>To learn more…</h3><ul><li>(YouTube) <a href="https://youtu.be/SHOVVnRB4h0">Mob Programming: A Whole Team Approach</a> by Woody Zuill</li><li>(Blog) <a href="http://llewellynfalco.blogspot.com/2014/06/llewellyns-strong-style-pairing.html">Llewellyn’s strong-style pairing</a> by Llewellyn Falco</li><li>(Book) <a href="https://leanpub.com/ensembleprogramming">Ensemble Programming Guidebook</a> by Maaret Pyhäjärvi</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8a6aa7bc69" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Improving Software Delivery Using Data — A Case Study]]></title>
            <link>https://lamak-qaizar.medium.com/improving-software-delivery-using-data-a-case-study-b704f88541fb?source=rss-c016b9a3b681------2</link>
            <guid isPermaLink="false">https://medium.com/p/b704f88541fb</guid>
            <category><![CDATA[toyota-production-system]]></category>
            <category><![CDATA[continuous-improvement]]></category>
            <category><![CDATA[data-driven]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[theory-of-constraints]]></category>
            <dc:creator><![CDATA[Lamak Qaizar]]></dc:creator>
            <pubDate>Thu, 20 May 2021 07:45:54 GMT</pubDate>
            <atom:updated>2021-05-21T09:05:23.523Z</atom:updated>
            <content:encoded><![CDATA[<h3>Improving Software Delivery Using Data — A Case Study</h3><h4>Co-authored by <a href="https://www.linkedin.com/in/saaadyi/">Saad Ismail</a> &amp; <a href="https://www.linkedin.com/in/fahadakhan96/">Fahad Khan</a></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gejdbMTwRXkABIAL" /><figcaption>Photo by <a href="https://unsplash.com/@franki?utm_source=medium&amp;utm_medium=referral">Franki Chamaki</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>A couple of years ago, we set out on a journey to improve the quality &amp; speed with which we delivered software. This is the story of what we did and learnt along the way.</p><p>We are a team of 12 engineers organised into two squads. Each squad solves problems for a distinct customer touchpoint/experience. Together, the experiences form one of the domains at our organisation. Two additional team members specialise in Site Reliability Engineering (SRE). They complement both squads.</p><p>Back in time, we relied upon trial and error to improve delivery. Several initiatives yielded results e.g.:</p><ul><li>Setting up robust monitoring and alerting. Without which we would be notified of problems through our customers — after they had already caused much damage.</li><li>Automating tests and making it a habit to write tests first (TDD). Otherwise, we would find defects much later in the development cycle when they were costlier to fix.</li></ul><p>Several initiatives did not produce the benefits we’d expected:</p><ul><li>Increasing test coverage to an arbitrary percentage. Much effort was expended, but there was no noticeable gain in reliability.</li><li>Rewriting a microservice in a language/framework more familiar to us. We hypothesised this would make it easier to develop new features, however, to date there have been no new feature requests on this particular service.</li></ul><p>How much had we improved? Should we have improved something else? We didn’t have the data to tell. We decided to take a more measured approach as we moved forward.</p><p>That begged the question…</p><h3>What should we measure?</h3><p>Luckily, work was cut out for us. We came across a book titled <em>Accelerate: Building and Scaling High Performing Technology Organizations</em>. Through years of research across many tech companies, the authors have identified 4 metrics that correlate with organisational performance:</p><ol><li>Deployment Frequency</li><li>Change Lead Time (CLT)</li><li>Change Failure Rate (CFR)</li><li>Mean Time To Recover (MTTR)</li></ol><p>To track the KPIs, our site reliability engineers set up a script that gathered data points from deployment pipelines, version control (git) and incident reports. It ran every week on a Lambda, computed the KPIs and stored them in a database.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/681/1*1OjkcPmUiad-Z3o6qxDhqw.png" /><figcaption>A view of the KPIs on Kibana</figcaption></figure><p>Within weeks, we had established a baseline. We could now get quantitative feedback on initiatives &amp; track progress.</p><p>As we inspected our initial measurements, one KPI stood out. And it was not pleasant. CLT was averaging nearly 10 hours. We measured it as the time between a code commit and when that commit was live in production. According to a benchmark in <em>Accelerate</em>, high-performing organisations had a CLT of less than 60 minutes.</p><blockquote>We measured CLT as the time between a code commit and when that commit was live in production.</blockquote><p>We had much to improve.</p><h3>A bottleneck appears</h3><p>The Theory of Constraints states that to improve the throughput of a system, we must identify and alleviate its constraints or bottlenecks. What was the constraint holding up our CLT? We broke it down into its constituent components to find out.</p><p>Since we were pair programming, code would be reviewed continuously. Developers merged their commits directly into trunk — not having to create feature branches/pull requests and wait for an asynchronous code review. Before we started pair programming, a retrospective analysis showed that pull requests took 31 hours to get reviewed and merged on average. Fortunately, this was already out of the way. What was remaining was the time to trigger and execute the deployment pipeline.</p><p>While calibrating the deployment pipeline, we discovered automation that ran unit tests, set up the blue/green environment and routed traffic only accounted for 4% of CLT. The remaining 96% was human intervention: triggering the pipeline, manually validating the new environment and initiating numerous traffic routing steps while monitoring service KPIs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eHJw8noMqYjzqgUo4sopWQ.png" /><figcaption>CLT breakdown (for illustration only — not drawn accurately)</figcaption></figure><p>To improve CLT, we had to optimise the constraint: the 96% component where the pipeline was waiting for human intervention.</p><p>Before we did that though, something else caught our attention. During brainstorming sessions, a peculiar organisational practice had come up frequently: the “peak lock-out”.</p><p>The lock-out restricted access to deployment pipelines during peak business hours, i.e. late in the afternoon till midnight. It would coincidentally start during work hours. The result: we would often have to wait until morning to deploy commits. To make matters worse, commits would batch up during this time. If something failed, it would take longer to identify the faulty change.</p><p>Peak lock-out was introduced several years earlier during a phase of exponential growth. We were no longer a start-up. Teams were scaling up and systems were rearchitected while churning out even more features. During the chaos, deployments had often led to outages.</p><p>Since then, domain boundaries had emerged and in them, teams had settled down. Engineers could test and deploy their changes in relative isolation. Stability had improved drastically. However the lock-out, now a relic of the past, was unmoved.</p><p>We hypothesised that lifting the lock-out would improve CLT.</p><p>Not only that, we believed reliability would improve too. Commits would be deployed sooner rather than later when they would be freshest in the developers&#39; mind. They would also be deployed in smaller batches. This would lead to better detection and recovery times if and when an incident occurred.</p><p>For the lock-out to be lifted though, we had to make a case for it. Soon enough we got an opportunity.</p><h3>Breaking through the lock-out</h3><p>Peak lock-out was temporarily lifted during the first weeks of the COVID-19 pandemic. This was to allow teams to quickly adapt systems and infrastructure in line with new business reality.</p><p>With the dashboard and instrumentation already in place, we captured the impact on our KPIs during this period. CLT showed an improvement of 30%. Reliability too was better— there were fewer incidents with improved detection and recovery times.</p><p>With data in hand, we proposed for the peak lock-out to be lifted permanently. And so it was — much to the joy of engineers across the organisation.</p><p>We had improved CLT without yet reducing human intervention from our pipelines. This was because commits could flow through the pipeline throughout the day — unlike when peak lock-out was in place. Taking a leaf out of the Theory of Constraints: we had exploited the bottleneck by increasing its availability.</p><p>CLT was down from 10 hours to 6. There was still plenty of room for improvement.</p><h3>Eliminating manual steps</h3><p>To reduce human intervention, we had to eliminate the manual steps in our deployment pipeline. Per pipeline, there were as many as 10 manual steps. We set target conditions to drive them down all the way to zero.</p><p>Starting with quick wins, we eliminated redundant steps— those that did not add value:</p><ul><li>Having improved test practices, we were no longer manually verifying changes in a QA environment. We, therefore, eliminated the step that deployed to QA.</li><li>We eliminated all the intermediary routing and verification steps. We found that routing a small percentage of traffic, verifying service metrics, and routing 100% traffic was as good as routing traffic in many increments while verifying metrics between each step.</li><li>Since every commit to trunk was deployable, there was no value in manually triggering the pipeline by logging onto the automation server. Deployments could just be triggered automatically. Our SREs configured a plugin to do just that.</li></ul><p>We were now down to two manual steps. These were non-trivial to eliminate as they involved some form of decision making:</p><ol><li>Invoking APIs to validate whether the new environment was functioning correctly.</li><li>Monitoring service metrics after a small percentage of traffic was routed to detect any unexpected issues.</li></ol><p>In the early 1900s, Toyota faced a similar predicament. After having automated much of their production line, a human would still have to ‘watch over’ in case something went wrong. Toyota subsequently built just-enough-intelligence into its production line. The normal sequence of operations could then execute autonomously. In the rare case of a failure, the line would stop and alert a human to step in. This was known as Autonomation or Jidoka, in Japanese.</p><p>Back at our delivery process, we observed our pipelines while deployments were underway. Soon we identified a few heuristics that simulated human decisions and built those into the pipeline. In the rare case that something went wrong, and just like Toyota, the pipeline was configured to stop and alert us. Only then would we intervene — to take corrective action and ensure the same issue did not occur again.</p><p>From the two remaining manual steps, take the example of verifying service metrics on a small percentage of traffic. We found for most pipelines the ratio of API requests that failed vs. succeeded was a good enough heuristic. After computing the ratio on a small percentage of traffic, we evaluated it against a preset threshold and proceeded to route 100% of traffic. With as simple a solution as this, the need for a human to intervene in the process was eliminated.</p><p>Thus we were soon down to zero manual steps. After we pushed code, the deployment pipeline would trigger and run in the background — autonomously. We could continue coding.</p><h3>The constraint shifts</h3><p>With peak-lock out lifted and all manual steps eliminated, CLT was down to less than 60 minutes. An improvement of over 90% from our initial measurement, and in line with the benchmark from <em>Accelerate</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Whrd0zITynapoVddkmjhOQ.png" /><figcaption>As CLT improved, so did the Deployment Frequency. We measure Deployment Frequency as the # of deployments per developer.</figcaption></figure><p>As one constraint was eliminated, another emerged. CLT was now dominated by the time it took for automation to run, i.e. the time it took to set up the blue/green environment, run automated tests and route traffic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4MAdKlUBt4Mfz3vGAuX8KQ.png" /><figcaption>CLT breakdown after eliminating all manual steps (for illustration only — not drawn accurately)</figcaption></figure><p>We now look towards leaner infrastructure, such as containers, and nimbler traffic routing strategies e.g. application-based instead of our existing DNS-based set-up to alleviate the new constraint.</p><p>Until the constraint shifts again…</p><p>We’ve discovered improvement to be a continuous, endless process. With our aspirations running higher than ever, we press forward with a new set of tools to guide us: a data-driven approach, the Theory of Constraints &amp; Toyota’s lean production techniques.</p><p>If you don’t know what your constraint is yet, don’t worry. Measure what you want to improve, and take the first step. Let the data guide you. Mike Rother says:</p><blockquote>It matters more that you take a step than what that first step is. When you’ve done that, the learning process begins and you will see further. If you are moving ahead in fast cycles, you will soon find the current biggest problem.</blockquote><h3>Acknowledgements</h3><p><a href="https://www.linkedin.com/in/dstepanovic/">Dragan Stepanović</a> for introducing us to the Theory of Constraints and the research in <em>Accelerate</em>. <a href="https://www.linkedin.com/in/saadarshad/">Saad Arshad</a> &amp; <a href="https://www.linkedin.com/in/syed-shariq-ali/">Syed Shariq</a>, our fantastic site reliability engineers, for leading many of the initiatives above. They were aptly supported by their partner in hacking, <a href="https://www.linkedin.com/in/hatim-fakhruddin-096b566b">Hatim Fakhruddin</a>, and the central infra team led by <a href="https://www.linkedin.com/in/elifakten/">Elif Kara</a> &amp; <a href="https://www.linkedin.com/in/zeshan-habib-a893a619/">Zeeshan Habib</a>. <a href="https://www.linkedin.com/in/iazeemullah/">Azeem Ullah</a> for crunching out how long it took us to review pull requests and, along with <a href="https://www.linkedin.com/in/adam-gon%C3%A7alves-a7412310b/">Adam Goncalves</a>, providing us with a valuable review of this article. The entire team at <a href="http://linkedin.com/company/careem/">Careem</a> for their support and for showing us how to dream big. Thank you!</p><h3>To learn more about…</h3><ul><li>The Theory of Constraints: <a href="https://www.google.com/search?q=the+goal+by+eliyahu+goldratt">The Goal</a> by Eliyahu M. Goldratt</li><li>Measuring software delivery: <a href="https://www.google.com/search?q=accelerate+the+science+of+lean+software+and+devops">Accelerate</a> by Gene Kim, Jez Humble and Nicole Forsgren</li><li>Toyota’s continuous improvement process: <a href="https://www.google.com/search?q=toyota+kata+by+mike+rother">Toyota Kata</a> by Mike Rother</li><li>Lean production: <a href="https://www.google.com/search?q=toyota+production+system+by+taichii+ohno">Toyota Production System</a> by Taiichi Ohno</li><li>Our experiences with Pair Programming: <a href="https://medium.com/agileinsider/a-year-of-extreme-programming-1f239f6d00f7">A year of Extreme Programming</a> by <a href="https://www.linkedin.com/in/mohammad-urwah/">Muhammad Urwah</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b704f88541fb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Week of Learning Agile Development]]></title>
            <link>https://medium.com/careem-tech/a-week-of-learning-agile-development-1975062b3b97?source=rss-c016b9a3b681------2</link>
            <guid isPermaLink="false">https://medium.com/p/1975062b3b97</guid>
            <category><![CDATA[code-retreat]]></category>
            <category><![CDATA[team-activities]]></category>
            <category><![CDATA[agile-development]]></category>
            <category><![CDATA[refactoring]]></category>
            <dc:creator><![CDATA[Lamak Qaizar]]></dc:creator>
            <pubDate>Sun, 03 Jan 2021 12:59:40 GMT</pubDate>
            <atom:updated>2021-01-14T15:52:24.138Z</atom:updated>
            <content:encoded><![CDATA[<p>Away from the hustle of production work, we organised a series of team activities to grow our agile development capabilities. Each full-day of activity was themed:</p><ul><li>Day 1 — Refactoring</li><li>Day 2 — Code Smells</li><li>Day 3 — Testing Legacy Code</li><li>Day 4 — Simple Design</li><li>Day 5 — Mob Programming</li></ul><p>We kicked off each day with a book reading activity. Reading was intertwined with discussion and was followed by a <strong>coding kata </strong>— an exercise that reinforced learning by practice.</p><p>A short retrospective meeting to gather reflections and learnings brought each activity to a close.</p><p><em>Learning Week</em> was held remote-first on Zoom and all activities were group-based —i.e. reading and programming in either one large group or several smaller teams. For these smaller groups, we used Zoom’s breakout rooms feature.</p><h4>Want to run these activities for your team?</h4><p>If participants are not familiar with Pair Programming &amp; TDD, consider including relevant introductions. Participants in our case were a budding XP-team with a year of practical experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zo5wYn_ZDFI26SEM5VAYTA.jpeg" /><figcaption>Refactor cat. Photo by Zainab Jalali</figcaption></figure><h3>Day 1 — Refactoring</h3><ul><li>Group-reading: <strong>Design II — Refactoring</strong> from <em>Agile Technical Practices Distilled. </em>While reading, participants discovered heuristics such as Object Calisthenics &amp; duplication, and techniques to refactor (Safe Refactoring &amp; Parallel Change).</li><li>Participants were introduced to <strong>5 atomic refactors:</strong> (1) <em>Rename, (2) Extract, (3) Inline, (4) Move, (5) Safe Delete</em>. A look-up table was provided with keyboard shortcuts for reference.</li><li>Kata: <a href="https://github.com/emilybache/Yatzy-Refactoring-Kata">Yatzy Refactoring Kata</a></li></ul><p>A few thought-provoking excerpts from <strong>Chapter 2: Principles in Refactoring </strong>of <em>Refactoring: Improving the Design of Existing Code</em> were shared with participants through the day:</p><blockquote>“But doesn’t the time I spend on refactoring reduce the speed of development?”<br>“How to tell a manager about refactoring?”<br>“Refactoring can be a fantastic tool to help understand a legacy system …”</blockquote><h3>Day 2 — Code Smells</h3><p>Participants added Code Smells to their refactoring tool-kit.</p><ul><li>Group-reading: <strong>Chapter 3: Bad Smells in Code </strong>from <em>Refactoring: Improving the Design of Existing Code</em>, followed by <strong>Design III — Code Smells</strong> from <em>Agile Technical Practices Distilled</em>. Participants discovered the catalogue of refactoring recipes in Martin Fowler’s book.</li><li>Kata: <a href="https://github.com/AgileTechPraxis/CodeSmells">Smelly Tic-Tac-Toe</a> — participants used the following commit convention: [code smell] message, for e.g. [primitive obsession] wrapped float as Amount.</li></ul><h3>Day 3 — Testing Legacy Code</h3><p>Tests were already written for coding exercises on previous days. Day 3 asked the question: What if we don’t have tests?</p><ul><li>Group-reading: <strong>Chapter 1: Changing Software </strong>and<strong> Chapter 2: Working with Feedback </strong>from <em>Working Effectively with Legacy Code</em>, followed by <strong>Testing Legacy Code </strong>from <em>Agile Technical Practices Distilled</em>.</li><li>Kata: <a href="https://github.com/jbrains/trivia">Ugly Trivia Game</a> — writing a Golden Master test.</li></ul><h3>Day 4 — Simple Design</h3><p>Besides introducing the principles of Simple Design, we set out to build a habit of experimentation &amp; improvement.</p><blockquote>“After deleting and starting again enough times, I’ve often heard people say they have a feeling of freedom they’ve not experienced before.” — Corey Haines</blockquote><ul><li>Group-reading: <strong>Good design?</strong> and <strong>4 Rules of Simple Design</strong> from <em>Understanding The Four Rules of Simple Design</em>, followed by <strong>Classic TDD I</strong> and <strong>Classic TDD II</strong> from <em>Agile Technical Practices Distilled</em>.</li><li>Kata: 4 sessions of <a href="https://www.coderetreat.org/facilitators/gameoflife/">Conway’s Game of Life</a>, 45 minutes each. This followed the <strong>Code Retreat</strong> format: code was thrown away &amp; pairing partners switched after each session.</li></ul><h4>Constraints</h4><p>Participants were given a constraint in each session to break out of habitual code &amp; design practices.</p><ul><li>Session 1 — TDD, driver/navigator rotation in five minutes (or less)</li><li>Session 2 — ≤ 3 lines per method, no variable reassignment</li><li>Session 3 — Evil mute ping/pong. One person is a test-redder, and the other a test-greener. The test-greener does not care about requirements and will get tests to pass any which way. Partners cannot talk to each other.</li><li>Session 4 — No if/else, no loops, no getters (Tell, Don’t Ask principle)</li></ul><p>We adapted constraints after each session based on progress. More constraints can be found on <a href="https://www.coderetreat.org/facilitators/constraints/">coderetreat.org</a>, along with a <a href="https://www.coderetreat.org/facilitators/facilitation/">facilitation guide</a>.</p><h4>Reflections</h4><ul><li><a href="http://cyber-dojo.org/">Cyber-Dojo</a> allowed for a low overhead pair programming experience, i.e. no IDE quirks, no git commands and a simple way to throw away code by closing a browser tab. The downside was the lack of refactoring support. We switched to an IDE with git for our last session.</li><li>Groups may require a nudge to follow a constraint or discover an insight during sessions. We started with 1 facilitator and 4 pairs, before shifting to 2 mobs in the last session. The last session yielded better engagement between facilitator and groups.</li></ul><h3>Day 5 — Mob Programming</h3><p>Participants chose what to do on the final day: refactoring the <a href="https://github.com/jbrains/trivia">Ugly Trivia Game</a> from Day 3.</p><p>A single mob formed with five to eight members throughout the day. Driver/navigator roles rotated every five minutes, with a primary-navigator selected to avoid overwhelming the driver. Drivers would be rotated into the primary-navigator role.</p><p>We experimented with <a href="https://mob.sh/">mob.sh</a> for quick handovers. It turned out to be a nifty tool: keeping time and managing the sequence of drivers.</p><p>Code changes were deleted at the end of each rotation if tests were not green, encouraging participants to use safe refactors.</p><h3>Book references</h3><ul><li><a href="https://leanpub.com/agiletechnicalpracticesdistilled">Agile Technical Practices Distilled</a> <em>by Pedro M. Santos, Marco Consolaro, Alessandro Di Gioia</em></li><li><a href="https://martinfowler.com/books/refactoring.html">Refactoring: Improving the Design of Existing Code</a> <em>by Martin Fowler</em></li><li><a href="https://www.google.com/search?q=working+effectively+with+legacy+code">Working Effectively with Legacy Code</a> <em>by Michael C. Feathers</em></li><li><a href="https://leanpub.com/4rulesofsimpledesign">Understanding the Four Rules of Simple Design</a> <em>by Corey Haines</em></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1975062b3b97" width="1" height="1" alt=""><hr><p><a href="https://medium.com/careem-tech/a-week-of-learning-agile-development-1975062b3b97">A Week of Learning Agile Development</a> was originally published in <a href="https://medium.com/careem-tech">Tech @ Careem</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Illusion of Extraordinary Performance]]></title>
            <link>https://lamak-qaizar.medium.com/the-illusion-of-extraordinary-performance-574cf24e5630?source=rss-c016b9a3b681------2</link>
            <guid isPermaLink="false">https://medium.com/p/574cf24e5630</guid>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[success]]></category>
            <dc:creator><![CDATA[Lamak Qaizar]]></dc:creator>
            <pubDate>Sat, 20 Apr 2019 07:36:24 GMT</pubDate>
            <atom:updated>2019-04-20T07:51:57.249Z</atom:updated>
            <content:encoded><![CDATA[<p>The fastest person is often not the fastest. The smartest person is often not the smartest. Do extraordinary performers possess something the rest of us don’t? Or is the key to their success something ordinary that we are all capable of, yet we find it difficult to spot.</p><p>One such performer is Usain Bolt.</p><p>Is Bolt the fastest sprinter in the world? Maybe; his top speed of 12.27 metres per second suggests so.</p><p>Is Bolt’s top speed the reason for 3 Olympic golds in the Men’s 100m? Probably not.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hTmhmBVIhFCGJMj7Ikvirg.png" /><figcaption>Original image: <a href="https://commons.wikimedia.org/wiki/File:Usain_Bolt_Olympics_Celebration.jpg">Wikimedia Commons</a></figcaption></figure><p>During the 100m dash, when the rest of the sprinter&#39;s tire &amp; start to slow down (somewhere beyond the 70m mark), Bolt pushes through &amp; sustains his pace. In effect, he is decelerating slower than the remaining sprinters.</p><p>Other extraordinary performers work similarly.</p><p>When everyone tires &amp; gives up, they push through. When everyone goes to sleep, they continue to work. To the outside world, these high achieving individuals &amp; organizations possess something that the rest of us don’t. When in fact, it is them sustaining ordinary feats for extraordinary periods of time.</p><p>Jim Collins speaks of a similar phenomenon in his book Great by Choice. In a world of uncertainty &amp; chaos, sustained performance over extended periods produces extraordinary results.</p><p>He describes this phenomenon as a <a href="https://www.jimcollins.com/concepts/twenty-mile-march.html">repeatable process</a> that we can all apply to achieve the extraordinary.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=574cf24e5630" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Conduct Great Coding Interviews]]></title>
            <link>https://lamak-qaizar.medium.com/how-to-conduct-great-coding-interviews-f6f227352bd5?source=rss-c016b9a3b681------2</link>
            <guid isPermaLink="false">https://medium.com/p/f6f227352bd5</guid>
            <category><![CDATA[coding-interviews]]></category>
            <category><![CDATA[interviewing]]></category>
            <dc:creator><![CDATA[Lamak Qaizar]]></dc:creator>
            <pubDate>Mon, 30 Jul 2018 20:42:50 GMT</pubDate>
            <atom:updated>2019-04-24T19:03:43.516Z</atom:updated>
            <content:encoded><![CDATA[<p>Conducting coding interviews can be a challenging prospect for interviewers, and understandably so. What skills you should look for? How should you construct problem statements without being predictable? Will the candidate be a good fit for your team?</p><p>Here are 3 tips to help you get the best out of each interview whilst ensuring a positive experience for the candidate &amp; yourself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6fISJIpemqfMyAXyBSShoQ.jpeg" /><figcaption>Original image: <a href="https://commons.wikimedia.org/wiki/File:NebojsaBumbaPhoto.jpg">wikimedia.commons.org</a></figcaption></figure><h3>1. Look for a solid foundation</h3><p>Ensure that the candidate knows their data structures, can work with nested loops &amp; can identify when an operation is not atomic and would require thread-safe constructs. Be consistent in the underlying concepts you probe for irrespective of the problem statement posed.</p><p>Establishing a consistent benchmark ensures you are evaluating candidates on the same scale every time.</p><p>When it comes to code-style, remember to look for consistency from the candidate. Organisations (and languages) follow different styles — it is fair for candidates to use (or not use) Egyptian braces, so long as they do so consistently.</p><h3>2. Pose real-world problems</h3><p>Prefer real-world problems where you can explore a number of skills &amp; extend the scope as you go along the interview. Stick to one problem per interview, and prefer to derive the problem statement from the conversation as you introduce each other — try to keep the conversation flowing throughout the interview.</p><p>If caches, rate limiters &amp; circuit breakers are what you build at work, those are the sort of problems you want to see your candidate solve. Only have a candidate build a trie &amp; do a BFS if that is what you do at work.</p><p>To ensure unpredictability — keep varying the implementation &amp; problem scope from candidate to candidate. If generics are enforced when you build a cache with one candidate, have another candidate focus on structuring abstractions to allow several cache implementations to be coded. Whatever the problem statement &amp; the twists that you incorporate, remember to look for the same underlying skills. The twists will make problems unique even when candidates happen to share their experiences with one another. Don’t fret though if someone still manages to work out your interview after all your dynamism, they’re probably worth hiring anyways.</p><p>For senior candidates, place additional emphasis on code structure &amp; architecture.</p><h3>3. Work with the candidate</h3><p>Try not to pose a problem statement &amp; sit back for the next 30 minutes. Reveal the problem statement through the duration of the interview and go along with them as they attempt to solve it. Help where help is required as you would help a colleague; if the candidate doesn’t get the job, they’ll be better off for the next one — or better yet, you may even learn something yourself.</p><p>Working with the candidate helps build a positive interview experience and can get encouraging word of mouth for your organisation if not a colleague.</p><p>How do you reveal the problem statement? Let us take an example:</p><p>Introduce a couple of dependent classes where one invokes the other &amp; mention testability — see if they pick up on dependency injection. Introduce the assumption that the dependent service tends to fail — can we count the number of exceptions it throws? Can we trigger a fallback without invoking the dependency in case the number of exceptions exceeds a certain threshold? It wouldn’t make sense to fail indefinitely once the threshold is breached— can we introduce a time window? Can the window be rolling? There you have a circuit breaker, without mentioning one explicitly. Thread safety, complexities, trade-offs and abstractions are some additional topics that can be explored here.</p><p>Feel free to go in-depth and probe where you feel necessary. Let as much of it flow naturally as possible, and the further the candidate makes it through the journey, the stronger the candidate you have on your hands.</p><p>Remember to look for soft skills as you journey with the candidate: Did you enjoy working with them? Did they give up too easily when faced with a challenge they had not experienced before? Did they stay on point or lose focus? As good a candidate may be, it is important to look out for personality traits &amp; values that align with the team &amp; organisation they are interviewing for.</p><p>Finally — don’t expect to get everything right in your first few interviews. Whenever you have a doubt, it is safer to turn down the candidate than incur the costs associated with making a bad hire. Practice makes perfect, so keep racking up the interviews.</p><p>Good luck with conducting your next great coding interview!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f6f227352bd5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>