14 ms·
Finishing what you start makes teams more productive and predictable
- macintux 4y agoConceptually related discussion from yesterday: In Praise of Stacked PRs https://news.ycombinator.com/item?id=32214809 https://news.ycombinator.com/item?id=32214809
- kqr 4y agoThis is a fun experiment along the same lines: https://m.youtube.com/watch?v=Dr67i5SdXiM https://m.youtube.com/watch?v=Dr67i5SdXiM The result surprised me even though I know intellectually I should have expected it.
- wizofaus 4y agoThat's because it chooses a bad example of an activity for which production-line methods make sense. Pick an activity (that you need to repeat many times) where each step requires quite different tools and skills that are difficult to master, and breaking it up into tasks for individuals who specialize in said tools/skills is almost certainly going to get you better throughput. Even in the letter-stuffing example, if you imagine that if it required full/focused use with both hands of different tools for a) folding the letter b) placing it in the envelope c) sealing the envelope d) stamping it, then having different people special in and handle each subtask, even if it means paying a bit of extra time for moving the item between each individual, is likely to pay off (of course, if one of those subtasks takes vastly longer than the others, it may need 10 people doing that, vs one on the others, but that doesn't change the principle). Obviously software development is very different - we're not asked to use the same tool repeatedly to produce the exact same result. Further, in our world a) switching between tools is usually relatively costless and b) developers are generally quite capable of becoming skilled with multiple tools. But I'd still say that some of the same principles could apply, e.g. if those assumptions weren't true for whatever reason (e.g. switching tools means physically moving to a different piece of hardware in a different room, or there are obvious measurable differences in the skills of your developers as far as particular tools go), then splitting a task up so one part can be handled by one developer with one tool and the other by another developer with a different tool is probably going get you a better result than asking one developer to be responsible for "finishing" the whole task themselves. Arguably the important thing is that they be on the same team and consider themselves to have a shared responsibility for the task that's been split up. Which interestingly, often isn't how teams are organised in software development companies, from what I've observed over the decades. Having an end-to-end feature be the responsibility of a single team, even if it necessarily requires multiple specialists, is probably not a bad guiding principle - but on the flip side, many peoples aren't (for understandable reasons) keen on being shuffled around between teams depending on what each feature requires.
- kqr 4y agoOne piece flow doesn't mean the same person does everything. It could mean that multiple people do their specialty, but instead of working at their own pace with storage between them, one passes their work product directly into the hands of the next when the next one is free. I have done the experiment with the envelopes that way too with similar results.
- allenu 4y agoCool demonstration. If I understand correctly, the one piece flow process is better because it eliminates the waste of putting the item away and picking it up again. We've overlapped the "putting away" of one stage with the "picking up" in the next stage.
- kqr 4y agoThis article is very thorough, but makes one fairly big mistake: it assumes there is low variability in task size. This could be a reasonable assumption if you're very good at adjusting scope, but I would be skeptical unless you have measured it and have the numbers to prove that in practise, tasks indeed turn out to be roughly the same size (±20 % or whatever -- I don't know the exact threshold.) Why this matters is that under cheap context switches and even modest task size variability, it's -- surprisingly -- a performant queuing policy to pre-empt the currently processing task to handle every incoming task. The intuition behind this is that if a task is still processing when a new one comes in, it's likely to be a "big" task, and it's worth letting small tasks ahead in line. Reduces mean response time. Of course, this could all be moot anyway because context switches are certainly not cheap for software engineers. I just thought I should mention it for nuance. Rules of thumb only get you so far, at some point you have to more accurately model the situation and simulate.
- vladgiverts 4y agoSpeaking to the task size point, I’ve found (via leading a number of teams and training many more team leads) it’s possible to decompose any task into smaller tasks so that every task is within a small constant factor of each other. If it seems impossible for a given task, maybe because it’s particularly complex or has lots of unknowns, then no problem, simply create a “spike” task to research or prototype whatever you need to in order to decompose the big task into appropriately sized chunks (for your team’s idea of appropriate). See you end up with a bunch of tasks that are all roughly the same size or are spikes of similar size, and you can have the very nice predictability and productivity that the author is speaking about. (btw, I also agree that contact switches are never cheap for software developers, so it’s better to let them finish whatever they’re working on whenever it’s not too unreasonable to allow it)
- kqr 4y agoThis has been true in my personal research too. When projects are sufficiently decomposed, a "ticket" about implementing part of a project is generally speaking within the same order of magnitude. However, this article is not talking about "tickets" but rather about the entire project. So that you may or may not be able to break the project down into roughly-constant chunks is irrelevant for the arguments of this article. What matters is the size of the full project that you need to see through from start to finish in order to get business value out of your work. (Yes, you can usually break down the project into smaller chunks too, so that you see business value quicker. However, these are rarely of constant size anymore, in my experience.)
- rdoherty 4y agoIf you liked this post, the book Making Work Visible is a great expansion on these topics. Making Work Visible: Exposing Time Theft to Optimize Work & Flow https://www.amazon.com/dp/B09L3B9YK1/ref=cm_sw_r_apan_AX66TBG68TPPYQ3VRMZ4 https://www.amazon.com/dp/B09L3B9YK1/ref=cm_sw_r_apan_AX66TB...
- openfuture 4y ago"Time theft"?! Oof I sincerely hope he got that the right way around rather than predictably inverting it.
- hnbad 4y agoBased on the summary I think the author just uses an unfortunately overloaded term. The "time thieves" aren't supposed to be the employees but inefficient processes slowing them down.
- klodolph 4y agoFact is, a team with five people working on five independent tasks may be able to proceed at high throughput, because of the cost of coordination when you assign multiple engineers to the same task. That is, if you have chef A making a burger, and chef B making a salad, and chef C making a cake, then they can all go at full speed because they're using different parts of the kitchen and don't need to coordinate with each other much. Individuals pay for context switches, but teams can assign different tasks to different team members. Or maybe I don't understand the point the article is trying to make here. It seems really obfuscated with metaphors involving burgers.
- Too 4y agoThe problem becomes a lot more difficult and interesting once you start involving multiple people. Should everybody have many or exactly one task assigned? Should one person be on stand-by for operations? Should tasks be paired to two developers? Whole team mob programming one task? Are all the tasks truly independent? Should juniors in team have same WIP as seniors or is the limit counted for the team as a whole? I see some teams almost give juniors a backlog of their own with the most basic cookie cutter tasks, even if they are low in prio, just to get them on board. Other teams handcuff them together with a mentor doing normal tasks. Vice versa for tech leads who often have another set of tasks only they do. If everybody is working on a task, then who will code review others work? This can end up in a priority inversion situation, if Alice finished working a high prio task, should Bob working on a low prio task drop his work to review Alice work or should he finish his existing work to keep within his WIP limit.
- 8n4vidtmkvmk 4y agoi think we're talking about giving a single engineer multiple tasks.
- klodolph 4y agoThe article is definitely talking about teams. It says "teams" lots of times.
- solatic 4y agoArticle relies on a non-sequitur assumption that you should work on an entire feature start-to-finish without interruption. What management ought to do is to split feature work into tasks of smallest granularity as possible, then schedule only those of highest priority. This is what actually reduces batch sizes. Then deciding to prioritize the work to finish a feature instead of new work for a different feature becomes a matter of discipline, not process. This is important because it allows management to stop throwing good money after bad on features that the business decided that they don't actually want anymore. If Development doesn't deliver business value because Product can't stick to a coherent feature strategy, that's Product's fault, not Development's.
- kqr 4y agoI agree with the general idea, but I'm not sure putting development and product in an antagonistic relationship will improve things. They're different professionals with different ideas of what's important. Someone in product is unlikely to understand the development cost of leaving something half-finished, because recognising it as a maintenance tar pit takes development expertise that can be hard to articulate (as expertise tends to be). What's needed is close cooperation, not finger pointing.
- vasco 4y ago> If Development doesn't deliver business value because Product can't stick to a coherent feature strategy, that's Product's fault, not Development's. It's only not your problem too if you like working for failed companies.
- doix 4y ago> What management ought to do is to split feature work into tasks of smallest granularity as possible, then schedule only those of highest priority. I would say this is pretty standard, and personally I really hate it. I think it works well if you want to prioritize hitting a date above all else, especially with a junior team or in a "low trust" environment (cheap off-shore team). But for other metrics, I don't think it's great. In my experience it results in a lower product quality, people do the bare minimum to finish a ticket and throw it over the wall. Since tasks are so split up, things don't end up connecting coherently. The problem you're trying to solve for the user gets completely lost and you end up with a bunch of features that don't necessarily make sense. In my opinion, it also really sucks for job satisfaction. It makes me feel micromanaged and have 0 autonomy. But I have met people that love it, their reasoning being "I can just zone out and write code without having to think about other things". So that's more of a personal thing. > If Development doesn't deliver business value because Product can't stick to a coherent feature strategy, that's Product's fault, not Development's. While you might technically be right, that's not a great attitude to have.
- youcensorme 4y agoDiagrams are utterly meaningless. Author apparently has never understod 'assembly line' nor knows how such things work. Of course my analogy doesnt map to code delivery, but neither does his burgers. Worthless
- crnkofe 4y agoI wish more people would read this. Both leads and devs. Finishing is the difficult part of software development. Conversely opening new projects/features/bugs is very easy. Opening many tracks in parallel slows down the entire team to a crawl to which the standard workaround is to simply work more hours o cut corners and take shortcuts thereby increasing tech debt as you go. Fight fire with fire. I also find people are twisting definition of done to make it look as-if it's over. Something being coded usually isn't done. It still needs to be tested which is the labour intensive task. Something being tested isn't done, it must be shipped and released to production. Code in production still isn't done. It must work and be performant enough, might need more logs, might need more monitoring. Last but not least it must get into the hands of the users who give the final word. But even then it might not be completely finished.
- roberttod 4y agoI think those initial diagrams/explanations miss a key detail. The longest step in cooking burgers is the grilling step, in which the cook is just waiting for the burgers to cook, and won't speed up the process by giving attention to one burger instead of 2. The idea that 3 burgers would take 12 minutes while 1 takes 4 isn't realistic, even without all the batch processing math later in the article. I still agree with the idea teams should do one thing at a time in general, but if you are going to do anything in parallel, it makes most sense to do other work when waiting for something to complete (as in the grilling step in this example)
- kqr 4y agoNow we're really taking the analogy apart until it's no longer reasonable, but I'll continue: Sometimes it makes sense to stand around waiting for the burger to cook. Maybe all you have to do are low-value burgers and it's nice to maintain an idle chef for any high-priority burger tasks that come in. Or there are important but non-burger tasks that need to be done but are easily deprioritised in favour of burgers.
- makeitdouble 4y agoWhere it really falls apart is that a restaurant has a predefined menu and no items are allowed to have unknown complexity (someone asking items out of menu just gets a “no”). Estimates are based on actual measures, not guesses. There will be accidents, but those will be rare enough to not have to be planned for. In that respect, a restaurant queue is a lot more akin to a factory, and is fundamentally different in nature.
- muzani 4y agoThere's a book, Everything In Its Place, Dan Charnas, which does a good analysis of the analogies of cooking and productivity in the office. Basically it recommends doing the "process" tasks first, the ones that the rest rely on. In this case, it would be grilling burgers. In the office, it might be something like assigning tasks or approving PRs. Charnas recommends that planning starts by "first things first" as opposed to say, the Tim Ferriss, Brian Tracy, or Eisenhower methodology of most important things first. And often the first thing is to figure out which things come first. And yeah, the book also recommends finishing where possible. A dish 90% done might as well be 0% done, but it occupies mental space while it's not done.
- jmathai 4y agoIn my experience on small teams that I've been on - a key motivator for people is shipping products and features. The sooner and more frequently you can do this the more positive reinforcement there is for the entire team - not to mention reduced risk of something never making it to the target users. Teams that have figured out the optimal way to get product and features into the hands of users as quickly as possible are the happiest teams because it's evidence that they're working together efficiently to meet their shared goals.
- jraph 4y agoReleasing is great. Unused work is quite sad. A big condition for motivation though is if people are not pressured to rush features. Being in a rush does not work long term and not being happy with the quality of the work done is very demotivating and impairs the sense of meaning. Micromanagement too. Personally, the two week sprints and daily stand-ups did this to me in my previous job, but I can see they could be a source of motivation for others. So, how work is organized and managed is really important too and depends on the people in the team.
- barking_biscuit 4y agoI hate having to ship features when I just want to work on improving reliability, doing upgrades, improving DX and clearing all the crap out of the way that's preventing us from otherwise shipping.
- ISL 4y agoIn this context, a completed upgrade or cleanup would count as "shipping". The article's author seems to primarily emphasize serializing processes so that incremental progress is readily evident to everyone and the organization can reap early wins from the first-shipped results.
- BurningFrog 4y agoAll that stuff is important, and I enjoy it more than most. But I also keep in mind that the only point of it is to enable shipping more features faster and better.
- captnswing 4y agoHenrik Kniberg recorded this fun 5min video a long time ago, about the relation between "utilization" and "flow" and how to optimize for both. I keep showing that to people, never gets old https://www.youtube.com/watch?v=CostXs2p6r0 https://www.youtube.com/watch?v=CostXs2p6r0
- thundergolfer 4y agoI just read The Goal, and that video has translated one of the lessons from that book, which is about industrial parts manufacturing, into the Agile software dev world. Good book, and good video.
- deleted 4y ago[deleted]
- coderintherye 4y agoThis is why when leading an engineering org I narrowed down to one metric: Committed to Completed Ratio It encourages completing things and only committing to what you can complete. It's legible, easy to understand by engineering, product, and management, pointless to game, and positively reinforces completion. It's quite difficult to accurately predict when a complete feature will ship, let alone a whole product. But, if one breaks down a feature into its legible constituent components and then commits to completing just what is within that (which also necessitates any required communication to arrive at understanding the requirements) then over time you can get quite good at predicting what you will be able to get done in a sprint and better at only committing to what you believe you can actually complete.
- nickreese 4y agoSounds like a book in the making. Would love to read this.
- mirekrusin 4y agoThe essence is right there in the comment, no? Why the whole book about single idea?
- coderintherye 4y agoThere's been some talk in Agile about such a metric: https://gorillalogic.com/blog/completion-against-commitment-cac-a-useful-metric-for-the-agile-team/ https://gorillalogic.com/blog/completion-against-commitment-... Changing to it was inspired by a few things one of which was: https://www.strategy-business.com/article/10204 https://www.strategy-business.com/article/10204 As well as a talk at CTO club which unfortunately is not shareable but can share the footnote listing: [1] 2014 State of DevOps Report https://devops-research.com/research.html https://devops-research.com/research.html [2] 2016 State of DevOps Report https://devops-research.com/research.html https://devops-research.com/research.html [3] 2015 State of DevOps Report https://devops-research.com/research.html https://devops-research.com/research.html [4] Westrum, R. “A Typology of Organizational Cultures”, http://bmj.co/1BRGh5q http://bmj.co/1BRGh5q [5] Shook, J. “How to Change a Culture: Lessons from NUMMI” http://sloanreview.mit.edu/article/how-to-change-a-culture-lessons-from-nummi/ http://sloanreview.mit.edu/article/how-to-change-a-culture-l... [6] https://www.slideshare.net/reed2001/culture-1798664/93-Highly_Aligned_Loosely_Coupled_Highly https://www.slideshare.net/reed2001/culture-1798664/93-Highl... Though if you are interested in a good book on loosely related subject, highly recommend "Principals of Product Development Flow" https://amzn.to/3Ox4PgB https://amzn.to/3Ox4PgB
- lutarezj 4y agoTo finish according to... scrum's definition of done ?
- makeitdouble 4y agoIt seems to me that actually, productive and predictable teams finish what they start. Going through the whole explanation, the base assumption is that tasks are clearly defined, there is few surprises, task pipelines seldom break in the middle because of external factors. Which is the hallmark of a predictable dev environment and by proxy, a productive team. All the team has to do to increase it output is stop doing the tasks in parallel. Conveniently, there is no real explanation of the status quo, teams must have been really lazy and couldn't think by themselves why they were doing so. This really feels like one more motivational preacher trying to sell that one weird trick to solve all your problem.
- jillesvangurp 4y agoDon Reinertsen has some interesting arguments for all this based on keeping inventory of work in progress low, maintaining short work queues (amount of time things sit in an issue tracker), minimizing the number of things being worked on at the same time, and minimizing time to delivery (cost of delay). Basically his reasoning is that overloading teams with more work than can be handled actually leads to delays and inefficiency. You get teams and developers waiting for each other and being blocked on each other. So, they start switching tasks and increase the amount of work in progress, which leads to even more blockage. It looks like everybody is super busy but it's actually very inefficient. Before you know it, you have lots of half finished things blocked on something and an issue tracker full of work that was specified months ago and probably is not even valid anymore. People get stressed and deadlines start slipping. All this increases cycle times of individual work items. Reducing the amount of work in progress means things move faster through the system overall and less things get blocked. And when they get blocked, it gets resolved faster. Also people feel better about things because they get things done. And, they get feedback faster, which is also a good thing. The counter intuitive thing with this is that reducing the amount of work increases overall throughput and increases predictability. I rewatch this once in a while because it is just such a great presentation: https://www.youtube.com/watch?v=L6v6W7jkwok&t=3601s https://www.youtube.com/watch?v=L6v6W7jkwok&t=3601s I try to manage my teams and products accordingly by creating clarity on what it exactly is that we are building from week to week and what the priorities are. I like having small teams or groups of people rather than having big teams. Because that allows me to have more than one thing being worked on. When it comes to product management, I don't like specifying too much ahead of time. There's no point in having months worth of inventory of feature work that won't get worked on until months later. By the time work starts, half of it is probably invalid anyway because requirements and priorities always change.
- nlstitch 4y agokind of an "open door"/empty title now, is't it? It's like; When you work a lot but never finish something, you probably just did a whole lot of nothing.
- boffinism 4y agoI once worked in a VERY chaotic startup with near-constant pivots and priority shifts. In each case, at the time, the change in direction could be justified... but morale was chronically low, particularly among software engineers. I spoke to one who, after a year, mournfully revealed that none of the code he had written had ever shipped. He, and most of his colleagues, burnt out and dropped out pretty fast.
- fendy3002 4y agoOne year? Try two and a half years without anything shipped. It's even worse that no project is being tested until two years mark. It is really demoralizing and shows how inefficient and unorganized the company at running IT-related projects.
- Kaze404 4y agoI just left an environment like that after almost 2 years. It got to me so bad that I can't even remember what it's like to work somewhere more organized, which is why I'm excited to start my new job soon.
- d0m3 4y agoThis article makes some assumptions that could easily change the result. By the way, if you have a batch size of 1 you're back to the initial hypothesis which is obviously not how things work in the fast food industry. I think it misses the point of idle time and availability. From the supply chain theory, if your resources are always 100% busy, your delivery time will go infinite because as soon as something takes a little more time as expected then you can never catch up. This applies particularly well to software engineering.
- js8 4y agoIf we all were just workers, it could work. In practice, I see lot of the high-level ideas/strategizing people starting new projects without finishing the old ones. They never bother with details required to finish or complete something. Starting and not completing is fundamental to labor division in capitalism, for better or worse. Without it, there would be less labor extraction.
- openfuture 4y agoWho knows if anything is finished anyway? So long as you live you can continue and the definitions are always in flux / personal. I believe the one who feels the strongest pull should work on manifesting a vision, not the one who had the idea; i.e. if someone says "it'd be nice to have cake" and another goes "omfg yes that would be the best" then who should make it? They could do it together but if the first person shops for ingredients and then decides they'd rather go to hawaii for a bit then the second person can still make the cake and eat it without the world burning down.
- Joel_Mckay 4y agoMost projects go though several design cycles, and this usually starts with a theoretical goal or a proof-of-concept requirement. I have found that identifying the “hard” features first, and defining fixed time-budget micro-projects or key unit-tests is useful. Primarily, this method quickly identifies if a project is even viable with the available team, resources, and knowledge base. Saying “No” to projects which incur serious liabilities, is just as important as minimizing project scope. Unconstrained sisyphean commitments are a common feature afflicting those with Founder's syndrome, and can have detrimental impact on projects as the intelligent begin to jump ship before it sinks. Every firm that lives past 1 business cycle will have a project boneyard. ;)
- miga 4y agoReleasing is great, but the 80:20 principle means that finishing 80% of features and throwing away 20% is always much faster than expecting to finish 100%. The difference between real life projects and college projects is that often nobody made the same feature in the same context before. This means that there will be features that will take much longer time, and need to be shifted to the next release or a bin for "complex enough to focus on everything else". If you do not understand why something like this happens, it may be that you are unaware of the knowledge gains from exploration as opposed to releasing the product. You just need one great product, and it is okay to throw away ten explorations to make it happen.
- miga 4y agoWhen one uses manufacturing job (burgers) as metaphor for software development, then you see that the guru thinks it is menial labour as opposed to knowledge-dominated process. Move along, there is little understanding to acquire from this post.
- bunsenhoneydew 4y agoI’ve had too many managers that thought this and none of them knew the first thing about software. They weren’t very successful. It’s a huge red flag for me if I realise someone at an organisation has this mindset.
- manuelfcreis 4y agoThe article is actually about this! How manufacturing processes are not a one to one comparison with software work. > The reason many people fail to acknowledge and act upon transaction costs in the software industry is that they compare software — a design process — to manufacturing processes.
- rubyist5eva 4y agoI know right? Software development isn’t grilling burgers it’s designing the grilling system and building the entire supply chain to get it shipped to the customer that is*.
- langsoul-com 4y agoI'd also add a large backlog of tasks is very depressing. If everyday you saw you had 100 more things to do and no matter how much you finish, the list doesn't go down, it's not exactly motivating.
- rubyist5eva 4y agoWhy? If the backlog is empty you don’t have a job anymore.
- k__ 4y agoSo, The Phoenix Project could have been an article? Nice!
- arminsergiony 4y agoI would like for more people to read this. leaders and developers. The most challenging aspect of software development is finishing. In contrast, it's incredibly simple to open new projects, features, and issues. Opening numerous tracks simultaneously causes the entire team to work at a crawl, and the traditional solution is to simply put in extra hours or take short cuts, which increases tech debt over time. Battle fire with fire.
- Heleana 4y agoI believe that those first explanations and graphics are missing an important aspect. The step in the burger-cooking process that takes the longest is the grilling step, during which the cook does nothing but wait for the burgers to finish cooking. The cook cannot speed up the process by focusing on only one burger at a time instead of both. Even without all of the math on batch processing that is presented later in the article, the idea that it would take 12 minutes to cook three burgers while it only takes 4 minutes to cook one is not plausible.
- cjmcqueen 4y agoDo you think you're considering the burger metaphor, ie the type of task, and not letting the point of the article stay front and center? I think we can agree that not all development tasks are the same, but I think the premise of first in first out is better than large bulk concurrent tasks, which I thought was the premise of the .
- makeitdouble 4y agoA real world example of the waiting to cook metaphor is PR review and client/QA validation. Imagine you’re working on an integration project where you use an API provided to you by a third party, there will be a point where you coded a client, you made the calls, and you’ll need their validation before moving that specific task further. And when they green light your implementation, you send that to QA which will review your feature in their next batch. If you consider your task completion to be “have the service integrated in production”, you have least two stopping points where focusing more on your task won’t help you go faster. The optimal move is to plan for those and fill the gap. It becomes trickier when it’s unplanned: you were expecting for something to work, but you’ll need to wait for a bugfix that will only comes in X weeks, for instance.
- civilized 4y agoWe shouldn't get fixated on it but it's worth noting that the metaphor is awful and it's weird that the author doesn't see that.
- smelbe 4y agoIt is readable, simple to comprehend for engineering, product, and management; it adds no value to the game; and it positively rewards finishing what you started. It is exceedingly difficult to precisely forecast when a whole product will ship, much less when a complete feature will be released. However, if one breaks a feature down into its legible constituent components and then commits to completing just what is within that (which also necessitates any required communication in order to arrive at an understanding of the requirements), then over time one can become quite good at predicting what one will be able to get done in a sprint and better at only committing to what one believes they can actually complete.
- hnbad 4y ago"It's effortless to switch from working on one burger to another" This is why software engineers should be banned from writing about anything outside their very narrow domain (and I say that as a software person). There's context switching when working on different features, sure. But there's context switching when working on different parts of the burger, too. Slicing two buns is faster than slicing one bun, then coming back from doing something else and slicing another. There's context switching in both scenarios. Heck, switching between writing a spec and working on the implementation is a context switch too. The switch between features is just generally more significant than the one between the different phases of working on the same feature compared to the steps of working on a burger. Heck, this also completely ignores that the chef likely doesn't ONLY produce burgers and even when they do not every burger will necessarily be the same. In fast food restaurants you'll actually see chefs do some steps in parallel (e.g. slice all the buns) and some sequentially. Additionally they'll often optimize to finish all items in an order in the same timeframe -- in all likelihood you're not a complete prick and actually want your friends to be able to join you for lunch rather than staring at you for 4-8 minutes while you eat your burger all alone. The analogy is not just simplified, it's completely ficticious to the point of bearing no resemblence to the actual process it tries to use as an analogy. It doesn't provide a common ground by referring to something everybody knows, it requires actively ignoring what you may know in order to make its point.
- hnbad 4y agoAs others have pointed out, the analogy doesn't even work for what it is trying to do. Tasks are heterogeneous (as are the features themeselves) and some steps involve passive wait time (e.g. waiting for CI, QA or reviews, or waiting for the grill to do its thing to the patties). Religiously linearizing the process by isolating each feature may actually often prolong the overall time in these cases.
- ChrisMarshallNY 4y agoA key philosophy of mine, is "Success begets success." I'll set goals small, so success and completion are guaranteed, then raise the bar a bit, on the next one, and so on. Soon, success and completion become habit, for the team, and the results are amazing. I end up with a team that isn't arrogant, but highly confident, and quite efficient. "Succeeding" also requires things like careful attention to detail, good testing (and fixing), documentation, and other "boring" stuff. Once that becomes habit, it's just "background noise." It just takes time, and that is something that seems to be at a premium, these days. But regular success just feels good. I recommend the practice.
- exodust 4y agoDon't even need to read article to know it's true. That finishing things, even sentences, is
- chiefalchemist 4y ago> How finishing what you start makes teams more productive and predictable What's even better? Starting the right things that deserve to be started in the first place. Efficient !== Effective
- jasonlotito 4y agoThe assumption here is that delivering the product is the finish line. That once you finish the burger, the person getting the burger is good to go and they can enjoy the burger. The problem is, restaurants don't work that way. If they delivered a single burger to a table, the guests would be upset and would wait. The person getting the burger would be waiting until everyone got their meal. You need to deliver all the meals at once, and you need to prepare all the meals in such a way that they can all be delivered at once. If you need to deliver 4 hamburgers, you prepare them in batches, and deliver them all at once. Sending out the order in pieces makes the end result much worse for everyone involved. Which is why it's dangerous to look at delivering features as the end goal. You need to deliver a complete meals. Sending out a single burger doesn't always make sense.
- utpaldg 4y agoPredictability is great in teams which know what they are doing. Oftentimes, in early stage startups, there is ambiguity in what needs to be under the WIP list. While it is optimal to minimise transactional cost due to context switching in that case, maintaining a constant throughput in that scenario would be sub optimal. Superb write up, though!
- Nemi 4y agoThough I agree with the premise of this article, I simply can’t get past his burger example. Let me explain. Multi-tasking has exponentially greater impact on performance the greater the complexity of the task. Most people just don’t find themselves doing these kinds of complex tasks on a daily basis. This is why coming up with a simple example that lay-people can understand is so hard. Simple examples don’t pass their sniff-test. It is obvious to anyone thinking about it that I can make two burgers simultaneously and it only adds a fraction to the overall time. This is because the complexity of the task is extremely simple. In reality it would add seconds, not minutes. However, once you ramp up the complexity of the task this penalty does approach 1 to 1, or greater. It is obvious to anyone that having to do a heart transplant while also doing your taxes at the same time would require longer than either task individually. An example like that is also easily dismissed because it is so far-fetched. I find that to really impress on people the penalty involved requires an example that is personal to them. If you can find some complex tasks that they do even rarely and have them envision doing them simultaneously, then they are more likely to buy into the idea. Let’s be honest, most people don’t find themselves in this situation like programmers do because of the deep thinking that programming requires, but if you search hard enough you can usually come up with some personal examples for people. If the person you are trying to impress is important enough in your life (spouse, boss, etc), then it is worth the effort to find some individual examples.
- rsanek 4y agoI found the example used in an anti-multitasking book I read to be both simple and compelling. The idea was to write all letters from a to z and all numbers from 0 to 25. Compare the total time between writing the alphabet first and then the numbers (abcd...; 1234...), vs. mixing the two (that is, a1b2c3d4...). The separate approach wins by a large margin, and is accessible to anyone to try themselves.
- supernovae 4y ago"Finishing what you start" has no meaning. None. In the weakest definition of "finish what you start", it means "I cleaned my desk, I finished what I started" but the reality is - the only way for this to be "done" is to have no more work and no more desk. The work of maintaining that desk cleanliness is never ending work and herein lies the problems we create for ourselves. Take the burger example and put it in a system - you're on to the next burger and some shmuck wants it without ketchup and with extra pickles. Then you have to cleanup the burger stand but cleaning up one day won't be the same cleanup as another and sometimes you may have to shutdown to deep clean - it's never done until you forever stop making burgers and close shop. For me, it's all about mindset. I look at work as rewarding when I never stop learning. The notion of done is what makes people crazy because it's never about the work being done, it's about not want to do the work to begin with and not seeing any value in doing it. My kids rooms are messy, i say they're lazy, but really they see no value in the work - to them, it's a waste of time. It keeps them from doing other things they would rather do. I laugh when they say they're done cleaning their room because without a doubt, not even a day later, it will be a stink mess again. Also, context switching... these discussions never make sense because they're always discussed in terms of state as an exception to the system. Your flow state is uniquely you, the system you operate in is complex and dynamic. I think all to often people put way too many words to paper trying to control complex interactive systems when they should really make them safe and resilient to monitor, observe, anticipate what's next and have the autonomy to make decisions. That autonomy and decision making and anticipation still requires effort and work - and i'll be honest, some of the best flow state is safely operating in complex dynamic systems while being able to mental model your position in it and have empathy for others - realizing that your model is yours and others will have there's. Done is imaginary.
- jdauriemma 4y agoThe author's conclusion is intuitively true to me. I suspect, though, it wouldn't convince a skeptic because of a complete lack of empirical evidence.
- jnash 4y agoI thought that was obvious? The easiest way to completely destroy the productivity of a team is to constantly switch tasks and never release anything. The team will quickly realize that the work they do doesn't matter and will switch to pretend-to-work mode or find another job.