<?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 Slobodan Dan on Medium]]></title>
        <description><![CDATA[Stories by Slobodan Dan on Medium]]></description>
        <link>https://medium.com/@danastroman?source=rss-96313f69ff61------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*AbjaxVbpj3ik9xcyYxyGMQ.jpeg</url>
            <title>Stories by Slobodan Dan on Medium</title>
            <link>https://medium.com/@danastroman?source=rss-96313f69ff61------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 10:32:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@danastroman/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 Left Can You Shift?]]></title>
            <link>https://medium.com/geekculture/how-left-can-you-shift-aedf42d73f78?source=rss-96313f69ff61------2</link>
            <guid isPermaLink="false">https://medium.com/p/aedf42d73f78</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[lean]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[shiftleft]]></category>
            <category><![CDATA[continuosdelivery]]></category>
            <dc:creator><![CDATA[Slobodan Dan]]></dc:creator>
            <pubDate>Wed, 28 Apr 2021 05:03:10 GMT</pubDate>
            <atom:updated>2023-01-14T18:57:25.834Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pzfI5U8BfJJqy-Az_FgQ7w.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@giuliamay?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Giulia May</a> on <a href="https://unsplash.com/s/photos/left?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Now I’m not sure what you’re thinking coming into this text, dear reader, but I’d like to let you know straight away that shifting left isn’t about the welfare state. At least not in this article.</p><p>With that out of the way, what does shift left mean in software development?</p><p>Kirstie Magowan defines it rather elegantly <a href="https://www.bmc.com/blogs/what-is-shift-left-shift-left-testing-explained/#:~:text=Shift%20Left%20is%20a%20practice,in%20the%20software%20development%20process.">in her blog</a>:</p><blockquote>Shift left is a practice intended to find and prevent defects early in the software delivery process.</blockquote><p>Although this pretty much nails it, I’d like to extend the definition a tiny bit and say that <strong>shift left is the practice of getting faster feedback about your work</strong>. It’s not just about defects.</p><p>So how do we do this?</p><p>Let’s look at a few areas where we can apply this practice.</p><h3>Code review</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Csm7xy09_3jugojv96dXuQ.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@alvarordesign?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Alvaro Reyes</a> on <a href="https://unsplash.com/s/photos/code-review?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>I’ve long been a very vocal and avid supporter of code reviews. I maintain that you should commit small changes to source control and have them reviewed as you go.</p><p>So, this shifts code review left. But we can do better. Much better.</p><p>Although the code review process is incredibly valuable, it’s not a very efficient process. When presented with a large amount of code, <a href="https://smartbear.com/learn/code-review/best-practices-for-peer-code-review/">we tend to skim it</a>, rather than review it, or as Giray Özil nicely put it:</p><blockquote>Ask a programmer to review 10 lines of code, he’ll find 10 issues. Ask him to do 500 lines and he’ll say it looks good.</blockquote><p>The conversation might look something like this:</p><p><em>Tech lead: “So… does it work?”</em></p><p><em>Developer: “Yep.”</em></p><p><em>Tech lead: “Well… I guess it’s ok. We’ll fix it later.”</em></p><p>No. You won’t. Let’s fix it now.</p><p>How? Try <strong>pair programming</strong>.</p><p>You can take turns with your teammates and get immediate feedback on business logic, error checking (best done on someone else’s chessboard, isn’t it?), code style and even IDE use — God knows I’ve learned the best IDE tricks watching someone else type.</p><p><em>“Wait, wait… the thing that you just did — how did you do that?”</em></p><p>I’d even suggest making it mandatory. Your organization will be better off for it, and you’ll find most developers enjoy the experience. Especially now that so many of us are working remotely, the humanizing effect is immeasurable.</p><h3>Quality</h3><p>Have you ever realized somewhere along the way that your software has too many features to be reliably tested manually? I’ve found myself in this situation more times than I’d like to admit.</p><p>As it turns out huge manual regression suites aren’t a good quality control measure when faced with increasingly complex software. They’re not sustainable. Heck, they’re not even reliable! And who really wants to go through thousands of steps to check every nook and cranny to make sure the software still does what it’s supposed to?</p><p>So, yes, we must write automated tests. But which ones?</p><p>The <a href="https://testing.googleblog.com/2015/04/just-say-no-to-more-end-to-end-tests.html">Google testing pyramid</a> says it all: write very few, very critical (but very robust!) end-to-end tests, a few more integration tests, and a metric ton of unit tests. How many? 10%, 20% and 70% respectively.</p><p>Yay unit tests!</p><p>So just write a ton of unit tests — case closed, right? Well… maybe.</p><p>Lately, I’ve been thinking that we may have been doing QA wrong all these years. Perhaps testing is the least important part a QA engineer’s job. But that’s a topic for another post.</p><h3>Build and deploy</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RAWzXWMnZ5YaGHudiAJn2g.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@randyfath?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Randy Fath</a> on <a href="https://unsplash.com/s/photos/build?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Do you or your developers occasionally merge something that breaks the build?</p><p>Sure, we should all build our code before we merge, and I’m sure that you do, dear reader. I, however, sometimes, in a hurry, forget my due diligence and I suspect there are a few others like me.</p><p>Rather than relying on developer discipline, I prefer automated pre-merge pipelines. That way whoever is looking at the pull request will be able to see that the code breaks the build before it’s merged. The pre-merge pipeline should use identical build scripts and configuration to production builds, and it should be checked in to source control.</p><p>Similarly, the deployment scripts and configuration should also be in source control and used for every environment that you deploy to.</p><p>To complete the trifecta, check the infrastructure configuration into source control and instantiate resources based on this configuration. This way environment provisioning also becomes testable and predictable.</p><h3>Security</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wzlipL-tmDVFo1nBt8czwA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@matthewhenry?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Matthew Henry</a> on <a href="https://unsplash.com/s/photos/security?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>I see three straightforward ways to shift left on security: planning, education and automated testing.</p><h4>Planning</h4><p>Involve your security experts from the get-go. Tell them what you are planning to build and for whom, and which components and interfaces your system is likely to have. In return, they’ll be able to tell you early on about potential vulnerabilities and data protection issues, so that you can weave these into your user stories and architecture.</p><h4>Education</h4><p><a href="https://owasp.org/www-project-top-ten/">Security risks</a> and <a href="https://medium.com/ft-product-technology/a-developers-guide-to-gdpr-that-won-t-make-you-sweat-4f1f7f1d9c8b">data protection</a> should be an integral part of continuous learning for every developer. The more developers interact with these topics, the more it becomes a natural part of their thinking. Time should be set aside for courses and training.</p><p>Another way to teach security is with penetration test training. I’ve got great engagement when training this on our own software. There is something strangely fun about trying to break the very thing that you’ve built.</p><h4>Automated Testing</h4><p>Finally, when the code is in, you should run automated security tests. These can be custom made by your development, QA or security teams or provided by 3rd party tools like <a href="https://www.zaproxy.org/getting-started/">OWASP ZAP</a>.</p><h3>So how left can you shift?</h3><p>As you can see shift left is not just about detecting defects, although it is the focal point of the practice. It’s about continually learning how you can do better from the start, up until the point where you can <a href="https://kanbanize.com/continuous-flow/jidoka">get it right the first time</a>.</p><p>If you are not already doing most of these, you might be thinking: That’s a boatload — where should we start?</p><p>My recommendation? Start with pair programming. I can’t overstate the value of this practice. You get team building, learning, code review and quality work all in one package. I promise, you won’t regret it.</p><p>Next, a good CI/CD pipeline goes a long way. Put the automated checks and tests to work and declare a green build policy. It will prevent a lot of superfluous work.</p><p>The rest is up to you. All of these are important and all of them pay dividends, but some are less obvious to implement and depend somewhat on your team and company structure.</p><p>I wish you the best of luck on your journey!</p><p>Keep calm and shift left.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aedf42d73f78" width="1" height="1" alt=""><hr><p><a href="https://medium.com/geekculture/how-left-can-you-shift-aedf42d73f78">How Left Can You Shift?</a> was originally published in <a href="https://medium.com/geekculture">Geek Culture</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Growing Your Monolith]]></title>
            <link>https://medium.com/geekculture/growing-your-monolith-9f53bd205e7c?source=rss-96313f69ff61------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f53bd205e7c</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[team-management]]></category>
            <category><![CDATA[best-practices]]></category>
            <dc:creator><![CDATA[Slobodan Dan]]></dc:creator>
            <pubDate>Mon, 15 Mar 2021 15:03:02 GMT</pubDate>
            <atom:updated>2021-03-15T15:03:02.009Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O1tODuaf4jXY7LTzOHTs-A.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@hulkiokantabak?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Hulki Okan Tabak</a> on <a href="https://medium.com/s/photos/monolith?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>So you have a great idea for a software project and have decide to make it into a website. You have a small team and you decide to keep it simple and just put the whole thing in one place. You build a small server-side rendered application talking directly to the database.</p><p>In a month or two, you develop rapidly, the code is all in one place, it can be debugged and read easily and your product is adored by your users. You hit the spot — congratulations! Now it’s time to grow…</p><h3>Front and back end</h3><p>Perhaps you hire a few more developers, you push out more features and your codebase is starting to grow. With more developers working on the same codebase, you find that more often than not two or sometimes more developers are working on the same code and merge conflicts become more regular.</p><p>You decide to split your codebase.</p><p>The most intuitive next step would be to split the codebase into a client application and an API. However, there is a tradeoff:</p><p><strong>Advantages</strong>:</p><ul><li>Separation of concerns (the API is concerned with business logic and persistence while the client is concerned mostly with presentation and user interaction)</li><li>Two repositories make conflicts less likely</li><li><strong>Intrinsic cognitive load reduced because developers can now focus on either front or the back end</strong></li></ul><p><strong>Disadvantages</strong>:</p><ul><li>Entities, validation and some business rules are now likely duplicated in the client and API</li><li>The client application now must keep track of API interfaces it communicates to</li><li>You need to build and deploy the client and API separately</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ytWD8Y-GXXkjXEEW59VzDA.jpeg" /><figcaption>Photo by <a href="https://www.freeimages.com/photographer/asifthebest-44246">Asif Akbar</a> from <a href="https://freeimages.com/">FreeImages</a></figcaption></figure><h3>A common module</h3><p>The codebase is still not too big and you keep on commiting and pushing code, now with a more flexible setup. There are now two teams, one taking care of the front end and the other taking care of the backend. The codebase is getting bigger, and the front and backend get more and more out of sync. This results in bugs and more (unnecessary) communication between team members (perhaps even some blaming), as well as the necessity to look over the implementation in the other codebase, and reflect the changes made.</p><p>Obviously you need some common language between front and the backend. So you decide to make a package that will hold logic that both the client and the API will consume. There is, unfortunately a hefty price to pay for this, too.</p><p><strong>Advantages</strong>:</p><ul><li>A good chunk of the code is no longer duplicated</li><li><strong>Business logic can be kept safe and tested</strong></li><li>Changes made to the common package are now reflected in both client and API</li></ul><p><strong>Disadvantages</strong>:</p><ul><li>You have a third repository, likely maintained by both teams</li><li>The client and API need to keep up to date with the latest changes on the common module</li><li><strong>The common module has different rules for writing and building code than both the front and back end</strong></li><li>You need to create, maintain and possibly pay for a repository for the common module packages</li><li><strong>Developers need to understand semantic versioning and adhere to it</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8-AxYGTRqCQmXLkTFKFfAQ.jpeg" /><figcaption>Photo by <a href="https://www.freeimages.com/photographer/inapap-54021">Christina Papadopoullou</a> from <a href="https://freeimages.com/">FreeImages</a></figcaption></figure><p>As you can see, it already becomes less clear whether or not you are gaining value from this change.</p><h3>The services</h3><p>By now your small company has grown to three or four development teams, and the codebase has grown accordingly. The software now has many features, many entities and business rules.</p><p>It has become obvious that there are separate portals on the front end, and that these portals communicate with specific endpoints more than others.</p><p>The knowledge of the whole business and how different parts of the software operate is becoming a burden too big for any developer to bear, so you decide to make the next leap.</p><p>Hopefully you have kept your code clean and your contexts bounded, and it is at least possible for you to make the transition — it’s time to split the back end into services, and at least logically split the front end into parts concerned with separate business domains. As you might have guessed, it’s not just going to be sunshine and roses. Let’s take a look at the tradeoffs:</p><p>Advantages:</p><ul><li><strong>The API is split into several repositories containing similar business logic, reducing the cognitive load on the team</strong></li><li>There is once more less merge conflicts and less commits that any one developer is behind from the main branch</li><li>There is less communication needed from different teams</li><li>Ideally each team has a set of modules encapsulating business logic in entities and interfaces</li><li>Each service has a separate, smaller database</li></ul><p>Disadvantages:</p><ul><li><strong>The code is harder to run and debug</strong></li><li>The service communication is harder to orchestrate in the infrastructure</li><li>The services need to communicate with other services to maintain data consistency</li><li>Authentication needs to be centralized</li><li><strong>The system as a whole is much harder to understand</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ua_GhN6_ZzhWJLBZ77DICw.jpeg" /></figure><p>So was it worth it? Well… maybe. Before we conclude. Let’s take another step.</p><h3>The event bus</h3><p>The inter-service dependence is becoming too big and the instability of different components of the system is causing the whole system to go down and incidentally, driving you mad.</p><p>To decouple the services and take care of all those nasty data inconsistency issues, as well as provide a more stable environment for your users, you decide to start using an event bus.</p><p><strong>Advantages</strong>:</p><ul><li>Services no longer have to call other services</li><li>Data is synced safely and quickly</li><li>You know exactly how to communicate with other services — you emit events</li></ul><p>Disadvantages:</p><ul><li>API developers now must learn how to use the chosen event bus</li><li><strong>Developers must learn to think in terms of events</strong></li><li>Services taking care of shared entities now must emit events and other services must consume them</li><li><strong>The application flow is extremely hard to understand in some cases</strong></li><li>Orchestration of events becomes a possible issue</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U9m6G5AxWLhKK9PAwsDMvg.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@yannikm?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Yannik Mika</a> on <a href="https://medium.com/s/photos/post-office?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><h3>When to take the step</h3><p>I’m sure that complicating your decisions by presenting you with the tradeoffs you are going to make did not make your job easier. I will not even try to pretend to have the answer, but what I can do is suggest a rule of thumb:</p><p><strong>Take the step when the cognitive load of the teams in the current state becomes greater than what you would have by taking the next step towards a more distributed system.</strong></p><p>But how can you tell when that is? Listen to the people. Are they complaining? What are they complaining about? How often?</p><p>If you’ve heard from six out of ten developers that they hate it that they have to maintain the same thing in the front and back end, it’s more likely that extracting this logic into a module is going to yield a net benefit.</p><p>Still, if most of them need to learn to write unit tests, maybe reconsider adding more knowledge debt to the pool.</p><p>Which leads us nicely into the reason to write this piece in the first place.</p><h3>Sustainability</h3><p>Much too often we plan for big projects and rapid growth, almost never asking ourselves — will it be sustainable?</p><p>I would say that such grand plans rarely are. It’s nice if you’re successful and can afford this rapid growth, but throwing more people at the problem will only last you so long, until the people that built the thing and contain all of the siloed and undocumented knowledge start leaving for all kinds of reasons.</p><p>Achieving sustained growth is a bit more straightforward than measuring cognitive load. Here’s some of the things you might need to do:</p><ul><li><a href="https://rework.withgoogle.com/print/guides/5721312655835136/#:~:text=The%20Google%20researchers%20found%20that,twice%20as%20often%20by%20executives."><strong>Build trust in your teams</strong></a></li><li><a href="https://dzone.com/articles/accelerate-a-principle-based-devops-framework">Follow proven industry best practices</a></li><li><a href="https://getnave.com/blog/kanban-metrics/#:~:text=The%20two%20Kanban%20metrics%20that,are%20connected%20by%20Little&#39;s%20Law.">Control the intake and measure the flow of work</a></li><li><a href="https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html">Build loosely coupled components</a></li></ul><p>When you decide to start on this journey of sustainability, don’t do it all at once. Introduce more good habits and practices, only when most of the people have incorporated the ones you already introduced.</p><h3>Conclusion</h3><p>More often than not people think that a new hot technology or architecture is the best thing since sliced bread, but the truth is — it’s always a trade off.</p><p>The real question is — do you need it?</p><p>The more I’m thinking about software and the people building it, the more I’m seeing the negatives that the complexity of these solutions bring.</p><p>I’m by no means saying go back to monoliths, but I am saying that you might want to reconsider a microservice-first approach if your team consists of three to four developers with limited work experience.</p><p>Weigh your options, and try to chose the strategy that your team can deliver on comfortably. Unless your team consists of seasoned Navy Seals, I will venture a guess that you would be better off starting from a monolith, learning to separate modules and split only when you have a good grasp of your system.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f53bd205e7c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/geekculture/growing-your-monolith-9f53bd205e7c">Growing Your Monolith</a> was originally published in <a href="https://medium.com/geekculture">Geek Culture</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Kanban board: you’re using it wrong]]></title>
            <link>https://danastroman.medium.com/the-kanban-board-youre-using-it-wrong-fbc1051641ff?source=rss-96313f69ff61------2</link>
            <guid isPermaLink="false">https://medium.com/p/fbc1051641ff</guid>
            <category><![CDATA[visualization]]></category>
            <category><![CDATA[kanban]]></category>
            <category><![CDATA[kanban-board]]></category>
            <category><![CDATA[the-phoenix-project]]></category>
            <category><![CDATA[lean]]></category>
            <dc:creator><![CDATA[Slobodan Dan]]></dc:creator>
            <pubDate>Tue, 02 Feb 2021 11:06:37 GMT</pubDate>
            <atom:updated>2021-02-04T15:03:53.597Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-Qd0UfD5GBZ32P9h92JzcA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@edenconstantin0?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Eden Constantino</a> on <a href="https://unsplash.com/s/photos/kanban?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Today, just like most days now, I went for a walk after lunch. Being a full time member of the cult of productivity, I started listening to audiobooks, so that I can learn at the same time.</p><p>I like listening to audiobooks, because it frees me up to think and reflect at the same time. That way, I get more “Aha!” moments. Today, however, it was more of a “Oh, no!” moment.</p><p>I was listening to <a href="https://www.amazon.com/Phoenix-Project-DevOps-Helping-Business/dp/0988262592">The Phoenix Project</a>, and the painful realization came to me when the narrator was reading the chapter that was touching on the principles of <a href="https://en.wikipedia.org/wiki/Lean_manufacturing">lean manufacturing</a>. The protagonist managed to assemble something akin to a Kanban board, but he still couldn’t see what he was looking for — the bottleneck.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fEFr8aaJpZ1ns2KhSEjE5w.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@carlosaranda?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">carlos aranda</a> on <a href="https://unsplash.com/s/photos/manufacturing?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><h3>Lean IT</h3><p>More and more people are using the wonderful Kanban board to visualize work in IT. I too have grown to love it, because of its amazing feature to clearly show what’s happening. You can easily see who’s working on what, what’s stuck, how the work is progressing and whether you’ll meet your sprint goals.</p><p>That is great! But also, exactly the problem. We were too focused on the sprint, and not focused enough on the value we were delivering to the business.</p><p>Working as a development team, we would work on developing and testing features, technical investigations, and fixing bugs and production issues. All these were visible on our Kanban board. But if we’re being honest, our work comprised of much more than developing and testing features.</p><p>Our Kanban board looked something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*piSVbQUuGyEfWF3gADkD9A.png" /></figure><p>Left to right there were columns named: <strong>to do</strong>, <strong>impeded, development</strong>, <strong>code review</strong>, <strong>integration testing</strong>, <strong>regression testing, smoke testing</strong> and <strong>done</strong>.</p><p>Not terrible, but not great either. I bet we could do better than that.</p><h3>Long before ready</h3><p>First let’s take a look at the left side of the board. Our work did not begin when tickets are ready to be developed. It started when they first appear on the backlog. They needed to be read, refined, investigated, prioritized and planned for. So there are at least three columns missing left of the <strong>to do </strong>column. These are<strong> backlog, refinement </strong>and <strong>sprint ready</strong>.</p><p>If we move out of the mindset of sprints, we could easily see that <strong>sprint ready </strong>and <strong>to do</strong> are redundant. What both of those describe is <strong>ready for development </strong>stage.</p><p>But what is the factory equivalent of <em>ready for … </em>stage? In my mind it’s like a stack of raw materials in front of a machine. In other words — it’s not work. So I don’t think it deserves a column.</p><p>And while we’re cleaning up, <strong>code review</strong> should be done <em>during</em> development, so it’s a part of the<strong> development</strong> step. Also work could be <strong>impeded </strong>at any stage of the delivery, not just during development, and more importantly — it’s not work, so it shouldn’t be represented by a column.</p><p>With these changes, let’s see how the board might have looked like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Li4B4Td8jxWFuFbCJqENZg.png" /></figure><p>At other times it surely looked like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-KHLNz6cLO5aEeVt9rtreQ.png" /></figure><p>Do you see how this may have affected our work?</p><h3>Not really done</h3><p>Now let’s look at the right side. When we <em>finished</em> our work, that didn’t mean the features we delivered were in production. It meant that we tossed it over to IT and QA to deploy and verify it.</p><p>To see that part of the picture, we should have added at least one more column — <strong>acceptance testing. </strong>Now the board would look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m_o1ZGlkQhiJN1fFDFBFsQ.png" /></figure><p>This would have been a much more accurate picture, because <strong>the only work items that create value are those that reach production</strong>, and only then could they be considered <em>done</em>.</p><h3>There can be only one</h3><p>At some point we decided to improve visibility of production issues, by flagging them as high priority with a label <strong>expedite</strong>. This created a separate lane for these issues on our board. This might have caused more harm than good, because it created a false sense of having another work stream. Only there wasn’t one. There was one team and one work stream, and the production issues were competing for space in the same pipeline as stories, spikes, and other tickets.</p><p>Some production issues were of low priority, so they ended up in the backlog, pilling up like logs in front of a lumber mill, without us really noticing. And, how could we? We spent most of our time looking at our zoomed-in Kanban board, making sure we finish all the work that we committed to in the current sprint.</p><p>Having these issues in the same lane, might have highlighted the obvious fact that the work was pilling up.</p><h3>The complete picture</h3><p>Ideally by having a better picture of the actual process, we could have focused more on the <strong>flow of work </strong>and less on the sprint commitment, which would ensure that a constant stream of value was reaching production.</p><p>Moreover, by seeing the whole pipeline, we would have a better idea of where our bottlenecks are. We might have been planning too much work, or pilling up tickets on acceptance testing, all the while developing new features that are also going to get stuck there.</p><p>I will definitely try to have a more wholesome view on the Kanban board on my next project. And with the flow of value directly in sight, who knows — we might find that we don’t even need sprints. Wouldn’t that be a relief?</p><p>How did your Kanban board look like? Did I miss some steps in the process? Are there too many?</p><p>Let me know in the comments. I’d love to hear your opinion.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fbc1051641ff" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to create great developers: The Skill Matrix]]></title>
            <link>https://danastroman.medium.com/how-to-create-great-developers-the-skill-matrix-a851b9b54153?source=rss-96313f69ff61------2</link>
            <guid isPermaLink="false">https://medium.com/p/a851b9b54153</guid>
            <category><![CDATA[mentorship]]></category>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[cognitive-load]]></category>
            <category><![CDATA[personal-development]]></category>
            <dc:creator><![CDATA[Slobodan Dan]]></dc:creator>
            <pubDate>Sun, 17 Jan 2021 13:15:43 GMT</pubDate>
            <atom:updated>2021-02-04T13:12:55.723Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MWr6NW5pxkFAcQPED5da2w.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@webstacks?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Webstacks</a> on <a href="https://unsplash.com/s/photos/web-development?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Some years ago, guided by the feedback of my department manager and mentor <strong>Borislav Ervaćanin</strong>, I started thinking about how unstructured our system for learning really was. He was a great mentor and was frequently pointing me to work on some skills that were not on my radar, like logging and exception handling. My thought at the time was: what’s there more to learn about this? But there was. A lot.</p><p>Having this uncanny ability to teach people, Borislav had always played it by ear, intuitively figuring out what I needed to work on next to become a good developer. Of course, not everybody had the same extraordinary ability. I certainly didn’t — I needed a mold.</p><p>A few years later, I became a department manager myself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5rXejhcKLorK7JiXnQH-tg.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@sctgrhm?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Scott Graham</a> on <a href="https://unsplash.com/s/photos/department-meeting?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>As a department manager my job was now to mentor a dozen other people, but I still had no mold. So, I decided I was going to describe the problem and then look for the solution on the internet. The problem manifested itself in several ways:</p><ol><li>Mentoring: having no baseline, it was both hard for the mentor and the mentee to envision a personal development plan for the mentee</li><li>Evaluation: having no common system of measurement, managers could not make valid comparisons between developers</li><li>Feedback: with no reference system nor skills to inquire about, the managers were relegated to asking about a general impression of performance from team leads and other team members</li></ol><p>With the problem now in plain sight, I scoured the internet trying to find some general approach that addressed it, but after several hours came up empty handed.</p><p>Eventually I began to look beyond the IT sector, finally stumbling upon what in some industries was known as the “skill matrix”.</p><p><strong>The skill matrix is a list of specific skills that an employee needs to have in order to master his position, and a description of the corresponding skill levels for each skill. Employee competency can be evaluated using these skill levels.</strong></p><p>The idea was so simple and so appealing to me that I set out to create a mockup of such a matrix for my department. My initial draft looked like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qL-M-EZZRw6daAxoY059Wg.png" /><figcaption>Skill Matrix of a Full Stack .NET Developer</figcaption></figure><p>I sketched it quickly, keen on getting an opinion from both managers and my department.</p><p>My department loved the idea. The feelings of surprise and elation were quite apparent, as they, for the first time, observed the map of the continent they stood on. The approval was unanimous, with many ideas on how it could be used and improved.</p><p>The managers were reluctant at first, but very quickly warmed up to the idea, and agreed to put it on a test run. We picked a few people from our departments, and evaluated them against the matrix independently.</p><p>Despite the rough descriptions, we seem to have all understood what the skills were, and what the levels were, and they also seemed to roughly fit the seniority of the people we evaluated.</p><p>There was, of course, a lot to improve, but the benefits were obvious:</p><ol><li>The mentors and mentees could now keep track of mentee’s current competences, and easily come up with a learning and advancement plan</li><li>The managers could talk about concrete skills and achievements, compare them, and reward them accordingly</li><li>The managers could ask for feedback on improvement in specific skills, rather a general performance impression</li><li>The interviewers could use the matrix to ask questions, and score the interviewee accordingly, reducing the possible seniority/wage errors made in the interview process</li><li>Having a shared understanding of what quality work constitutes, we could reduce friction in both communication between developers and speed up onboarding on different projects</li></ol><p>We were happy with the conclusions and goals we set upon — to add missing skills like “troubleshooting” and “IDE competency”, and to improve some of the less obvious descriptions.</p><p>Personally, I felt it also made the case that, heavy focus on learning new technologies, might be a poor long term strategy. Technologies change with rapid pace, and technology skills have very little carry-over to any other technology skill. In contrast to that, the general skills carry-over to almost any technology skill and change very slowly over time.</p><p>The conclusion from this, I though, was simple: <strong>the path to becoming a great developer was by mastering general programming skills, and learning technologies only as needed</strong>.</p><p>Besides the benefits outlined above, the skill matrix also raised a question: was the <a href="https://en.wikipedia.org/wiki/Cognitive_load#Intrinsic">intrinsic cognitive load</a> of a full stack developer overbearing?</p><p>It certainly looks that way. With the natural complexity of the domains, and the complexity of the projects themselves, maybe it is time to narrow down the expertise field once again.</p><p>What do you think? Is the full stack developer a realistic idea or do we need to find new ways to split responsibilities and specialize to keep being effective at our work?</p><p>Do you think the skill matrix is a useful tool? Would you try it out?</p><p>Let me know in the comments bellow.</p><p>Next time I will discuss the balance of general, technology, team and personal skills, with regards to the skill matrix and developer advancement.</p><p>This is my first published article. Thank you <strong>Nikolina Romakov</strong>, for pushing me to write this story, and <strong>Dejan Ačanski</strong>, for discussing and reviewing it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a851b9b54153" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>