Speed matters: Why working quickly is more important than it seems
jsomers.net
jsomers.net
Yes, there are situations where working too quickly will bite you, so you can't always do it. But the key idea here is that by working quickly you reduce your expectations of how costly a new effort is. Then you'll actually start it. Inertia is a powerful adversary. Any weapon you can put on your belt to fight it is worthwhile. I'm keeping this idea.
If I prioritize quick responses and turn arounds to requests that are important, provide value, and allow me to improve important skills, that is not incompetence.
If you de-prioritize items, regardless of their importance and value but simply because you don't want to do, that could quite conceivably be called incompetence. However that rests on the assumption that you don't want to be competent.
I generally want to be competent. When there are things I don't want to do, it is usually because they are part of a bad, inefficient process that I haven't managed to change yet.
(In practice, I've found that anything that's >50% shit or so isn't worth wasting time on. Stuff that's >50% good, informative stuff is usually qualitatively different from stuff that's 5% good informative stuff; go where the former is.)
And when extended to people - just because someone says something stupid or wild doesn't mean everything they say is that way.
But one good counter example does come to mind - designing a database schema.
I'm trying to wrestle with what the difference might be. I think Markov processes, e.g. processes where the future state depends on a prior state, are relevant.
Maybe we could say tasks are either "strongly Markvoian", that is, how well we do them now will influence our future work and hence we should really think them through, e.g. designing a schema. Weakly Markovian, in which case there may be some future impact but not much, and so we exercise caution but "done is better than perfect". And finally non-Markovian - e.g. throwing out the garbage, cooking dinner, most emails - getting the thing done is simply a pass/fail and so we just have to do it, quality is relatively unimportant.
I think what I'm saying is, most tasks will be weakly or non-markovian, so we should "move fast and break things", but every now and then there'll be something we need to do that is strongly markovian. For such things we should be prepared to take a step back and give ourselves a little extra time, so things don't blow up further down the track.
I feel like when you focus on speed you very quickly learn just enough to get the task done quickly. And then your progress stalls.
I find that when I'm doing any work that involves modifying existing code, there's a huge difference in how quickly I can work when I'm touching code that was originally written by people with different work styles. Usually I can sail through the more methodically-written stuff. When the time comes to make changes to code written by the people most fond of uttering, "The perfect is the enemy of the good," though, progress slows to a crawl. Adding new features without introducing new defects to that code is like trench warfare.
That said, much like the article says, the fast workers did tend to get assigned more new tasks. I think maybe this was a huge win for them. From a wider perspective, though, it's a bit tragic because it results in this inexorable downward spiral in terms of code quality. Of course that worked out well for them too because more defects meant more opportunities for them to cape up, swoop in, and save the day. I can't remember who it was who said, "Beware of your firefighters, they are probably your chief arsonists," but there's a lot of truth in that statement.
* Typing on a keyboard
* Sharpening a knife
* Driving a car.
It seems more like a question of doing things a lot and very focused, than focusing on speed initially.
Basically go slow and work on the correct form/line/being smooth/etc... Once you have that down, you are ready to go fast and you will be better/faster than someone who hasn't gotten the flow down at a manageable speed first.
Speed is impressive, but you literally have to learn to walk before you can run!
I'd say it depends on your current skill level rather than on a task property like "strongly Markovian". Learning has diminishing returns. At some point more learning is not worth it anymore.
Do things fast when the cost of doing them wrong is low. If you're learning something, or doing something with low risk, then doing it as fast as possible is a really good idea (for all the reasons set out in the article).
But...
Do things slowly if the cost of getting it wrong is so high that you'll have no opportunity to try again. For example, don't pack a parachute quickly.
The key is recognising that there's more than one way to approach soemthing; selecting the right method for the problem at hand is the winning strategy.
The idea is that any decision that is straightforward or easy to change should not be sweated over for any appreciable amount of time, and in fact can be deferred indefinitely (deciding not to decide).
Meanwhile, any decision or indecision that will have long term repercussions should be considered at length and with all due haste.
I mention indecision here deliberately, because things like deciding not to put authentication into your application in version 1 counts as a decision, one with far reaching and usually fairly aggravating (IME at least) long term effects on the project. Others would include thread safety, the ability to cluster or shard your design, multilingual support, audit trails, etc. If you are the only solution in the space then you often have time to correct these mistakes. But if one of your competitors figures these things out before you, you can find yourself in real trouble (one of the aspects of the Innovators Dilemma).
Let's say in a life time, the accident rates due to packing a parachute quickly is 1/10000, and the fatal rate of the slow packing group is 1/1000000. Even though the fast group faces bigger danger than the people in the slow group (or people sitting at home), but other than the few who have the bad luck, the rest of them will practice way more than the other group, jump more times, go to more places, have bigger opportunities to become a world champion of parachute packing or whatever parachuting sports.
Sure, a few will be forgotten by the world.
The victors we see in the world are probably the people who are still alive in the fast group, and have produced lots of results because of their speed and being still alive. Someone in that group will pay a huge price, but it's not necessary you or any particular one.
You didn't give specific numbers on how often someone can jump, but consider the realistic bounds on how much more often a person who packs hastily can skydive. How often is this person jumping? Are we in a scenario where the amount of time it takes to pack a parachute is really the limiting factor, to the point where the hasty packers can jump "way more?" Seems like what that would mean in concrete terms is that as soon as you hit the ground you're going to hit the john, re-pack your chute, and immediately be back in the plane. Is that a realistic scenario?
but hey it's just me. this place is usually pretty civil - it's in the rules.
If the probability of death from packing a parachute quickly were 1/100 then I think your argument would break down somewhat. Like I said, you should spend the appropriate time on something depending on the costs and risks associated with it. "Do everything fast" is wrong, but so is "Do everything slow".
[1] In 2003 the annual risk of being killed as a car user were 1/15261. http://www.medicine.ox.ac.uk/bandolier/booth/Risk/trasnsport...
Skydiving (US): 9 out of a million chance of death per jump
Skydiving (UK): 8 out of a million chance of death per jump
... where 1 micromort = 1 in a million probability of dying
[1] https://en.wikipedia.org/wiki/Micromort#Leisure_and_sport
Write a to-do list app super fast, but take time with medical software...
Take time to pause, reflect, think, and enjoy your life experiences.
Even when it comes to work-related activity, there are times and places to do things quickly and there are times and places to do them deliberately. If nothing else, just for sanity's sake, it is important to pace yourself through a day, through a week, through a month, through a year, through a career. Even if speed were exactly correlated with maximum productivity and effectiveness, it is vital that you have times when you simply feel you can enjoy being at work, being with people, doing your activities, without everything feeling you have to work like a machine that will be evaluated by engineering standards only.
Even more, we all have different personalities and some people do not work well if they feel they are forced to work at some arbitrarily quick pace as opposed to one that suits their style.
Finally, even speed as a factor can vary with your activities as you develop skills in those activities. When I began years ago to try to write things, I was agonizingly slow about the process. I felt I had a quick mind but the process of getting what was in my mind down on paper made me feel plain stupid. Whatever I did, it would never come out right. Through a very tedious process of writing and re-writing, it would eventually become passable and that was it. It might take me a week in such cases to write something expository of modest length. Yet, realizing this was a weakness, I worked damned hard to fix it and, through a process of many years and countless hours of effort, I reached a breakthrough point where I could do "walls of text" (in the phrasing of some) in 10-15 minutes and produce quality stuff. I now write very quickly and effectively. But had I tried to do so years ago with my limited abilities at that time, all I would have produced was hash.
So, lighten up and do it in your own style. Yes, speed does matter. But it is only one of many factors that will determine how you do at work or, even more important, at life itself. By all means, apply yourself well - be diligent, hard-working, etc. but do it fast or slow as suits your needs and your own style. At least that is how I view it.
I don't think that is quite what the article is suggesting. I think it was reminding us to thinking about the effects of the speed at which you accomplish things. If there is a behavior you are trying to encourage in others (e.g. requesting a code review), focusing on responding quickly can be crucial to helping foster that behavior. Similarly, if there is a communication channel (e.g. Slack vs. email) that is not being adopted, holding yourself back from quick responses to those emails while responding quickly to Slack messages will help foster the transition.
This doesn't mean that you need to do everything as quickly as possible. It does mean that if there is something that you do slowly that you want to improve on, it may be helpful to be aware of the additional mental cost you associate with the activity so that you can compensate for it. Similarly, if you are trying to improve the quality of your writing, focusing on improving the speed of your writing (or even just the speed of your typing) while maintaining the same quality might pay off faster than just focusing on improving quality.
It's not faster today - if you kept working, you'd presumably get more than zero done. But you'd also create more bugs, and you'd come back more tired tomorrow. Coding is not an assembly line; your brain needs to be fresh.
Taking time to pause, reflect,and think is the same. It's slower in the next minute, maybe in the next hour. But stopping to think and realizing what is the right thing to do can save you days of waste.
My first boss said, "You need to learn when the most productive thing you can do is go look out the window for 15 minutes." After 30 years, it's still good advice.
I'm ignoring your point about work-life balance here. All I'm saying is, too much emphasis on speed slows you down, even only considering work.
Slow is smooth. Smooth is fast.
If I take 20 minutes more to code a module because I'm thinking about it, but spend 30 minutes less debugging problems with the module, that's fast.
If I take a day to respond to an email, but the person I'm conversing with gets the info they need, avoiding three more days of back and forth, that's fast.
If I take a week longer to iterate through a project idea, but nail the implementation, then I can know that I'm pivoting because the idea was wrong, not the implementation.
I kinda think that the opposite is true, or at least as true as your statement (meaning that at least as much half-baked stuff rushed out the door 'stood the test of time' as did stuff that took a lot of time to ship.) Unix, C, Windows, PHP, JavaScript...
Even in the examples you mentioned, Unix, C, and Javascript are all run through standards bodies now. It took years for C11 to be finalized. It's been years since ES6 has started development. PHP7 has taken a few years (and a version update before even being released).
Windows, depending on who you're talking to, can be a good example of half-baked, or an example of why half-baked is terrible, with regards to Windows 8 and Windows 10 releases.
So all projects that have "stood the test of time" for that length of time have that attribute. Also having that attribute are all the projects of that era that failed miserably.
Plus, people seem to like it when they ask something, and you help research through it with them. They come back to you again, which gives you another free opportunity to share someone else's learning, and you quickly turn into that person who either knows everything, or knows where to find out.
My general rule has been - always ask what they've tried first. If it seems a sincere effort has been put into it so far, by all means help out. It may be something you know immediately, but there is value in teaching people to learn for themselves.
On the other hand, if I'm dealing with a "senior" engineer who's doing that, I'm actually less worried about whether there's been sincere effort. It's just the other side of the same coin: They've offered their learning opportunity to me, and I'm happy to take advantage of it.
* Momentum - To stick with something and finish it, you need to use momentum. Lacking momentum, projects languish. Quoting author Steven Pressfield: "Second only to habit, momentum is a writer’s (or artist’s or entrepreneur’s) mightiest ally in the struggle against Resistance."
* Waiting is painful. That's the point behind the examples in the middle section (waiting for an email reply, waiting for Google, waiting for an employee to finish a task). One thing this article makes me more aware of is the concept of getting impatient with yourself. Part of you is the boss or client that wants things accomplished, and it is sizing up the worker part of you, wondering if it assigns a task whether that task will get done quickly or require a lot of waiting, and there's a relationship to manage there. (Perhaps this dynamic underpins the phenomenon of momentum?)
* Quantity Always Trumps Quality - There's a blog post by Jeff Atwood with this title. The point is, if you want to get better at something, do a lot, and don't worry about quality while you're practicing.
Focusing on "speed" is probably a good mental trick for a couple reasons. First, it validates and acknowledges that we hate to wait. Second, it helps overcome perfectionism and the tendency to think and judge instead of doing and creating, by giving us something to measure that is not about quality but is instead correlated with action and progress.
I wholeheartedly disagree. My martial arts instructor had a saying: "Practice doesn't make perfect. Perfect practice makes perfect." I've found that to be true. After all, if you practice bad technique, how do think you're going to perform in real situations?
Not to mention, you usually practice things in a controlled environment where you are evaluating your own technique. That's often not true in real situations, where your focus needs to be split on many different things. If you want to execute well in a real environment, good technique needs to be second nature so you don't have to think about it. You just do it. Being able to do that requires a large amount of good practice.
I can relate what you're saying to my experience taking singing lessons, though even there, I find that making progress is all about turning off the inner judge while you practice. All you need to practice something is a bit of intent and a bit of awareness; it's not important that you "worry" about the quality of what you are doing, per se.
1. If you are coding ensure that your debugging environment is good (simplest example would be if you write HTML how long does it take to see the output or is it auto-refresh itself int the second monitor when you change the file?).
2. If you are building a project how long does it take to deploy? Do you have CI with a one button push to production environment? If you have then you'll deploy faster and more often there is no overhead. If not you won't want to deploy often due to the overhead of the deploy.
etc.
The most important lesson I've learned about speed is that "design your environment and build for speed and remove the repetitiveness" then you can be fast. You can apply this rule to many things. Blogging, ensure that your blog tool makes it easier (how easy to link stuff, find images, does it really necessary to add an image to all posts, do you FTP upload, or do you just copy&paste and image to the editor, what happens if it crashes, do you lose data or does it just recover?)/
An alternative explanation would be that if you don't take your time to understand people's mail and just rush to answer them as quickly as possible, things that would take two mails to communicate now end up being a thread of ten mails, two phone calls and an in-person meeting.
Nothing is more infuriating than a person that replies 30 seconds later with a message that suggests they didn't read past the first sentence.
I don't know the author or his ways of responding to emails, but in my experience the above often applies to people that value speed above all else.
I also don't respect people that always respond to email immediately because it makes me think they don't have anything important enough to work on that requires unbroken concentration.
It's not to get the same amount of work done in a shorter time (the management fallacy referenced in some of the comments).
The point of speed is to increase the number of feedback opportunities. Each feedback datum allows for slight course corrections / confirmation of original hypothesis.
By analogy, think of it like sample size. If you accept time as a primary constraint, then faster iterations (even if you accomplish less!) tend to give you more samples. More samples mean less variance.
Making decisions on a better model (less variance) is very appealing to me.
> I was taught in college that one ought to figure out a program completely on paper before even going near a computer. I found that I did not program this way. I found that I liked to program sitting in front of a computer, not a piece of paper. Worse still, instead of patiently writing out a complete program and assuring myself it was correct, I tended to just spew out code that was hopelessly broken, and gradually beat it into shape. Debugging, I was taught, was a kind of final pass where you caught typos and oversights. The way I worked, it seemed like programming consisted of debugging.
> For a long time I felt bad about this, just as I once felt bad that I didn't hold my pencil the way they taught me to in elementary school. If I had only looked over at the other makers, the painters or the architects, I would have realized that there was a name for what I was doing: sketching. As far as I can tell, the way they taught me to program in college was all wrong. You should figure out programs as you're writing them, just as writers and painters and architects do.
1: http://blog.codinghorror.com/quantity-always-trumps-quality/
2: http://lesswrong.com/lw/53e/just_try_it_quantity_trumps_qual...
Its one of the key lessons YC taught me.
Working "fast" is tricky. The ironic conclusion part of the article is an example to that. People will miss the point and screw up more while trying to be "faster". However if a task becomes more automatic, it will become faster, which means that actually doing something "fast" would consume less energy, since it is more or less automated and unconscious, while "trying" to be fast would consume more energy.
The key here seems to be that just do something "a lot", and it will become faster by itself through time by being more and more "automated". But take your time, and stop worrying about speed. Speed is just pressure which will bring more pressure as you do stuff faster. Don't create unrealistic pressure.
Another key is garbage collection. Just get stuff "done", and get rid of the old tasks, or treat your long to-do items as "later" lists. If something really matters, you will do it anyway. You won't even need a to-do list to keep track of your "important tasks".
You need to self-reflect after each iteration, mind you, to make sure that you learn each time you do the thing. But, this is necessary for skill progress whether you're going fast or slow.
(And, having to make the corrections can be as informative or more so, depending on how you're able to reflect on the "why" you're refining or fixing the thing).
Yes, but that's frequently not the case. Developers at "sweat shops" tend to write far more code, and work many more hours, than the average dev at a top tier software house and yet they are usually much worse devs.
The claim is that repetition and a short feedback/learning cycle will improve a developer more quickly than a long cycle. It doesn't say that a poor developer with a fast cycle will out-learn a different, stronger developer with a slow cycle.
- You can only hold so many details in your head at once, and you can only sustain that collection for a limited duration. Holding those details there can be crucial for doing good work and the faster you work the more you make use of them.
- Doing good work often requires a lot of experimentation and iteration. In a number of circumstances this may only be practical if you can do them fast enough
Speed lets you try many alternatives, experiment with many different even opposite options, and draw out creativeness.
Another possible reason is that speed is the strength of the younger generations. In human history, if new comers want to beat the current authority (in business or politics) who have already mastered the intricacies of the current game, one have to propose and experiment large quantity of new alternatives, new rules of new games, even though most of experiments might have low quality results judging by the established rules. But it's the better way to compete and survive.
We could not confirm or disconfirm this as truth, say in the context of an experiment. This phenomenon is better described by the concept of immediacy of reinforcement. As one decreases the delay to reinforcement, the strength of behavior maintained by that reinforcer increases [0].
The study I cited provides support for the authors conclusion. However, his description is flawed because it doesn't provide means for prediction and control of behavior.
Do you go around criticizing all opinions that refer to people's thought processes as 'flawed because it doesn't provide means for prediction and control of behavior'?
In behavior analysis all behavior is considered the subject matter, including private events. So the answer to your question is: No, I'm not saying that.
I wish you luck in persuading people to accept this philosophy. You may have an uphill struggle convincing people that it is comprehensive enough to replace all the other ways humans have thought about their experiences to date.
That's not what I think. See the difficulty in inferring someone else's thoughts? ;)
If we are just theorizing or talking about what the mind is and so on, then this belongs in the realm of philosophy.
Behavior analysis is alive and well on the psychological scene. APA's lifetime achievement award this year went to an applied behavior analyst. If behaving is doing and behavior is the subject matter of behavior analysis, that's pretty comprehensive.
Have you considered the possibility that some philosophy might actually be useful in this domain?
[incidentally: I have nothing against behavioral analysis in itself - just the claim that thinking about what goes on in the mind should be excluded in its favor]
However, this is way beyond the scope of the original blog post or my original comment. In my first comment, I offered an alternative description of a phenomenon that the author described. You suggested that I was advocating for "strict behaviorism." That wasn't the case, so I clarified. At this point, I'm not sure what the purpose of this discussion is.
I agree that humans influencing each other through talking about how they think about things is a hard phenomenon to reduce to the kind of science that you are advocating, but that is a limitation of your preferred methods, and it's inappropriate to dismiss phenomena just because you don't have a good way to understand them.
I agree that people sharing information about how they think about things may INFLUENCE behavior. In your previous comment you used the term "cause." These are very different words, especially when we are talking about science. It's not clear what you think I dismissed.
> "inappropriate to dismiss phenomena just because you don't have a good way to understand them."
I never suggested that we dismiss phenomena. If you read my original comment, I agreed with the authors general premise but I offered an alternative explanation: "This phenomenon is better described by the concept of immediacy of reinforcement. As one decreases the delay to reinforcement, the strength of behavior maintained by that reinforcer increases."
Thus, I'm not sure what your point is.
My point in the original comment about the concept of immediacy of reinforcement is that it is a broader, evidence-based concept that encompasses what the author described. I thought HN users might get value from such an explanation as they could apply it to more aspects of their lives than just "doing things quickly." It seems as though your purpose is to argue with me over things I didn't say or ideas I don't hold, which isn't productive or meaningful to the HN community.
In this reply, you are wholly dismissive of discussions about behavior that do not solely use behavior analysis.
Attempting to evade this through being pedantic rather supports my point.
Nonetheless, you are arguing with me. You responded to my comment. I would rather you not tell me what I think or what what I said, when the facts don't show it.
This discussion (which has now devolved into an argument) began when you stated that I was "advocating a return to strict behaviorism." This was also incorrect, so I clarified.
I honestly don't have a problem with you, but you have been kind of attacking me in this thread. When you told me that my tone was condescending, I apologized because I know that my words can have an affect on people that I didn't intend. At this point you are offending me by claiming I said things I didn't say and attempting to characterize me as someone who ignores all viewpoints except for BA. Yet, our entire conversation is recorded above and does not support your claims.
For every piece of code you write, there should be a unit test covering it that you can run fairly instantly with 1 keypress which catches at least internal-consistency errors. (Integration tests would cover external-consistency errors, but when you're refactoring/adding/deleting code, internal-consistency is violated far more often than external consistency, in my experience.)
Once you experience this for yourself, you will NOT want to go without it. It allows you to IMMEDIATELY get back to coding without waiting for test runs to finish and without creating bugs unknowingly that you only catch much later.
You are correct. Likewise types can catch some bugs that unit tests cannot.
But the overall goal is to learn new pieces as efficiently as possible. Someone who is efficient at practicing will make much more progress (and have more fun doing it) than someone who isn't.
The writer mentions that faster employees have more work assigned to them. Woo hoo, but what happens when the work queue fills up faster than it can be emptied? Then the once-fast employee now seems slow.
If you can honestly answer "Yes" to that question, by all means, speed it up.
-=in defence of taking your sweet time=-
the arguments for speed and the arguments for quality are not either or. they both contribute to a product that works.
to introduce the case for slowness a natural precedent is appropriate. the development phase for human beings was on the order of 2 billion years.
and in that time a whole lot of nothing happened. all those evolutionary competitors at every level of the tree of life were more rapidly produced than humans. and now humans rule the world and in 200000 years have used that comprehensive development period to move rapidly and adapt so effectively to the world that we have changed it to support 7 billion of us and tripled our life spans. the hockey stick curve of our technology speaks to the benefits of long development, and the long tail of non-adaptive more-rapidly developed ideas that come to nought.
those practising rapid development and launch save costs during the development stage and increase costs during the much longer operating stage by code that has more bugs, takes more to maintain, is more brittle, and these things constribute to being slower to adapt to customers and competitors when it counts, that is, when you have customers, are burning operating costs, and competing.
it works better to develop comprehensively when it is cheap to and build the most efficient product to be really useful when you run with it. longer development, then move faster in operations.
otherwise you end up solving your terrible code base by hiring more brains, and those brains could be better put to use creating improvements for your customers and not fixing the consequences you shipped in a sprint.
pre launch development is cheap, so it works to take your time and not optimize that __process__ prematurely. everything is more expensive after launch when the stakes are real and where an advantage can be moving fast -- if the code you crafted creates that you can adapt quickly, then you've minimized costs over the operating period, and your brains can work on growing and retaining, rather than building an ozymandius of monkey patches.
the time when speed is important is after launch not before it. if you rush your pre launch development, you will be a slow operator, and this will cost you exponentially more than the linear increase in cost from a longer development time.
also the more robust the system you build is, the slower ( as in slow thinking ) you can create your decisions in the operating period to really consider strategy.
let your competitors ship first and watch the things they miss. let them pay for the experiments you now decline to run. if someone seems to be capturing the market through their business model then you are too slow anyway and the high order bit for you isn't code anymore. if that is not your market, then it is filled with competitors who are mimicing each others sub-monopoly strategies. so you can step in, be the last mover, and take the market. invest time during development to make code and tools that work, grasp your business plan, and have the possibility of thinking strategically about the business, in the operation phase, once you have launched.