9 ms·
Always Multiply Your Estimates by π (2013)
- airoftime 5y agoThat's a good one. I really like the sin graph representation .
- mattbillenstein 5y agoHa, I always said 3, I never knew this existed... You always see rookies make the mistake of just adding up the individual time of all the tasks - and engineers are famously bad at making horribly under-scoped estimates - so projects estimated this way have typically went over time by a factor of three or so as I've come to learn...
- telotortium 5y ago3 is the Biblical value for pi, so that's okay.
- adamrezich 5y agothis is not exactly true; here's some additional context for the curious: https://www.purplemath.com/modules/bibleval.htm https://www.purplemath.com/modules/bibleval.htm https://answersingenesis.org/contradictions-in-the-bible/as-easy-as-pi/ https://answersingenesis.org/contradictions-in-the-bible/as-...
- telotortium 5y agoThat's very interesting - thanks!
- entrep 5y agoIs this doable? A better approach would be to break it down as much as possible. This has the following benefits: * You will identify tasks you haven't though of * You will get a better picture of the total effort needed * It will be easier to provide grounds for your estimates to stakeholders * Developers will see progress as tasks get closed * Commits can be traced to specific tasks * Better estimates for remaining work during sprint/iteration/what-ever-you-call-it
- choeger 5y agoLet me guess, you work as a low-level manager? What you are suggesting is basically micromanagement-by-scrum. * Identification of tasks you didn't think of is a fallacy in software engineering. There are very few actual tasks when it comes to writing the software. Yes, sometimes you can break a change. For instance across components or features, but most often that has already been done when a developer gets a task. Most of the additional tasks you can come up with are either trivial, come after the end of development (e.g., deployment), or are completely arbitrary and not self-contained (write this class or that function). Very seldom a software development task can be broken down into several roughly equally complex subtasks. * It follows that you don't improve your estimate by writing down all these side tasks in your task tracker. You increase the busywork and friction and become less agile. These subtasks tend to become stale quite quickly when requirements change. * Your stakeholders don't understand anything about aoftware development. Unless your task is trivial to begin with, there is little ground in any estimate. * Developers either see progress through code reviews, technical discussions, or the source code itself. No need to maintain a list of tasks in some tracker for them. * Commits should be self-contained and have a meaningful message anyways. It should be trivial to trace them to the main task. * Your estimates won't improve at all if you break down your task arbitrarily. If you create subtasks like "write the tests" it might help a junior to structure their work approach, but in a professional environment it is pointless. Worse, if time is at the essence, some product owner might ask you to deploy "just an MVP" before that subtask is done, postponing it forever. The only reason to break down a task is when there's a time-like dependency in the process. E.g., I can do X after Y gets deployed. Or I need to remove Z once Q is done. Mostly, tasks like Y or Q will involve operational aspects (data migration, experiments) so the subtask will have a different owner or at least a different context.
- janto 5y agoIn my head I usually do "an order of magnitude" increase to do things properly. 1h to 1d to 1w to 1M to 1Y. Thats kind of like a multiplier of τ=2π
- porb121 5y ago....that's not an order of magnitude each time
- janto 5y agoa calendar "order of magnitude". I can't think of a better term.
- powersnail 5y agoPerhaps “up a unit of measurement”?
- janto 5y agosounds about right
- bluenose69 5y agoThis is what I was taught: double the estimate, and increase to the next unit. It was mostly as a joke, though. The wise scheme, as has been pointed out, is to adjust predictions during a project. If the task that was initially planned to take a day is routinely taking 2 days (or 2 hours), adjust future plans accordingly. Higher-level managers are sometimes unhappy with this scheme, while middle-level ones value the accuracy of such predictor-corrector schemes. This gets us into a related topic of the depth of management structures, and I think the military scheme (of each person directing a roughly fixed number of persons, so the number of levels is proportional to the log of workforce size) might be worth considering.
- mdp2021 5y agoI would say it is a "superset timeframe".
- necovek 5y agoFor something with such a large margin for error, it can only be funny to use something with multiple digits of precision (like Pi is). Unfortunately, not funny enough for me to want to use it, and the attempt to rationalize it only makes it worse. (iow, that's not a particularly funny joke either)
- pantulis 5y agoThat's interesting becase x3 is one of the axis of the famouse "from code to software product" chart from Fred Brooks "Mythical Man Month". But there are two of them, so really it's x9, almost an order of magnitude.
- TeMPOraL 5y agoAerospace says π, but they do separate normalization of time and costs: > 29. (von Tiesenhausen's Law of Program Management) To get an accurate estimate of final program requirements, multiply the initial time estimates by pi, and slide the decimal point on the cost estimates one place to the right. https://spacecraft.ssl.umd.edu/old_site/academics/akins_laws.html https://spacecraft.ssl.umd.edu/old_site/academics/akins_laws...
- atoav 5y agoFor predicting the daily schedules on a film set I always "ran a simulation" of what would be done that day and just summed the predicted minutes. The simulation ran in my head of course, but it included things like: Actors drinking coffee and chatting, costumes getting ready, Camera department forgot memory card in the car, lunch breaks, someone arrives late, etc. Obviously the major chunk were always scenes and they are usually also the major contributor to the insecurity of the prediction. E.g. working with people who you don't know, weather, technical problems (broken, missing stuff), stuff that just won't work (animals, certain scenes with actors). But in the end what always mattered was that there was a time plan for each day and at the end of a day we would know wheter we are A) faster as predicted, B) on time or C) slower than predicted. The next day would then be restructured accordingly by the production and usually you'd be back on time by the end of that. I was usually spot on with my predictions and we never had any issue with getting the planned stuff done. With programming the whole thing is harder, because it can be even more unpredictable. But what definitly always helps is when you have a feeling for whether you are too slow, on time or you managed to build a time buffer for future doom.
- regularfry 5y agoTom DeMarco talks about modelling-based estimates in Waltzing With Bears, mainly to break people out of the error they fall into of treating the soonest possible time something could be done as a realistic estimate of when something will actually be finished. There are also approaches like Function Point Analysis which provide an explicit model that you can calibrate your team against. It's doable, but what people tend to forget is that it's work. If you want an estimate, I need to be able to expend effort providing it. It's an engineering activity that needs organisational support to do it at all well, but often you find an expectation that people will be able to pull an estimate out of a hat just having heard the faintest description of the problem, and there can often be a tacit belief (usually but not entirely from non-technical folks) that not being able to do so makes one incompetent.
- kqr 5y agoThis is where range-based estimations really shine. If you want an estimation right now, I will tell you on the spot that, "I'm 95 % certain it will be done no later than nine months from now, but probably sooner. However, I know it won't be done this week." You want a narrower range than 0.25–9 months? You'll have to let me think about it. Maybe I can be just as certain that it will be done 1–5 months from now, if I get time to mentally run through the simulation, to borrow the terminology from upthread. You want a narrower range than 1–5 months? I don't have the information I need to give you that. If you give me a couple of weeks to talk to the right people and start designing/implementing it, the next time we talk, maybe I have gotten the range down to 1–3 months. I can always give you an honest range, but the more you let me work on it, the narrower it gets. ---- This is of course what's suggested in How To Measure Anything, Rapid Development, and any other text that treats estimation sensibly. An estimation has two components: location and uncertainty. You won't ever get around that, and by quoting a single number you're just setting yourself up for failure.
- kornakar 5y agoThis reminds me of my game development job I had years back. I was new to the field (but not new to software development) and there was this small software team doing programming tasks for the game. The lead developer was concerned on my performance after a few months I was there. I remember him drawing an image excatcly like the second picture in this article (an arrow going from A to B). He said that my performance was very poor, and then he drew another picture that was like the circle in the article. The way I worked was searching for a solution, going wrong direction a few times, asking designers for more information and then eventually landing on a solution (that worked, and users like it). But I was told this is wrong way of doing software. I was not supposed to ask advice from the users (because the team "knew better"). He also told me that a good software developer takes a task, solves it (goes from A to B), and then takes another task. After a few weeks I was fired from that job. To this day I'm still baffled by this. The company was really succesfull and everyone knew how to make software. It seemed like a very harsh environment. Is it like this in the top software companies everywhere? Like the super-pro-developers really just take a task and solve it without issues?
- xupybd 5y agoI've heard game development is pretty ruthless.
- necovek 5y agoThere are tasks you are experienced with that you can pretty much jump on and just do them, but there's also the other 90%. What's weirdest about your story is that you were laid off a few weeks into your job. People usually get more time to get the hang of it even if they are senior, so I would mostly assume that it was a cultural fit rather than performance. Some outsourcing/service (billed by the hour — which explains it for the most part) companies would look for very strict delivery cadence with focus on exactly the process you describe, but you'd be unlikely to have contact with the user in that case (just the customer). Most importantly, if you ever get fired, be sure to ask for the explanation so you don't end up being baffled.
- kornakar 5y ago
- janto 5y agoThat's the kind of shortest path you'd get if two tasks appear on the straight line and you want to keep a minimum distance away from them :P
- aasasd 5y agoTwo points to elaborate, already mentioned in the neighbour thread on estimation. Firstly, programmers are notoriously and famously bad at estimation, so it's highly likely that you do need to find the multiplier for yourself. This illustration is something like fifteen years old by now: https://pbs.twimg.com/media/EyNRiYQXMAIshEj.jpg https://pbs.twimg.com/media/EyNRiYQXMAIshEj.jpg Secondly, wise managers know to expect this, and do the multiplication themselves. But if you have managers who do the opposite and always scale the estimation back, expecting the results earlier that promised, then you need to use a second multiplier—which the manager will unknowingly annul, getting closer back to your actual figure. Probably something around 1.5 to 2. However, if you need the second multiplier then you also gotta ask yourself why you're staying in that company.
- capableweb 5y agoThis is good advice but forgets that people are part of how long time something will take as well. If it's one engineer, it'll probably take $estimation * π, but if it's two engineers, you probably need to double that. If it's three, triple it. New calculation should be something like "($estimation * π) * $peopleWorkingOnSameThing". Communication overhead and mistakes should not be underestimated.
- notimetorelax 5y agoI agree that communication overhead exists but I think you’re ignoring the benefit from having 2 people working through a problem vs one person. I’ve seen much faster results because people don’t tend less to get stuck if pairing with someone.
- TeMPOraL 5y agoIn my experience, that's pretty high-variance. The perfect result - one where you get anywhere from 1.5x to 10x boost of productivity - requires pairing people who communicate well, are on relatively similar skill level[0], can focus, and who both have a good day. No distracting personal issues, no emotional problems, or other kinds of things that make you unable to focus in presence of other people. If any of those conditions isn't met, pairing up will waste time. There's some confounding involved, of course - for example, a good rapport with teammates can mitigate the effects of private issues. But my point is that you can't just pair people up and expect productivity to improve; it'll likely decrease, and it'll likely swing wildly from day to day. -- [0] - With respect to division of work on the task. Like e.g. a long time ago I was in a gamedev competition with a team of artists. I was nowhere near as good a programmer as they were artists, but we decided to make an art-heavy game, so our workloads balanced out and we proceeded almost in lock step.
- Aeolun 5y agoWait, so you are saying that the net positive effect of adding an extra engineer is zero?
- 5y ago
- deleted 5y ago[deleted]
- Borrible 5y agoYes, but that's only half of the software development circle.
- anotheryou 5y agoThings I include that are easy to identify: [my honest best estimate thinking off all I can think of] * X +1 on the factor for any of these: - always +1 right away (so it's x2) - tech is new for you - other teams involved - you don't have a clear idea of what tasks are involved (it's not yet another X) - you see additional risks So if it's making a yet another micro marketing website based on an pixel perfect photoshop design: x2 If the design is not pixel perfect or missing responsive: the customer is involved: x3 If you refactor stuff in to new tech and it changes apis to other teams: new tech, other people, risks, no clear tasks: x5
- einpoklum 5y agoMy problem with multiplying my estimates by Pi, or any n > 1+epsilon, is that one's boss often looks at such estimates and asks "How can it take you so long to do just XYZ?" and they would rather, in effect, be given a shorter estimate initially and settle on delays than be given a more conservative/inflated estimate, even if in the latter case there is rarely a delay.
- jyriand 5y agoHofstadter's Law: It always takes longer than you expect, even when you take into account Hofstadter's Law
- Ahan515 5y agoSo true!
- ohthehugemanate 5y agoThe research on this stuff says that time estimates are extremely inaccurate and to be avoided. If you manage to stay inaccurate by ONLY a factor of 3.14, that is unusually high accuracy. Much more accurate are estimates of difficulty or complexity (small medium large, weighted numbers, whatever). The manager can then make an average conversion rate to time (with error bars), and use that for medium/long term forecasting. This is demonstrated extremely accurate compared to time estimation (but it is useless and breaks if you apply time/points pressure to your team, or even let them think in terms of a time conversion rate). This is not new research. Kahneman's Nobel prize about decisions under uncertainty was in 2002. Put away the superstitions and stop estimating with time!
- spacemark 5y agoSo basically, engineers estimate complexity and the manager converts that to time? Still sounds like estimating with time to me.
- girvo 5y ago> manager converts that to time Based on past data, I think. But yeah it's still not great IMO, even if it might be slightly more accurate in some circumstances.
- mrzool 5y ago> Oh, and that to-do list you made last weekend? It’s no coincidence you only got about a third of the things on the list done. ;-) He nailed that one for sure.
- ekianjo 5y agoRather than spending time in no so accurate planning its much better to break down long tasks into small ones and then measure continuously how fast you go through those and revise every day or every week your assumptions.
- KingOfCoders 5y agoSoftware estimation is fractal. The closer you look, the more details you see.
- redler 5y agoI've found this "story" by Michael Wolfe [1] (warning: Quora link that you may need to open in an incognito window) to be a fun way to explain why accurate software estimation is so difficult. [1] https://www.quora.com/Why-are-software-development-task-estimations-regularly-off-by-a-factor-of-2-3/answer/Michael-Wolfe?srid=3Gx https://www.quora.com/Why-are-software-development-task-esti...
- KingOfCoders 5y ago"My" idea was also inspired by coast lines, in the initial examples for fractals with the English coastline. And I often use coastlines as an example to explain why software development is fractal. Will use your link in the future, thanks!
- dghughes 5y agoThe Scotty principle. On Start Trek Scotty said to Geordi you never tell the Captain how long a job will take you always pad the time significantly.
- deleted 5y ago[deleted]
- Guthur 5y agoI have broader issues with estimates and deadlines but when pushed i follow a general rule. If the problem is not some trivial configuration or otherwise mundane change I measure it in weekly units. With weekly units it's unlikely for you to have a blow out of more than 50% with out clearly seeing it coming whereas when you say it'll take a day or two you can so easily have a blow out of 100-200%.
- jcutrell 5y agoAt a former job when I had some organizational influence, we started doing this and called them “team weeks.” My goal was to sell the week x team model to avoid constant streaming of tiny straggling tasks. (It was an agency.) I think the model works, but didn’t totally match that agency. It’s a good theory though
- andreareina 5y agoThere was a claim I saw somewhere that the actual time required fits an exponential distribution with the estimate as the scale factor. Does anybody know the actual source, or a pointer thereto? This is assuming that the study actually exists and it isn't a "just so" story...
- jrh206 5y agoI think this is the article that you’re recalling: https://erikbern.com/2019/04/15/why-software-projects-take-longer-than-you-think-a-statistical-model.html https://erikbern.com/2019/04/15/why-software-projects-take-l...
- dgb23 5y agoPeople tend to want to hear or give the shortest estimate that seemingly sounds feasible. I don't do that anymore. I try to push estimates as high as possible and then collaboratively cut down on requirements/promises/features to match an expected (time) budget. This often leads to more pragmatic work items and sensible prioritization from the start. And it is an opportunity for general communication and understanding the value of things.
- jcutrell 5y agoMy theory is that this has to do with our difficulty dealing with delayed gratification. Tell people a short number now = immediate praise, long term pain. Tell people a higher estimate, immediate negative; finish in time = delayed gratification.
- kilroy123 5y agoI agree but you can often miss out on work if you do this as a freelancer. Last potential customer I spoke with I did this. They were insulted by my estimate and practically hung up the phone on me.
- dgb23 5y agoWe can't read the mind of that potential customer. Did they want cheap, fast labor? Probably. Do you optimize for that? I assume not. You might have dodged a bullet or maybe there was a communication issue.
- saalweachter 5y agoI will sometimes give an estimate in multiple ways -- "This takes about four weeks for the engineering work, but unless we remove all other priorities it will take about 3 months to complete." A lot of the time when you are working the delays aren't just the uncertainty of an individual task; it's that you're working on several projects at once, you're attending meetings, etc, so that you might only average 2 hours / day working on a particular task or you might not be able to start a task for several weeks (depending on whether you work sequentially or in parallel). You still need a realistic, achievable estimate for that first time, in case management calls your bluff, but distinguishing between "the amount of effort this will take" and "how long it will be before it is complete" can help set realistic expectations while making it harder for management to mistakenly think you need two months to complete a task that could be done in two weeks.
- jcutrell 5y agoThe most important thing I’ve learned about estimation is that, especially in larger/more established companies, it really only matters in two basic scenarios: - Order of magnitude differences - hard deadlines (like a public event you are supporting) Usually estimations between two things don’t matter as much as prioritizing those two things. Work on the thing that matters the most. If it takes 2 days or 5 days, in most cases it won’t matter - it’s still what you would work on, so functionally estimation wasn’t needed. If it is a difference of 2 days vs 2 weeks (or some meaningful magnitude to you) then you start having opportunity cost that factors into prioritizing. Estimation is more often used as a tool for “control and prediction” - how many times have you had incredible success because you controlled or predicted an outcome?
- larrydag 5y agoOne method of estimating projects is using the old method Activity Based Costing. This can be used to estimate time-related activities as well. The key is figuring out your total utilization of time cost estimates and per unit of time cost drivers. https://hbr.org/2004/11/time-driven-activity-based-costing https://hbr.org/2004/11/time-driven-activity-based-costing
- SkipperCat 5y agoA good project manager helps flatten the curve. The most important thing they can do is prevent engineers from having to be 'specification detectives', where the engineer has to search other business groups for the actual details of the deliverables. I've always been happiest working in places where I focused my efforts diving into the technology rather than interviewing salespeople to find out exactly what they promised the customer.
- booleandilemma 5y agoYeah, I could see my team cargo culting this.
- brightball 5y agoEvery time I’ve heard somebody say this, usually in management, it has been because they don’t take into account their multiple disruptions of the developers throughout the process. Tends to be a big signal for lack of personal accountability from the person saying it.
- jmnicolas 5y agoI'm absolutely unable to give a reliable estimation so I use the "Duke Nukem Forever" method: when it's done.
- PerkinWarwick 5y agoI can understand the need for a multiplier as a lot of estimates are based on (a)working continuously and (b)nothing going wrong. My best estimates were more along the lines of 'how long did this take last time' and then building a schedule by subdividing that.
- deleted 5y ago[deleted]
- RedBeetDeadpool 5y agoThis seems to follow my experience, although I attributed it to the Pareto principle. 80% of the feature will take 20% of the time. The last 20% will take 80% of the time once you factor in all the other things like: - getting the feature working correctly to all specifications. - thinking about larger scale impact of your code and how your team might react to it, and deciding on which implementation to take. - resolving missing edge cases. - previously undescribed features the design team overlooked, but is now obviously wrong now that they can see it in action. - time it takes to roundtrip the review process. - resolving unrelated bugs that code changes may have created. - writing tests. - manual testing. - fixing bugs found in regression tests. - deployment and deployment related errors (happens rarely, but you have to average it out). Just getting to "I got this feature working!", seems to only be a small part of the whole process.