Category: Uncategorized

  • The Case Against Scrum Masters

    I’m not a fan of Scrum Masters, not as a responsibility passed around inside of a team, but the kind of Certified Scrum Masters that generally have it as their job title. I’ve worked with a few of them in varying capacities over the years, but I’ve noticed the same reoccurring problems. To be clear though, I take issue with them as colleagues, but not necessarily as people – because many of them are great people who I like outside of work.

    The Scrum Masters I’ve worked with have come in two flavors – one where they act as a coach for teams to help them enact Scrum and one where they’ve acted as pseudo project managers and directly lead teams. Though I find the former less problematic than the latter, I’ve found the issues between them largely the same and only a matter of degree than kind. Therefore, I will be using the term CSM to describe the specific Certified Scrum Masters for both of these cases.

    Certified Scrum Masters are not Developers

    Software Development is not special from many other industries, but in software development, as in the rest of STEM, the process is not easily understood by non-practitioners. There are many other jobs, such as house painter or mechanic that require just as much ingenuity and creativity, but where the process is much more easily understood by the average person. To many people, programming is magic. Generally, this isn’t a problem – I don’t need to know exactly how my car works to be able to drive it, nor should the average person need to know the inner workings of their computer, but where it becomes an issue is when these non-developers become responsible for coaching or even become in charge of developers.

    Because CSMs do not understand the process of software development, their ability to communicate with and understand developers is typically very little. This leads them to being narrowly focused on processes and tools over people and interactions. As coaches, they become obsessed with doing things the “right way” whether or not it actually suits the needs of the team and when the team fails to see results from their effort, the team is told the solution is more Scrum or that they aren’t doing it the right way. As project managers, they lack the ability to actually lead the team, only being capable of moving tasks across a JIRA board and pestering the team members about when they will complete their tasks. In both cases, I’ve found their contributions to be net-zero or even net-negative.

    In contrast, I’ve experienced having both an Agile Coach (note Agile and not Scrum) and managers who are/were developers themselves, including my current one. The difference is astounding. The Agile Coach I had at a previous company pushed me into a completely new paradigm and helped me find the track to push my skills to the next level. I believe they were paramount to many of my future successes. And my current manager is able to understand the services we own, provide code reviews and feedback, and help provide solutions that make our team effective.

    Being a developer does not automatically make a good manager, but not being one guarantees ineffectiveness and I find the same is true of CSMs in both capacities.

    The Process Isn’t the Problem

    Team processes can be annoying and frustrating, but rarely have I found them to be the true blockers of a team’s progress. Often, they’re merely the symptoms at the most, if they’re even a problem to begin with. CSMs come in to make teams work faster and more efficiently by trying to optimize the process. Adding more swim lanes to the JIRA board to make ticket status more granular or staring at the burndown chart every morning has no impact on the output on the team and is more likely to hinder than help, but these are where CSMs focus their efforts.

    This is not a problem unique to CSMs. It’s why the saying, “if all you have is a hammer, everything looks like a nail” exists, and I criticize developers for the same thing as well – that being too narrowly focused without taking the bigger picture into account is a path to ineffectiveness and failure.

    Actually solving the issue requires digging into the root cause and understanding that bigger picture. Sometimes there are no blockers. Sometimes, the team is juggling too many projects and the constant context switching is taking away their ability to gain the necessary knowledge to build their systems.

    And sometimes, you just need to hire more people.

  • Always Be Shipping

    I’m a bit of a perfectionist. When I create something, I want it to be not only good, but great. I can’t accept substandard quality. I have standards after all and to accept mediocrity is to begin down a path which leads to enervation and death… or something like that.

    Having spent most of my career on the quality engineering side, I tend to be quite particular when it comes to code reviews. My level of scrutiny can, at times, frustrate my teammates who feel I am unfairly nitpicking. Generally speaking, QA can gain a reputation for being a hinderance because we begin to be seen as an obstacle to be overcome instead of as a teammate supporting higher quality standards, but I think it’s important to realize that quality is not on the opposite end of the spectrum to speed. Quality is speed. Or, to steal from Bob Martin, “clean is fast.”

    When a lack of code quality begins to surface as customer complaints, management’s go-to is often to add new processes to gate off code until all steps in that process are followed. This can take the form of either a senior developer’s approval or a centralized release committee. It’s an understandable response and one that happens frequently, despite its ineffectiveness, because it at least appears to work and as I love to say, people make decisions on what they think is true, not on what actually is.

    Gating off new code changes appears to have a positive impact on quality at first. The number of issues go down, as do customer complaints, but the reason for this is primarily because the new processes discourage changes being made at all, which naturally leads to fewer new issues, and secondarily because an increased focus on resolving customer complaints can bring a short-term investment to fix known issues. In the long-run, however, the burden of an extensive review process discourages developers from making smaller changes, like paying off technical debt, and the way they do their work does not fundamentally change, which inevitably continues to lead to the same result, causing management to feel forced into leaving the review processes in place and developers who dislike the red tape to eventually seek employment elsewhere.

    The real solution is counterintuitive – ship more often. In fact, the end goal should be to ship as often as possible – multiple times per day, even, and by ship I do mean merged in and deployed to production. The fear, uncertainty, and doubt that would reject making this change believes that the effect would be the opposite of slowing down and gating releases – and it is, but that is because the belief that slowing down releases is effective is wrong.

    The default assumption around deploying more frequently is that even more issues will occur. But, why this doesn’t manifest in reality is because if we double or triple the frequency of our releases, developers can’t suddenly double or triple the amount of code they’re actually producing. Instead, they’re forced to cut apart the changes into smaller pieces. Less code means pull requests are less burdensome to review, less code that could potentially break, less that needs to be tested, and less that needs to be rolled back if a failure does occur.

    By making ourselves ship more often, our current processes may not be able to scale. Lengthy reviews, frequent manual testing, and centralized release committees will quickly become swamped and be incapable of handling the volume because they don’t scale. These processes will have to be replaced with something more efficient and scalable – namely automation. But the part I find most interesting is that pushing for a more frequent release cycle is how we get these processes in place and not the other way around. If we want our teams to adopt the practices of DevOps and automation, we should actually be promoting a faster release cycle as our first step. If your team currently deploys once per month, push for once per week. If you deploy once per week, push for 2-3 times per week. This is the most effective method because finding better processes becomes a necessity instead of a “we’ll get to it eventually” item to throw on the bottom of the backlog. Start by increasing the frequency of your releases and all else will soon follow.

  • My Last Post was Wrong – Rethinking Testing

    In my previous post about how to unit test, I decided to share some recent findings that made me rethink my approach to unit testing. Unfortunately, I didn’t give myself the time to fully explore them and with about five minutes on Google, it became apparent that I had been caught up in an anti-pattern. So to prevent making the same mistake twice, I’m going to stop my testing mini-series for now and spend more time learning. In the meantime, I have a number of other topics lined up that I’m planning to dig into.

  • How Do We Test This – Unit Testing

    For this post, I’d like to change things up a bit and talk specifics – in this case, unit testing. Many guides on unit testing tend to include code samples that I find overly simplistic, so I’d like to provide something that’s a bit closer to what we might actually encounter in the wild.

    Let’s say we’re working with an existing code base and we’ve been given the task to add unit tests for an existing class. Not, maybe, the ideal situation, but the norm for most teams I’ve been on. Here is the class:

    public class SampleClass {
    	private SampleDependency dependency;
    
    	public SampleClass(SampleDependency dependency) {
    		this.dependency = dependency;
    	}
    	
    	String sampleMethod(String s) {
    		if(s == null) {
    			throw new IllegalArgumentException(s);
    		} else if(s.isEmpty()) {
    			return "";
    		}
    		
    		StringBuilder sb = buildRequest(s);
    		return dependency.doSomething(sb.toString());
    	}
    
    	private StringBuilder buildRequest(String s) {
    		StringBuilder sb = new StringBuilder(s);
    		sb.append("foo=foo2");
    		sb.append("bar=baz");
    		return sb;
    	}
    }
    

    Like code in many real projects, this class has a dependency. What that dependency is doesn’t matter too much here – it could be a database, an API, or some other internal class, but what matters is that to create a unit test, we want to test this class only. This means we need to isolate this class from it’s dependencies. This is one of the main ways we differentiate unit tests from other types of testing.

    What is the process for doing this? If we create fake (mock) versions of our dependency and substitute them in, we could get them to act in any way we wanted, while still calling the real method in the class we want to test. While we could create them ourselves, we can instead use mocking frameworks that do the heavy lifting for us. In this example, we will be using Mockito.

    String sampleMethod(String s) {
        if(s == null) {
            throw new IllegalArgumentException(s);
        } else if(s.isEmpty()) {
            return "";
        }
        ...
    }
    

    When analyzing our methods for testing, a good starting point is to consider all the different execution paths – happy paths for valid input and sad paths for invalid. The first part of our method includes some guard clauses against null and empty string. For our first tests, we will start by verifying these paths.

    At first glance, this may not seem to add much value. We know passing in null will throw an IllegalArgumentException, so what value is there in adding a test that explicitly passes in null, just to check the thrown exception? Tests can act as a kind of documentation in code form. We can use our unit tests to capture the current behavior of the method, so that we can verify that any future changes made to it are actually intentional.

    @Test
    void testSampleMethodThrowsIllegalArgumentExceptionWhenStringIsNull() {
        assertThrows(IllegalArgumentException.class, () -> {
            sampleClass.sampleMethod(null);	
        });
    }
    	
    @Test
    void testSampleMethodReturnsEmptyStringWhenStringIsEmptyString() {
        String result = sampleClass.sampleMethod("");
        assertTrue(result.isEmpty());
    }
    

    These tests are low-hanging fruit. The more significant complexity comes when we look at the rest of the method.

            StringBuilder sb = buildRequest(s);
            return dependency.doSomething(sb.toString());
        }
    
        private StringBuilder buildRequest(String s) {
            StringBuilder sb = new StringBuilder(s);
            sb.append("foo=foo2");
            sb.append("bar=baz");
            return sb
        }
    

    Now we’ve reached the code that calls our dependency and so we need to use Mockito to create a mock that we can use and pass to the class.

    @Test
    void testSampleMethodReturnsCorrectResult() {
        // Given - set up our precondition
        String expectedResult = "sample result";
        given(dependency.doSomething(anyString())).willReturn(expectedResult);
    	
        // When - call our method
        String actualResult = sampleClass.sampleMethod("sample request");
    	
        // Then - check the results
        assertEquals(expectedResult, actualResult);
    }
    

    Using Mockito’s given() method, we can make our mocked object return whatever we want. The ability to do this is aided by using dependency injection and storing an interface over an implementation. Once we’ve set up our mock, we can then call the methods we want to test using it.

    But what about the private method? How do we test this when we don’t have any direct way to call it?

    private StringBuilder buildRequest(String s) {
        StringBuilder sb = new StringBuilder(s);
        sb.append("foo=foo2");
        sb.append("bar=baz");
        return sb;
    }
    

    For this, we have two options. If the private helper method has only a single execution path, then we typically do not need to call the method directly to test it. We can rely on the tests for its calling methods to cover it. But, if there is additional complexity, e.g. conditionals, then instead, we should extract the method to a separate class, as indirect testing may not be capable of hitting all the execution paths . If we are not able to make changes to the class, then we have no choice but to fall back onto indirect means, which may not be able to test all execution paths.

    The source code for this post can be found here.

  • Definition of Done – Why it matters

    One of the great difficulties in software development is measuring progress on individual stories. It’s often difficult to provide an answer when asked how long something will take. Part of the difficulty is because software development does not have a linear path to completion; certain tasks may be more or less difficult than we expected and unknowns tends to be numerous. But also, we tend to consider done to mean done with the initial programming, often leaving out time to clean up, test, merge, etc. This can lead to underestimating time to completion if the additional steps are not accounted for, but it can also cause large variance between developers, depending on personal development style, unless the team has an agreement on what defines completion. This is the definition of done.

    The definition of done is straightforward – it’s the list of criteria the team uses to determine when a story is complete. It typically includes most of the tasks we do anyway – create a pull request, have it peer-reviewed, and all tests pass. In my experience, most teams’ effort to create definition of done stops here, resulting in completing a checklist item that provides little value. But, if used properly, the definition of done can be the cornerstone of the team’s engineering practices.

    The important part

    The process of creating a definition of done is where much of the value lies. The discussion opens up an opportunity for the team members to discuss what development practices they value and why they should be applied universally. These can include additional requirements that are more individualized to the team’s situation and not necessarily copy-pasted rules from the internet. Depending on the challenges and situation of your team, you may find common recommendations not applicable. That’s completely okay. The emphasis is on the need to consider the team’s unique position and apply criteria that makes sense.

    Since I am strongly focused on software quality, there are a number of checks I do on my own projects before I consider something to be complete:

    • Code coverage – Code coverage is not the end-all-be-all of testing, but it can provide useful information about the state of it. High coverage does not guarantee tests are good, but low coverage guarantees existing tests are inadequate.
    • Linting – Everyone has their own philosophies on code style, but more important is consistency. Linters help keep code consistent, while also ensuring no one has to waste time being the code police during reviews.
    • Code quality metrics (smells) – SonarQube and other quality analysis tools are something I heavily rely on, because they find problems I never would have found on my own. Code smells are often ignored because they aren’t errors, but they can be signs of bigger issues and fixing them helps improve maintainability.

    These are just a few examples from my own projects that could give you some ideas, because not every developer is going to agree on criteria and significant pushback can happen if team members start to feel the definition of done is going to become burdensome and slow down their work.

    To not be a burden

    There is one big reason why I’ve seen definitions of done thrown out – because it’s a burden. The definition of done can quickly become a significant burden to the team if it becomes inundated with too many steps, and team members may skip steps or only do them half-hardheartedly, the same way as when given a pull request that’s Just Too Big. There are a few things to consider doing to help prevent this:

    • Automate everything – The more of our engineering practices we can offload to the computer, the better. This ensures we spend time doing the actual development, while minimizing the overhead cost.
    • Do only what’s necessary – What is necessary is subjective, but if developers are often skipping a particular step, there’s a good chance it’s not necessary. Making sure the definition of done is created by the engineers themselves and not something forced on them by the manager will help ensure this is the case. The fastest way to do something is to never have to do it at all.
    • Adapt the process – Make the definition of done a living document. Let it change as necessary to support the team. Agile emphasizes individuals and interactions over processes and tools. Make the process fit the developers and not the other way around.
    • Enforce it – All team members need to be following the definition of done. Having some team members opting out will virtually guarantee the other team members eventually stop following it as well. If some team members are refusing to follow it, then perhaps it’s time to Adapt the process.

    With the right mindset, the definition of done can be a valuable cornerstone of any team’s development practices. Creating one does not need to be a big affair, but it can allow for the team to create a list of criteria that is useful without being burdensome, to know definitively when a story is done.

  • Atomic Habits

    Over the last year, I’ve had the great fortune of working from home. While the situation has afforded me the ability to do many things I wouldn’t otherwise have been able to do, it was also a major shakeup to my habits. Now, as restrictions have largely been lifted and life has returned to at least mostly resemble what it looked like before, I’ve begun the process of reestablishing my habits and reflecting on what I want my daily life to look like in a post-covid* world.

    It was only four months after I moved to Seattle that the lockdown went into effect. At the time, I was quite happy with my situation. Moving to a new city with a new job at Amazon had given me many things to be highly optimistic about and I had established a solid set of routines that drove me forward. Despite realizing at the start that the lockdowns were likely to last for much longer than expected, I chose not to make any significant changes and acted as if things would only be temporary. My physical and mental health deteriorated and my environment began to reflect that.

    Though I found myself in a rut, the pandemic opened up unexpected opportunities and lead to significant changes; I moved to San Diego, left Amazon to work for Kareo, and started dating an amazing girlfriend who reads all my posts. This meant rebuilding my old routines was not going to be possible and I would have to create new ones. Searching for ideas, I picked up Atomic Habits. This book gave me great insight into my own habits and how to work on them.

    Habits are about who we are

    One of the biggest takeaways is how the way we think of ourselves determines what we think and do. Gaining the label of “gifted” in kindergarten came with a significant expectation of academic success. Becoming part of the nerdy kids meant being uninterested in athletics. These labels set expectations and we create habits that reinforce them.

    Labels like these can be useful, because they give us a sense of direction. If you’re a smart person, you’re expected to do smart person things. Friends and family will push you to have smart person hobbies and a smart person career. But, these labels can also be limiting – they can prevent you from exploring outside. Having non-smart person interests may be met with shock or concern, but in the end, our labels are not how others define us, but how we define ourselves. And so, changing what we do ultimately requires changing who we believe ourselves to be.

    I myself have quite a few labels that surprise people – pilot, cyclist, weight lifter. These are not interests that align with a smart person label, but for me, they do not clash with my persona in the way others think they do, because I don’t limit the way I think about myself. Above all else, the strongest label I attach to myself is leader. Not everyone may see it and that’s fine, because what’s important is how I choose to think about myself, because that dictates the habits I keep.

    It’s about the journey, not the destination

    Long-term success is the result of small, atomic habits repeated hundreds or thousands of times. Breakout success comes only after years of work where no one is watching. It is a lifelong journey to get there and it often takes years or decades to have the results we really want. Life is not a video game. But what we can achieve are truly meaningful results, if we are willing to put in the effort to work for them – every day, little by little.

    Atomic Habits has much more than what I covered here. I highly recommend giving it a read. It also includes guides on how to create and maintain good habits and end bad ones, something else I’m slowly making progress on.

    *This is, of course, hoping we actually are moving towards a post-covid world.

  • The Meeting After the Meeting

    My work with Sallie Mae required the company’s 300+ developers to come together every quarter to a planning meeting for the next three months. It was a two-day-long event that involved a lot of time spent waiting around for other teams and often times the work planned on the first day would be completely changed around by the second. Most of my coworkers looked to get out of as soon as possible, being unhappy with having to sit around all day, but I was quite excited every time they came around because it offered me something that is often quite rare – the ability to have a lot of conversations with many people. These conversations were what I call, the meeting after the meeting and they were often much more important than the actual planning meeting itself. When the planning meeting was over and everyone went home was when the real decisions were made.

    The meeting after the meeting is often unplanned and is frequently disguised as a social event, but don’t be fooled. It might take place in the hallway, the parking lot, or when out for lunch, but it typically covers something outside the main meeting topic. This can be due to a lack of time, business priority, or because the idea may be experimental, but because these discussions typically take place in a safer environment, away from those who might otherwise interfere, the discussion can flow freely and real progress can be made on coming up with ideas. Many projects I have created have started as meetings after a meeting and certain parts of my career have been dictated by the same from my managers.

    Not everyone has the time to stand around talking outside of meetings, but if you can, I highly suggest doing so. If you want to get in behind the scenes and be a part of the big, important decisions, this is where they happen.

  • Microservices – The Racecar Architecture

    Microservices is the new hotness. Or maybe it’s the old hotness. Either way, it’s still a concept that comes up quite frequently, so naturally it’s something on which I have a strong opinion. And like many other aspects of software, I can summarize my opinion as, “good idea being overused to solve problems it wasn’t designed for.” End post. But if that’s not a satisfactory answer, read on. This post is not a criticism of the microservice architecture, because I do like it, but rather a criticism of where and when it’s used.

    Microservices are what I refer to as a “race car architecture.” It can achieve unrivaled performance when done well, but with the cost of a dedicated, specialized team and a narrow scope for where it operates. Needing such a high performance architecture is not typically the starting point for a project, simply because you aren’t going to find projects that start with a user base of that scale. Microservices should not be the starting point, but a natural progression of our architecture when demands require scaling far beyond most applications. Starting with microservices is the wrong approach.

    This concept is called Yagni (You Aren’t Going to Need It). We should strive to build what we need today and not what we think we might need in the future. Will our project eventually need this high level of scalability and performance? Maybe, but I can’t see the future. Does it need it right now? Probably not. By the time you do, you’re probably not taking advice from a random guy on the internet, because you’re Google, with billions of queries per day, or Netflix, taking up almost 30% of all internet bandwidth. If you aren’t at that level of scalability, then you don’t need microservices.

    [D]on’t even consider microservices unless you have a system that’s too complex to manage as a monolith. The majority of software systems should be built as a single monolithic application.

    —Martin Fowler

    Microservices introduced the term, “monolith” to describe existing architectures, implying that they are somehow old and archaic, but what’s often glossed over are the costs of converting to this new and shiny architecture. Microservices have additional overhead in the form of hardware, repositories, DevOps pipelines, and developer time spent managing the higher complexity. There is a point where the overhead costs are outweighed by the benefits, but this is generally only true once conversion to microservices becomes a necessity, because the overhead is significant. Projects of any typical size will more likely be hindered by these costs than helped.

    A better alternative is to build a “monolith” application in a way that would allow easy conversion to microservices should it be necessary in the future to do so. Fortunately, because this has been the way of things for so long, we have plenty of reference material to help us do so. If we ensure our application layers are well separated and loosely coupled, we can ensure that if we do need to convert to microservices in the future, we will have the means to do so.

    Microservices may be the new hotness, but that does not mean they are the solution to every technical problem. It is a race car architecture, suitable for specific domains with extreme scaling requirements. They are a natural progression of an application’s design, not something we should choose until we can’t do otherwise and certainly not something we should start from on a new project. Following the tried and true methods of “monolith”-style design will deliver better results for a lower cost for all but the few rare exceptions.

  • Software Is Not Always the Answer

    As a follow-up to my previous post, I had initially planned to go into more depth about my thoughts on Agile, but the result was much more an explanation of my personal approach to software development, so this post is going to be about that approach to establish a foundation from which I can build from.

    Software development is about solving problems; I think this is quite well-established, but I do not believe our job is to solve problems exclusively through creating software, or even technology. But, how could we do otherwise? This is where I zoom out a bit and take a broader view on our roles as developers.

    When approaching any problem, I like to start with the basics – the who, what, where, when, and why questions:

    • Who are the customers we are building for?
    • What, specifically are we creating?
    • Where will the software be deployed?
    • When is this (actually) needed by?
    • Why are we building this?

    These seem like, and certainly may be obvious questions for any established team and not ones that may need to be asked every time, so for the first four, I will simply point out to make sure you do know the answer to these and don’t simply guess or assume, because they are a critical factor in decisions, but are also easily answerable. What I would like to focus on is the why question.

    Why are we building this?

    Understanding the reason behind why we are building something is, to me, the single most important answer for building anything, software or otherwise. This is because the “why” checks the “what” by asking, “are we building the right thing that actually solves the customer’s problem,” but it also implicitly asks, “does the problem actually need to be solved” or “do we need to do this,” because the fastest way to get something done is to never have to do it at all.

    Project delays and cost overruns are certainly detrimental to a project, but building the wrong thing could potentially be unrecoverable if resources are scarce. With a thorough understanding of not just what we’re building, but why, we can have much higher confidence our solution serves the needs of our customers.

    My suggested approach is the Five Whys technique to understand the situation that led to the initial request. With this, it might be apparent that the solution may need to change, because there may be ways to solve the problem that are better and/or faster, but also may require us to get creative and step away from our computers to design real-world solutions. Let me illustrate this with a concrete example:

    A manager is planning the company picnic and comes to you with a request to build a registration and tracking system for the event. They say it needs to have a place where everyone can register themselves and their families, edit that information if they change their mind, check-in at the event and have the ability to raffle off some prizes.

    After some questions, you find out they expect about 30 people. Their main concern was that last year, they weren’t sure if all the people who signed up last time actually showed up and they don’t want to spend money for food no one will eat.

    Though building it yourself is feasible, you instead create a Google Form to manage signups, find a clipboard and a notebook for sign-ins during the event, and order a small book of raffle tickets online. A one-month solution became a one-hour one.

    The example may be contrived, but these types of everyday scenarios are quite common and with a bit of creativity we can find simple, effective solutions for what only appear to be software problems by not limiting ourselves to the lens of technology exclusively. Software is not created in a vacuum; we work inside a business which has many problems which are not always technological.

    This concept of considering all the different factors into our development process is what I call Holistic Software Development, or HSD for short.

    Holistic (adj) — characterized by comprehension of the parts of something as intimately interconnected and explicable only by reference to the whole.

    It is the idea that not only does the software we build exist in a complex web with other applications, but that what we create and the environment in which we create them are inseparable and that this is something to not simply be aware of, but to actively try to understand and learn from, because doing so is not just good practice, but vital to our success. When we take these other factors into account, we can be sure that we’re solving the right problem in the right way.

    Doing so requires us to step outside the realm of what we would typically consider the role of a developer to be, which is why a shift in mindset is necessary, because thinking in a software-only mode is our default. What we are rewarded with is many more tools in our problem solving tool belt, which increases our capabilities not just as developers, but as people.

    This is the foundation of my approach to software development, but this post is not comprehensive and I intend to explore the concepts further in future posts. Until then, I hope this post provides a useful introduction and generates some interesting ideas for new ways to think about software. I do not plan to hold myself to a set schedule for when I publish new posts, but I do already have a queue of new posts I’m planning to write, so I’ll do my best to announce new posts as they get published.

  • Agile is dead, long live Agile!

    Over the course of my career, I have had the pleasure of working on a variety of teams in a number of companies, which has given me the opportunity to experience how things are done in a multitude of environments. Each company and team has their own unique culture, but with enough experience, patterns tend to emerge. One of the most notable for me has been with Agile.

    It’s no secret that Agile has been co-opted by management to become the very problem it was meant to solve—that instead of removing barriers to work and providing opportunities for better communication we have added more in the name of “going faster.” And that instead of promoting direct collaboration and customized team environments we have pushed for more documentation and certifications in search of doing things the “right way.” I will admit to being just that little bit annoyed every time I see “Certified Scrum Master” or worse, “Certified SAFe Practitioner” in my LinkedIn feed.

    What has shocked me the most, though, is the sheer prevalence of Anti-Agile practices. Anti-Agile is a term I started using when I noticed that many of the “Agile” practices I was instructed to follow went contrary to the Manifesto. Does it fit best if you read the lines in the Manifesto forwards or backwards? If it’s the latter, then it’s Anti-Agile. What I had initially believed to be a localized issue with the company I had been working for at the time turned out to be industry-wide and that’s when I realized swimming upstream against the wave of certifications, trainings, and other corporate-mandated activities was a futile effort.

    Where we went wrong

    One notable observation I have made in multiple companies, is a noticeable lack of desire from most developers to be heavily involved with managing the team processes. Developers, almost universally, have been quite happy to hand over management of the team processes to someone with Scrum Master as their job title, if that meant they never had to do it themselves. Agile is not dead because management took it away from us. We, as a developer community, willingly chose to give it away.

    It is the fact I find myself surprisingly alone in my desire to both understand and improve upon our team processes that motivated me to write this post, because I think it’s here that I am contributing some new insight and not simply rehashing an old idea. I have found management to be generally more receptive to Agile than most developers, because they have a more direct interest in increasing team adaptability and/or efficiency than the average developer.

    Before I get too harsh on my peers, I think it’s important to point out that these attitudes do not exist in a vacuum. Senior developers who once held the energy and enthusiasm I do have had it stripped from them by years of immovable management. For others, but senior developers especially, Agile is yet another thing to know on the ever-growing list of things to know. And in an attempt to recapture time for actual development work, offloading the team-level concerns to someone who has the time for it provides a welcome reprieve. I don’t see handing over Agile to management as a result of irrational decision-making, but the result is the same nonetheless.

    Where do we go from here?

    If I had a solid answer for this question, then I would probably be publishing books about it (and perhaps running expensive training courses with associated certification tests to make it big on my newfound success), but I think the short answer is to do everything, and nothing.

    The fundamental challenge is that teams who closely adhere to the original Agile concept and find success likely would have done so following any methodology. Conversely, a team struggling to perform will do so regardless of what methodology they attempt to use. As is quite universally true, the fundamentals are what make the difference and not the smaller details. To create a high-performance team, we need only look at what makes any team successful, independent of any methodology or industry – good communication, mutual respect, clear goals, and the ability to depend on each other.

    Creating and maintaining a high-performance team requires substantial work and having a framework with which to focus that effort in a way to increase the likelihood of a successful result is useful. So, methodologies like Agile, even if co-opted, are not without value to those who need them, but those teams who benefit from them are outnumbered by those who don’t and it’s difficult to see how Agile’s present situation is not the eventual fate of similar movements that may arise in the future.

    I believe the answer is to do everything to make our own teams a more open and welcoming place for our team members to collaborate and communicate and to do nothing to create the “next Agile.” Because no matter what misshapen form Agile might take on in the future, making our teams successful relies on all of us making it so, developers and managers alike.