<?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 Daniel Sjöström on Medium]]></title>
        <description><![CDATA[Stories by Daniel Sjöström on Medium]]></description>
        <link>https://medium.com/@daniel.sjostrom_3181?source=rss-ff55eae8f2c0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Daniel Sjöström on Medium</title>
            <link>https://medium.com/@daniel.sjostrom_3181?source=rss-ff55eae8f2c0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 03:33:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@daniel.sjostrom_3181/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[The Lego Test: An unscientific scientific experiment]]></title>
            <link>https://medium.com/nordnet-tech/the-lego-test-an-unscientific-scientific-experiment-85dd215a7f94?source=rss-ff55eae8f2c0------2</link>
            <guid isPermaLink="false">https://medium.com/p/85dd215a7f94</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[experiment]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[mob-programming]]></category>
            <category><![CDATA[ab-testing]]></category>
            <dc:creator><![CDATA[Daniel Sjöström]]></dc:creator>
            <pubDate>Mon, 19 Aug 2024 09:11:41 GMT</pubDate>
            <atom:updated>2024-08-19T09:11:41.939Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9bymNMnk65fcBo552MTv2w.png" /><figcaption>Woody, Sara, and I talking at a meetup</figcaption></figure><p>At Nordnet we have noticed that when we work on a problem with everyone that is needed to solve the problem (engineers, research, design, business and more) at the same time then great things start to happen almost immedietaly. We get a sense that:</p><ul><li>We solve problems quicker</li><li>We are happier at work</li><li>We produce results with a higher quality (fewer bugs)</li></ul><p>Some people call this way of working mob programming, some call it eXtreme programming, some agile, and others call it just work.</p><p>But whatever you choose to call it is not important, what’s important is to let design, new ideas, requirements, quality assurance emerge as we are actively trying to solve the problem. In contrast to trying to approach the problem in a deterministic way by writing detailed plans, conducting design phases, and handing off the work to the QA team in the end.</p><h3>Making a plan vs. no plan</h3><p>We have a gut feeling that we are quicker and happier when work happens as we go, but we have never really been able to figure out what the differences are to the more planned approach. Is it less stressful, if so why? Is the quality really better? Are we happier?</p><p>To find this out we decided to conduct an experiment. Our idea was to split into two different teams (a real life A/B test), both of which would be tasked with building a tower made out of Lego. One group had to write a detailed plan while the other group could build as they go. The experience from building, designing, and of course how the towers would look like would then be able to help us see what the differences are.</p><p>Both teams had the same task (to build a tower) but they had to approach it differently:</p><p><strong>The traditional-project-team:</strong></p><ol><li>Specify the requirements for the Lego tower for the next team</li><li>Build the tower according to the requirements from the other team</li><li>Conduct a quality assurance phase</li></ol><p><strong>The build-as-you-go-team:</strong></p><ul><li>Design, build, and test at the same time</li></ul><p>Now we knew what to test and how, we were just missing the participants.</p><h3>The bricks started to fly</h3><p>On one chilly Stockholm afternoon we had invited Woody Zuill[1] to come and talk with us about mob programming. About 50 eager engineers and practictioners showed up, all from other companies around Stockholm.</p><p>This was the perfect setting for trying out our experiment! First Woody Zuill held a presentation on communication and collaboration, and after that everyone that wanted to got the chance to participate in the Lego building.</p><p>After we had divided them into teams and given them the instructions then they were all eager to start. The bricks started to fly into place from left and right for the build-as-you-go-team team.</p><p>In contrast, the traditional-project-team, that much like the decision makers do at a company gathered in a dimly lit conference room, where they isolated themselves from the rest of the world. There they sharpened their pencils, and started to write down the requirements for their ultimate Lego tower.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z4cPpxbrqHSUeUbma-7PgA.png" /><figcaption>Left: building immediately. Right: planning and writing</figcaption></figure><p>The team that had to write the requirements knew that they were going to have to hand over requirements to another team that then would have to do the building. It was noticeable that this was a fun phase, everyone’s plans of a dream tower came to light and they were allowed to write down any design that they would want.</p><p>The only problem was that another team would have to make the dream come to life. This is an insight from one of the team members when writing the requirements:</p><blockquote>You start off trying to be nice to the builders, but quite quickly we all just went screw it: lets make the tower as impressive as possible!</blockquote><p>In a way it’s only natural, you only get this one shot at designing the perfect solution so you’d better make it count. If it is trivial or challenging to build is something that you don’t know, that is up to the next team to figure out.</p><p>While the traditional-project-team was busy writing requirements the build-as-you-go-team had already started to build their tower.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X9chuLgTokaewW2HNES7Yw.png" /><figcaption>Left: half-way done. Right: just finished the tower requirements</figcaption></figure><p>Now it was time to pass off the requirements to the team that were going to build and also to receive the requirements from the other team. Now the team that once were the decision makers had to start building. Time was short and expectations were high.</p><p>Instantly they tried to make sense of the requirements from the other team, quickly questions started to rise: It says 5 windows here, but where should they be placed? One pond, how does a Lego pond look like? 50 bricks for a bed, that’s a lot.</p><p>But there was no time to try to make sense of it it all, instead they just had to start building and try to follow the instructions to the best of their abilities. Plus the team that had written the requirements were now busy with other things.</p><p>One thing that they quickly found out was that it was a stressful and challenging experience to try to achieve what was specified in the requirements. While at the same time the build-as-you-go-team could just continue to carefully place one brick at a time.</p><h3>How the towers turned out</h3><p>As you might imagine the tower made by the emergent team was undoubtedly better. But not only was the tower better but also their experience.</p><p>The team had managed to build the tower without feeling any pressure or stress, the team members were happier, and they were able to be creative in the moment, tweaking and adjusting as they went along.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xeFUcUSPPBc616QD8RpvjQ.png" /><figcaption>Left: The build-as-you-go-team’s tower. Right: The traditional-project-team’s tower</figcaption></figure><p>As you can see in the image above the difference is definitely visible. However the traditional-project-team managed to deliver what was expected of them in the requirements, there was a “tower” made out of 25 bricks, there was a big yellow bed, and there was a pond although a very tiny one (one blue brick).</p><p>While the build-as-you-go-team managed to also build a tower but it was much bigger. There was not only a pond, but a pool with a trampoline, a fish statue, a balcony, trees, and so much more.</p><h3>What did we learn?</h3><p>So what learnings can we take with us into creating software from building Lego? Well in all honesty the two of them does not have that much in common, but one thing that they do share are that they are both creative processes.</p><p>In creative processes, creativity usually happens when you are actually performing the work. So it was difficult for the traditional-project-team to be creative when building from a requirements list because someone had already tried to be creative for them in the design phase. Much like it was difficult for them in the design phase to understand what would be trivial or challening to build.</p><p>The build-as-you-go-team never faced these challenges because creativity could happen for them in the moment. They could build, test, and discuss what the best solution would be with basically no waiting time at all.</p><p>Therefore, let’s embrace the build-as-you-go-team’s tactic and just start building things together, that way we will: solve problems quicker, be happier at work, and produce better results.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=85dd215a7f94" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nordnet-tech/the-lego-test-an-unscientific-scientific-experiment-85dd215a7f94">The Lego Test: An unscientific scientific experiment</a> was originally published in <a href="https://medium.com/nordnet-tech">Nordnet Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Oh what a feeling — Principles from the Toyota production system]]></title>
            <link>https://medium.com/nordnet-tech/oh-what-a-feeling-principles-from-the-toyota-production-system-c12980fb35e8?source=rss-ff55eae8f2c0------2</link>
            <guid isPermaLink="false">https://medium.com/p/c12980fb35e8</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[methodology]]></category>
            <category><![CDATA[toyota]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[product]]></category>
            <dc:creator><![CDATA[Daniel Sjöström]]></dc:creator>
            <pubDate>Mon, 14 Aug 2023 08:23:36 GMT</pubDate>
            <atom:updated>2023-08-14T08:42:30.634Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Oh what a feeling — Principles from the Toyota production system</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*4-s3u5ql9TlD1oHR1QNQuw.png" /><figcaption>You aren’t gonna need it (YAGNI)</figcaption></figure><p>The Toyota production system has been used as a source of inspiration to collect methods and techniques for agile and lean workflows long before agile and lean even were a thing. What is often overlooked though is the principles behind the methods and the techniques. Maybe those principles can tell us more on how to replicate the success from Toyota 60 years ago than what the methods and techniques can?</p><h3><strong>Started from the bottom now we’re here</strong></h3><p>In the Toyota factory, they had to constantly manage the fluctuations from producing too many parts, to not enough parts. In order to handle this problem, they came up with the method of “production leveling”. Production leveling attempts to flatten the production curve so a steady flow of parts is being produced all the time[1]. For example, why should you spend 20 minutes producing 20 bolts and only use 10 now, when you can spend 10 minutes producing the 10 bolts that you actually need. Freeing up 10 minutes to produce value elsewhere.</p><p>We can translate this to software development. The upper part of the production curve would represent overdelivery, building unnecessary features, and adding processes. The lower part of the curve would then be underdelivery, low quality, and a defective product.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UcHwX75iBCa1W7ndy3xTZQ.png" /><figcaption>Image 1: Quality going up and down</figcaption></figure><p>Often times we end up in the upper area of the curve. This is, in a sense, a good problem to have. We have the means and the abilities to create high quality work, so we do. But starting at the top can lead to wasted work in terms of overengineering, long delivery times, and unnecessary overhead.</p><p>What’s dangerous though, is that there is an alluring sense of completion and closure that comes with the top of the curve, which can be as soothing as a warm sauna when it’s -22 degrees outside. However, overdelivering will lead to you and your team spending valuable time working on solutions for problems that does not exist. You are producing 20 bolts when you only need 10.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NjW9TLXG42dYtn-Vv24_yw.png" /><figcaption>Image 2: Quality steadily increasing as time moves along</figcaption></figure><p>Luckily, in software it is cheap and easy to incrementally improve, so it is usually better to start at the bottom of the curve instead. But it is uncomfortable and difficult to start at the bottom. If you want to start at the bottom you will have to release software to customers with a little bit of shame and unease in your stomach. However, doing so will ultimately make it easier to gather feedback, building only what needs to be built, and learning more about the problems that the product or the feature is designed to solve.</p><p>Toyota wanted to flatten the curve (image 1) as much as possible[1] to reduce waste but for software products we can instead incrementally improve so let’s try to make the curve grow from left to right instead (image 2). Increasing value, removing bugs, and adjusting according to feedback as we go along.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I0II4LpeFesXRkEhCkjNWQ.png" /><figcaption>Image 3: Incremental releases that increases the quality</figcaption></figure><p>In the Toyota factories they trained their workers to be able to operate more than one machine at a time, which makes it possible for the factory to easily allocate their production towards where it is most needed[1]. Releasing software incrementally enables us to do the same thing as Toyota did 60 years ago. If something more important comes up than what is being worked on right now it is uncomplicated to shift focus, and when focus shifts, some software and therefore value (hopefully) has already been delivered.</p><h3><strong>You aren’t gonna need it (YAGNI)</strong></h3><p>One of the easier ways of starting at the bottom is through problem pruning. The first iteration does not have to solve many different problems, it will only have to give some form of initial relief for one single problem. Just like the epa-dunk[2] duo Hooja and Mårdis sings “<a href="https://youtu.be/C9foCEfWMgM?t=48">there was no camera on the iPhone 2</a>”*.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GQvKAi_QX-maj_qeSRJmSw.png" /><figcaption>Image 4: Hooja, Mårdis, and Steve presenting the iPhone 2 to the world</figcaption></figure><p>Not adding a camera on the first iPhone made it possible for Apple to focus on what they thought were more important things to focus on. The learning from Steve Jobs and co is then that solving just one problem will reduce the inventory in terms of tasks in the backlog, reduce the risk of overproduction, and reduce processes. All good things according to the Toyota production system[1].</p><p><em>*there was a camera at the back of the iPhone 2, but there was no selfie cam.</em></p><h3><strong>Teamwork makes the dream work</strong></h3><p>In the Toyota factory they needed to come up with a system that could support production leveling, zero waste, and just in time and through that Kanban was born. Kanban was used as a sort of work order as it moved together with the needed goods from one process or team to another[1].</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3ZM3sThdAiVbh7NUet1Aeg.png" /><figcaption>Image 5: The teams earlier in the process delivers to the teams later in the process</figcaption></figure><p>One of the problems that Kanban was designed to solve was to minimize overproduction, the team to the right could ask the team to their left exactly the number of nuts, bolts, and parts that they needed from them. Then when the parts were finished, they arrived together with the attached work order, just in time and in the correct quantity[1].</p><p>That’s a pretty neat and simple system to keep track of things and to minimize overproduction in a factory. Similar Kanban-like systems have been adopted for software teams in order to solve similar problems[3].</p><p>But writing software is different from the work that is happening at the plant. Writing good software is a messy and creative process where we stumble around trying to figure out what’s going on and we try to learn to the best of our abilities what we are actually doing. In contrast to the process that Toyota uses when producing cars, the rules have been decided before the race begins in a sense, there are less unknowns.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/831/1*wRdYjolOg6xQxrIV1NRTBw.png" /><figcaption>Image 6: Drake prefers to collaborate</figcaption></figure><p>Luckily for software teams, work doesn’t have to flow from left to right, we can instead embrace the messy, creative process and work more closely together between different disciplines and domain areas. Simply put the business, engineering, and design should and can work on the same problem at the same time. When we are collaborating like this (image 6), the need for looking ahead, planning, and predicting diminishes. Instead, the need for learning, collaborating, and adjusting from feedback increases.</p><p>Which is a good thing! Since just like Taiichi Ohno from Toyota writes:</p><blockquote>As long as we cannot accurately predict the future, our actions should change to suit changing situations[1].</blockquote><h3>In conclusion</h3><p>I like principles, fundamentals, and defaults because they let organizations, teams, and individuals to be creative within their constraints. There is room for innovation, improvements, and reflections inside of a box that is built by principles in contrast to a pre defined system. Maybe that is one of the reasons why Toyota was or rather is so successful: because they are driven by principles over techniques[1]. In this post however, we have primarily looked at the techniques and methods that Toyota has implemented to support their principles. Here’s what we can learn from those techniques:</p><ul><li><strong>Production leveling</strong> maps to learning, adjusting from feedback, and incrementally adding value.</li><li><strong>One worker many machines</strong> maps to the ability to direct our energy towards the most important problem right now.</li><li><strong>Kanban</strong> maps to embracing the messy and creative software development process and collaborating between different disciplines.</li></ul><h3>References</h3><p>[1] The Toyota production system <a href="http://dspace.vnbrims.org:13000/jspui/bitstream/123456789/4694/1/Toyota%20Production%20System%20Beyond%20Large-Scale%20Production.pdf">http://dspace.vnbrims.org:13000/jspui/bitstream/123456789/4694/1/Toyota%20Production%20System%20Beyond%20Large-Scale%20Production.pdf</a></p><p>[2] Epadunk Wikipedia page <a href="https://sv.wikipedia.org/wiki/Epadunk">https://sv.wikipedia.org/wiki/Epadunk</a></p><p>[3] Kanban (development) Wikipedia page <a href="https://en.wikipedia.org/wiki/Kanban_(development)">https://en.wikipedia.org/wiki/Kanban_(development)</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c12980fb35e8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nordnet-tech/oh-what-a-feeling-principles-from-the-toyota-production-system-c12980fb35e8">Oh what a feeling — Principles from the Toyota production system</a> was originally published in <a href="https://medium.com/nordnet-tech">Nordnet Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[24 Months of mob programming]]></title>
            <link>https://medium.com/nordnet-tech/24-months-of-mob-programming-7846ceb54e3e?source=rss-ff55eae8f2c0------2</link>
            <guid isPermaLink="false">https://medium.com/p/7846ceb54e3e</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[mob]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[mob-programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Daniel Sjöström]]></dc:creator>
            <pubDate>Thu, 09 Mar 2023 08:17:42 GMT</pubDate>
            <atom:updated>2023-03-09T11:32:21.769Z</atom:updated>
            <content:encoded><![CDATA[<p>Like many of the software teams at Nordnet, the app team practices mob programming and have done so for 24 months now. We have been doing everything from discovery, ideation, interviewing, onboarding, coding, designing, and every other task that you can think of at a modern tech company together, as a mob. For most of the time the mob format has felt natural and easy to use but sometimes it has felt difficult and unnatural. This post is about our shared experiences, ups and downs, writing the Nordnet mobile app together every day, for 24 months.</p><h3>TLDR</h3><ul><li>Mob programming enabled us to triple our release cadence.</li><li>Mob programming helps us to get into the flow better than when working solo.</li><li>Mob programming is a skill, it requires a lot of work to get good at, so we needed weeks rather than days when we were evaluating it.</li><li>Mob programming is just a tool, however it is a very powerful tool.</li></ul><h3>How we started mob programming</h3><p>The team had tried mob programming previously, before we started using it full time, with varied success. The difference back then was that it was used sporadically and quite often for unusually difficult tasks, which is necessarily not a bad way to go about it. One of the core ideas behind mob programming is that a team of programmers is stronger together than any individual is on their own, so using the mob format for unusually difficult tasks is a great use case for it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SxVhYVvcYTR4-XGBYhwoNQ.png" /><figcaption><em>Knowledge level for a certain skill. The individual vs. the mob.</em></figcaption></figure><p>However, it is probably not where a team wants to start when they are new to working together in this format. That is because, much like anything at work, mob programming is a skill. When you start out trying a new skill for the first time you are most likely going to have a hard time, simply because you are new at doing it. Which is okay! It is fun and engaging learning new things. Especially new difficult things. But, it is more fun and engaging if you start off under the right conditions.</p><p>Nordnet frequently invites talented speakers on different topics, and one rainy week in November 2020 Woody Zuill[1] visited us to talk about the power of mob programming. The team felt inspired, and eager to try it out after the talk so we laid out a plan during our last zoom call before the weekend that Friday afternoon. We had decided that if we would try mob programming again we should sit down and program together for at least one <em>major</em> feature and then evaluate after that. So, come Monday morning, we all joined the same Zoom call and started working on the same feature.</p><p>The feature we were building was nothing special, it was just a way for customers to receive and read messages that our Customer Service team sends out. But the higher difficulty and the larger scope of the task meant that it felt like a perfect opportunity to try out mob programming. If the feature that we had decided to build together had felt too easy or too difficult then it would’ve been problematic to evaluate our new way of working. But this particular task we felt hit just the right spot in terms of complexity.</p><p>About four weeks later we had the feature in place and out in production. We felt hooked with our new way of working because it had enabled us to move faster, share knowledge between each other, and have shorter feedback loops (no more code reviews).</p><h3>But… mob programming is inefficient!</h3><p>One of the more common arguments against mob programing is that it is an inefficient method to write software. For example, one might say:</p><blockquote><em>“Why do you have 3–5 developers working on one thing at the same time, when you can have 3–5 developers working on 3–5 things at the same time? That way you could get much more tasks done in the same time as it takes to finish one task!”</em></blockquote><p>However, we found that this was simply not the case. Doing loads of tasks at the same time created it’s own set of problems. Like only one person knowing how a particular feature worked, context switching between it all, and the need for different types of sync meetings to try to solve the forementioned problems. Narrowing down on only 1–2 tasks allowed us to have a higher focus, deliver with a higher quality, and be more productive.</p><p>Quantifying productivity is tricky and there are many factors to it, but if one looks at the release cadence before and after we started mob programming, it paints a pretty good picture that practicing mob programming lead us to develop new features, <em>more</em> efficiently:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1baDIpoyMScQyjsAvVH3AA.png" /><figcaption><em>Release cadence for Nordnets mobile app.</em></figcaption></figure><p>We don’t think that it’s <strong>this</strong> easy though. We didn’t just start mob programming and then see our release cadence triple over night. Mob programming helped us with improving our release cadence, but it was not mob programming <em>itself</em> that did it.</p><p>We found that working in this closely collaborative way, having few tasks ongoing at the same time, and having shorter feedback loops, made it much easier to improve on our other processes. Mob programming effectively <em>enabled</em> us to see other ways in which we could improve.</p><h3>Getting into the flow</h3><p>One discovery that we did not anticipate, was how much easier it would be to end up in a state of “flow” during a mob, than when you were working on your own. By “flow”, we mean that special feeling when the level of difficulty and your level of skill matches up perfectly and you enter this completely involved &amp; focused mental state, where time just flies by. I think if you have done some form of development we’ve all experienced this, it is probably one of the reasons many of us chose this profession to begin with, since being in a flow can be very enjoyable and highly addictive.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MLdsnSAKepakJ4xkjdOBrQ.png" /><figcaption><em>The flow funnel. The individual vs. the mob.</em></figcaption></figure><p>If we depict difficulty on one axis and skill on the other, just like in the figure above, then flow is what happens between those two areas. If a task is too easy, then it might feel a bit boring or mundane; If a task is too difficult, then it might feel hopeless or anxious. The trick to entering a flow state is to work on a task that sits right in that sweet spot. We believe that it is easier to find that sweet spot in a mob, in comparison to working alone because you are able to help each other out in real time.</p><p>We are all good at different things and we all have different types of skills, so it’s easy to pick each other up and that way widen the sweet spot where flow happens.</p><h3>Learnings &amp; challenges</h3><p>We’ve had many successes and good experiences from working together in this way, but it is still important to remember though that mob programming is a tool, much like anything else. It is not a way of life or something everyone has to practice every day, 8 hours per day. It has, however, turned into a good default for us, and we’ve seen that basically every single metric has improved since we’ve started mob programming and as we get better at doing it. But all good things aside, much like any method mob programming has it’s own set of challenges, here are some of the ones that we’ve faced:</p><ul><li>Too big mob sizes, we found that when we were over 4 it hurt us more than it helped us.</li><li>We all have different preferences to doing work, and mob programming is not for everybody.</li><li>Having more than one mob developing features at the same time creates new problems.</li></ul><p>These are some of the learnings that we’ve had:</p><ul><li>With mob programming it is easier to adjust and improve on the teams processes.</li><li>It instantly solves common software engineering problems, like knowledge sharing, syncing between team members, and removes overhead.</li><li>It is a social way of working, and a great way to satisfy your social needs during remote work.</li></ul><p>If you are eager to try out mob programming in your team then our recommendation would be to evaluate it over an extended period of time (don’t just do an afternoon). Try to look at it as a way to enable your team to remove obstacles that you haven’t been able to remove before. Oh, and have some fun with it! Working like this is, above all, a lot of fun!</p><p>[1] Woody Zuill webpage: <a href="https://woodyzuill.com/#speaking">https://woodyzuill.com/#speaking</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7846ceb54e3e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nordnet-tech/24-months-of-mob-programming-7846ceb54e3e">24 Months of mob programming</a> was originally published in <a href="https://medium.com/nordnet-tech">Nordnet Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>