Adding Estimates

I’ve talked about estimation many times before. I’ve talked about Kent Beck, and I’ve talked about Hillel Wayne. Today I’m going to talk about all three of them at once. I’m not sure how directly this applies to development, but I’m pretty sure there’s something there. Maybe I’ll have it by the end of the post.

Beck recently wrote about private estimates and public progress. What it basically came down to was that the entire team gets together on Monday and decides what they think they can get done that week, given all they know of the situation, the priorities, and the goals. Then, at the end of the week, the team gets together again, looks at what was done, then answers the question “How did we do?”.¹ It’s a simple idea. He then goes on to give a list of pros you get from doing that and some things to avoid.

You get limits. You know what you’re NOT doing. You know what done looks like. You get focus and alignment.

On the other hand, you can’t add weeks. Or compare them. Or compare teams. It just doesn’t work.

But it also got me to thinking about something Hillel said. You can’t add times or temperatures and get something meaningful, but you can subtract them and average them. Huh? On the surface, that doesn’t make any sense. I mean it’s true, and it feels right, but huh? Subtraction is just the inverse of addition. Why can you do one and not the other? Averaging is adding things up then dividing. So why can you add and divide, but not just add?

As he explains, the reason it works is that what you’re really doing is not staying in the domain of time or temperature. What you really end up doing is working in the domain of deltas in time or temperature. And that works because you can add and subtract deltas. When you add two times the result isn’t a time. I’m not sure what it is, but it’s not a point in time. When you subtract two times you get the difference between them. The delta. And I know what that is. It’s a time period. That’s a real thing.

Taking the average of a group of times (or temperatures) is really taking the delta between each time and a common arbitrary time point, then adding the deltas, dividing that time period by the number of times you’re averaging, then adding that time period back to the same arbitrary time point. All of those are valid operations, and you end up with a single point in time that we all agree is the average of that collection of time points.

Now that I’m getting towards the end, here’s what I think. Estimates are kind of like times and temperatures in that they’re based on a known starting point. If you could somehow compare them all with the same starting condition then, just like time or temperature, you could find the delta and do your math in that space. Unfortunately, the starting point for an estimate isn’t an estimate, or a point in time, or anything else easily measurable. Instead, it’s the sum total of what you know about a situation. How things are, how you want them to be, the environment around you, and the expected interruptions among other things.

When you make an estimate for this week you know everything you know about the current state. How correct you are is a different question, but you know all you can know right now. If you could know more then you would. However, the estimate you want to make for next week relies on having that same level of knowledge. You might have that knowledge now, but when you get to the beginning of next week, when you should be making that estimate, the current state will be different. How different? I don’t know. You don’t know.

For next week, it will probably be something like what you estimate for this week, but not exactly. And over time the difference between you expectation and reality will grow, to the point where you have no idea what the starting condition is.

Which mean that you can’t pick a starting condition to subtract from all of the estimates, so you can’t generate a relative estimate delta. And if you can’t turn your estimate into a delta then there’s nothing you can add, or even compare.²

The same thing applies to comparing teams. Or doesn’t apply. Because the teams are different there can’t be any shared arbitrary point to use to create a delta from. And again, without that delta, there’s nothing to compare.

And that’s how Kent Beck, Hillel Wayne, and Estimates come together to explain why you can’t just add up a bunch of weekly estimates and come up with 12 month plan.

You Broke What?

They say with motorcycles there are riders that have laid their bike down at least once, and there are riders that will lay there bike down in the future. That there are no other kinds of riders. I’m not a motorcycle rider, so I can’t comment on the accuracy of that statement or not.

I am, however, a software developer, and I can say that there are 10 kinds of developers. Those that understand binary and those that don’t. And there are 2 other kinds of developers. Those that have broken production software at least once, and those that will.

There are two important things to take away from that. First, you will break production at some point. Don’t let that paralyze you. Second, don’t just YOLO it over the wall and walk away. Pay attention to what happens. Make sure things are doing what you expect, and not doing what you don’t expect. And be prepared to fix things.

Actually, there are a lot of things you should take from that besides those two important things. And the biggest of those revolve around 2 area. Preventing issues and recovering from issues.

You want to do everything you can to prevent issues from happening. The things you’ve seen happen. The things you’ve heard about happening. The things you can think of going wrong. The things others can think of going wrong.

Things like running unit and acceptance tests first. If possible, shadowing production. Then sending a percentage of production work to the new version. And things like making sure the sequencing is in the right order. You add things before you reference them. You stop referencing things before you delete them. Making sure everything is done before flipping to new versions. Those sorts of things. And don’t forget Hyrum’s Law. Somewhere, someone is using your system in ways you didn’t expect, and probably relying on something you didn’t realize was happening. When you find it you’ll need to deal with it.

Bottom line? You don’t want to keep getting bitten by the same kinds of problems when you can find and prevent them.

The other thing to take away is that you need to be prepared to deal with problems. The simplest one to be prepared for is the roll-back. Something bad happened? Putting it back the way it was should be a fast, one-click, operation. If you can’t do that, work towards it. Because it will happen. And don’t forget to periodically test the roll-back. There are much better times than when you’re under pressure to find out that you have a write-only backup.

And after the fact, don’t forget the blameless review. You might call it a post-mortem, an incident review, lessons learned, or something else entirely. Amazon calls them COE’s. Some parts of Microsoft call them Root Cause Analysis. Regardless of what you call them, you should do them. And pay attention to the results. Check out what the Pragmatic Engineer has to say about them.

How careful should you be? It Depends. It depends on how bad things can go and how fast you can recover. So think about what you’re doing. Think about how you can recover. Then make the change. And eventually, you’ll join the club of those who have broken production. I look forward to welcoming you.

The Dude Abides

The Big Lebowski is a cult classic from the late 90s. It’s all about Jeff “The Dude” Lebowski and a series of events and (mis)adventures that happen to and around him. There are many quotable lines, but one of the most quoted, one that shows up on posters, shirts, memes everywhere, and is the last line The Dude says in the movie, is “The Dude abides.” It’s a paraphrase of a line in Ecclesiastes

One generation goeth, and another generation cometh; but the earth abideth for ever.

Things change. Generations come and go. But the Earth abides. It doesn’t go away. The same with The Dude. Despite everything that happens in the movie, The Dude goes on as he is. Accepting life. Calmly enjoying it. Going bowling and drinking white russians.

Which brings me to today’s topic, Dude’s Law.

Value = Why / How

Dude’s law was coined by David Hussman, and he explains it in this short video. Dude’s law is simple. The value of doing something is proportional to why you’re doing it, and inversely proportional to how you’re doing it. For any give why/how pair, if you double the why you get twice the value. If, on the other hand, you double the how, you get half the value.

That’s pretty non-denominational, so let’s try to be a little more specific. Why measures the benefit. The thing you want and get more of. It’s based on the reason you’re doing something. It helps you to quantify the good things that happen if you do whatever it is. How measures the cost of doing it. That includes time, effort, money, and any other resource you put into doing the thing. Or talking about doing the thing.

It’s still pretty non-denominational, but at least now, value is benefit / cost. That’s a fairly common definition, and something that’s easy to get behind.

The important thing to remember here is that value is inversely proportional to the how, and the how in Hussman’s explanation includes time spent discussing how. If you spend too much time talking and thinking about how and don’t improve the how by enough, you’ve actually reduced value. An obvious example of this is XKCD’s Is It Worth The Time. Automation can help, but if you spend more time automating that the automation will save you then you haven’t added value.

It’s another local vs global maximization tradeoff. Consider making a technology choice for the next feature. You’ve got a system that was built using Go. There’s a cool new feature in Rust that you could use that would make the task easier. But the team doesn’t know Rust and the development environment doesn’t support Rust. The higher the how, the less value you create. So without changing the why you probably shouldn’t choose Rust in this case.

Unless… you also change the why. If there’s a good reason to move the entire system to Rust things are different. If your why goes up at the same rate as the how, then the value is not reduced. In that case, the higher how is justified by the higher why.

So yet again, we come back to it depends. Which is just another way of expressing Dude’s Law. Value is benefit / cost. That doesn’t change. It’s up to you to define why and how.

Skill Vs. Experience

Skill and experience can have a lot in common. If you have a lot of experience doing something, you can become very skilled at doing it. Alternatively, you can be very skilled at doing something, and that can take the place of spending time gaining experience.

Consider this video of a technically skilled mountaineer and a monk walking up a mountain.

The person with the camera knows the technical way to get up a mountainside. The monk on the other hand, just knows how to walk up the side of a mountain. End result, they both end up in the same place, but the path they take is very different.

Another way to say it is:

In theory, there’s no difference between theory and practice. In practice, there is.

Or maybe you heard it in an intro physics class, where it when something like this:

Everything I’m going to teach you in this class is wrong. Or more accurately, not exactly correct. It’s good enough for most things you do, but it’s not exact. Newton’s laws of motion are mostly correct, and the equations of motion are close enough for day to day things, but there’s a lot more depth to understand.

Knowing the rules is a skill. Knowing when you can and can’t apply them is experience.

And finally, lots of people know Arthur Clarke had at least 3 laws because they know his 3rd law, which is “Any sufficiently advanced technology is indistinguishable from magic”. But many people don’t know what his 1st law is.

When a distinguished but elderly scientist states that something is possible, he is almost certainly right. When he states that something is impossible, he is very probably wrong.

That elderly scientist has enough skill and knowledge in a field to know what’s possible even if they don’t know how to do it. On the other hand, their lack of experience can sometimes blind them to possibilities,

All of those are ways of pointing out that just because you have some skill and training, you don’t know everything. Skills can get you pretty far, and in many (most?) cases far enough. But you need experience as well.

I’m a decent rough carpenter. I can frame a wall or hang a door. They’ll be plumb, square, and level. I have the skill to do it. But it takes me a while. And very often I get part way through and realize it would have been easier if I had done something else first. That’s because I’m not experienced enough. I don’t do finish carpentry or build furniture. That requires a level of experience I just don’t have.

The same applies in development. In software development (and many other areas) you want to be efficient. That often means only building what you need. When you find out you need more, you refactor and add what you need. That’s skill based. It works. Every time. And it’s way more efficient than building some elaborate thing you don’t need, then figuring out a way to shoehorn it in to the problem you actually have.

Consider this situation. You’re building a tool to transform some data. You know the input file name, so you just hard code it into the tool. Great. It works. Then you find out that need to know the name in a couple of places in the code, so make it a defined constant. Again, great. Then you find out that there are actually different files that you’ll need to read in different situations. So you make it an input parameter. That’s using your skills. But if you’ve got enough experience you realize that you’re going to need to handle multiple file names from the beginning and you build it that way up front. With the starting name as the default. That’s even more efficient and that’s what experience gets you.

Skill might also tell you that you could build the tool to handle an input file that is a list of files to process. And that each of those input files will need a different output name, so you make the input file contain that. And each of those input files might need different permissions to be read, so you figure out how to get the right secrets to read the file.

What experience can also tell you is while you could do those things, you shouldn’t. Those kinds of problems belong to someone (or something else). It’s experience that tells you to use The Unix Way. Or at least you shouldn’t do them until there’s a demonstrated need for them.

On the other hand, if all your experience is in doing the exact same thing, the exact same way, you end up blocked. You don’t have lots of experience. Instead, you have many instances of the same experience. That’s not true experience. And it’s probably not true skill either. Because true skill is made up of lots of sub-skills. By themselves, the sub-skills aren’t nearly as useful.

So next time you have an opportunity to use your skills to increase your experience, or to use your experience to get some new skills, take it. The more you have of both, the better you’ll do.

Time Periods

From Star Trek to Hofstadter’s Law, estimates are always a conundrum. There are lots of articles about it on the web, but here’s Ron Jeffries about it and it’s a really good place to start.

To me, the problem is not the estimates themselves, or the idea that you’re trying to measure something that is neither precisely or accurately measurable, but in what happens to after you make the estimate. Or to put it more bluntly, the problem is that very often inaccurate, imprecise estimates are taken as promises. When that happens, everyone is going to end up with some level of unhappiness.

If you’ve been reading these entries for any length of time, it’s probably obvious that I think it’s important to add value as soon as possible. And that you need to add the most value you can. The question is, how do you know what the most valuable thing to do is.

In fact, it’s not just the most valuable, it’s adding the most value, for some set of resources, over a certain amount of time, and knowing that for a given set of resources, every choice to do something is also a choice to NOT do a bunch of other things. That’s a good thing. Focus is good, and tends to get you to value sooner.

However, to maximize, or even go in the direction of maximization, you need to compare resources spent on all of the possible options. And since you need to do it before you’ve done most of the possible things, you can’t know how many resources it will take. Instead, you have to estimate it. Then you can do comparisons and make choices.

Sometimes, there really are dates you need to hit. My go-to example for that is delivering games for the holidays. Even today, with online games, internet delivery, and mobile gaming, in the US, if your product isn’t available by Thanksgiving, you’re going to lose out on a lot of sales. You NEED to work within that constraint. You can go a long way by sequencing work and doing the things that need to be done first, first, and leaving the rest for later.

But what if you’re making tradeoffs? Thing A is critical, things B, C, and D are nice to have and individually that’s the importance order. But together, C and D are more important than B and C. Should you do C and D first then? Only if you believe that you can get them both done. And to know that, you need an estimate.

Which brings us to my recommendation(s). Never give a precise time estimate. Instead, the precision of your estimate should be a function of the time period estimated. Something like no more accurate than ½ the time period. If you think the right unit of time for your estimate is days, the accuracy of your estimate should be +/- ½ day. If your estimate is 3 years, then it’s 3 years, +/- 6 months. And, reserve the right to change the estimate AND the precision as you learn more about the problem.

That’s not what the #noestimates zealots want, but it is as little estimation as you can get away with.

Doing It Well And Truly

I’ve always been a reader of science fiction. In particular, the kind of science fiction where knowledge and competence make a difference. Stories like Andy Weir’s The Martian. Or Lucifer’s Hammer. There’s nothing magical or particularly special about the protagonists, they’re just competent. And lucky. And most importantly, they do the thing. They do it well and truly. But most importantly, they do it. The don’t (only) talk about doing it. They don’t (only) talk about how important it is that it get done. They don’t (only) wish someone else do it for them. They don’t (only) complain about who’s not doing it. They just roll up their sleeves and do it.

Most of Lucifer’s Hammer is about how different groups of people prepare for, survive, then move forward after a comet hits the Earth. They don’t complain about it (too much). They don’t wait for others to do something for them. They plan, they execute, they adapt, and they move forward. Lots of folks have read the book, and different people remember different parts of it. But almost everyone remembers Gil, the surfer. His choice on that day was to do what he loved, which was surfing. So he was out on the ocean off the shore of Santa Monica when the comet hit. When that happened, instead of giving up, he did what he did best. He decided to surf the tsunami. The last thing we get in the book is Gil thinking about the story he could tell if he survived.

Sure, Gil was thinking about going out in style at first, but he realized that Doing it well and truly might actually get him out of it alive. In a an extra last chapter that was published in Analog almost 40 years after the book, it turns out, he did survive. Once again we see that doing the thing, instead of just talking about it, makes a difference.

As in art (and life), so in development and career. If you see something you think needs to be done, but no one is doing it, think about it and figure out why. It might be like Chesterton’s Fence. There really is a good reason, it’s just not obvious to you. It might be because of priority. Or, it might be that it just hasn’t been important enough to anyone. That’s where doing the thing becomes important.

If it’s important to you, you have (or can find) the time, and there’s not a good reason not to do it, then do it. You’ll be happier. Chances are others around you will be happier. And people will see you as someone who gets things done. Any of those is a good enough reason. Together they’re a great set of reasons.

There are lots of things that sound like doing the thing, but they’re really things that aren’t doing the thing. They don’t get things done. They don’t make you happier. They don’t make others happier. They make you look like a complainer or a procrastinator instead of a doer. The key thing here is to keep the difference in mind. It might be fun to do things that aren’t doing the thing. It’s probably easier to do those other things than it is to do the thing. You might even get more support that way. However, you won’t get the thing done. And that’s the most important thing to remember. If you’re trying to get a thing done, you have to do the thing.

So the next time you find yourself in a situation where you have a choice between doing the thing and not doing the thing, think about what you want, what’s important, and if it’s your choice. Then, do the thing, and do it well and truly.

A look at 2023

Big changes on the work front. I started the year working at Amazon on their Just Walk Out technology, but then got moved to a new initiative. The work was interesting, and from what I hear, going well, but Amazon and that project weren’t a good fit for me, so after a year at Amazon, I started looking around for something different. What I found wasn’t Amazon, but it wasn’t that different for me. I’m back at Aurora, now working on the Developer Experience team, focusing on software quality, bothg internal and external. I still get to walk to work, and I’m enjoying the challenges, and once again, I’m learning new things all the time.

With those work changes, I wasn’t able to do as much work on the blog as would have liked, only 50 new posts this year. It averages out to one a week, but it was way more bursty than that. My goal for this year is to be not just more productive on the blog, but also more consistent.

From a content standpoint, this year’s articles have been more about the what and the why, and less about they how. Oh sure, I have opinions on how everything should be done, and I’m happy to share them, but the posts have focused on what kinds of things you should be thinking about and doing and why they’re important, not how to do them.

With that said, here are the 10 most popular posts over the last 12 months:

1. Careers Pt 3 – Visualizing Progressions
2. Careers Pt 1 – Levels
3. Effective Software Engineers
4. McDonalds
5. Incident Response
6. Let Me Tell You What I Want
7. High Quality Quality
8. Seeing Like A State
9. Breaker Breaker Rubber Duck
10. 1 > 2 > 0

I’m really happy to see that my career posts are still getting good traction, as are the Eng Competencies. How you look at your career drives what you put into it, and from that flows what you get out of it. And to round things out, 2 more posted this year since #1 and #2 are from last year

• Shallow Hurry
• Any fool can write code the computer understands.

Hopefully you’ve found those, and other, articles interesting and useful. I know I found writing them helpful in clarifying and cementing my own understanding of the topics. Until next year, Happy New Year, and remember to enjoy whatever you’re doing. We only get one shot at this life, so make it worthwhile.

McDonald's

I’ve been a subscriber of Kent Beck’s Tidy First? since almost it’s beginning. If you don’t have a copy of the book, consider picking one up. There’s a lot of good stuff in there. Not just things to do, but when and why to do them.

Since then, Kent’s been talking about his Thinkies, which are questions (or statements) designed to induce movement and provide you with more options and help you reach a decision. They’re short, straightforward, and are simple to apply. You start with a pattern, the situation that triggers the thinky, apply the thinky, then look at what you come up with. In many cases you have an entire new way of looking at things, a roadblock or two has been removed, and you get to make forward progress.

One of the recent ones was called McDonalds. It’s a great way to get a group that’s stuck in analysis paralysis moving again. When the see the group is stuck, make a suggestion. Not the perfect thing, and not something impossible, but something that’s unpopular, no-one really wants, but not completely ridiculous. The group won’t take your suggestion, and you really don’t want them to, but very often the simple act of suggesting a concrete solution will get the group to come together on choice that makes sense to everyone and is a good starting point.

This thinky’s name comes from the situation. The group can’t decide where to go for dinner. So you make a suggestion, such as McDonalds. Someone then says that’s a terrible idea. Let’s go to XXX instead, and the group comes to consensus. Deadlock broken and everyone gets to eat dinner.

You can use it in lots of situations. How should we manage workflow for this new project? Lots of discussion around rolling your own, buying one, finding an OSS solution, and lots of discussion around the pros and cons (mostly the cons) of each option. After a while folks are just repeating themselves, and you stop getting closer to consensus. You’ve got the equivalent of a super-saturated solution, but it’s just sitting there. To get things moving, you put out a throwaway choice. Something like “I know. We can use Celery/Flask to manage things”.

Immediately, things start to crystalize out of the solution. Celery/Flask won’t work because something. Instead, we should use Temporal because it solves all of our problems. It’s like opening Schrodinger’s’s box. All of the potential and possibilities collapse into a concrete situation that you can then move forward with.

So next time you and your group find yourself stuck trying to make a decision, try the McDonald’s Thinky. And check out the rest of them as well.

Strong opinions, Loosely Held

Everyone’s got opinions. Some strong we feel strongly about, some not so much. Some we are willing to consider changing our minds on, others we aren’t. How you balance how strong your opinion is and how hard you hold on to it is the challenge. It’s easy to hold on to something too tightly or for too long.

That’s why companies have policies like Disagree and Commit, Meritocracy and Toe Stepping, No Jerks, or No A**holes. It’s to encourage getting the balance right.

What’s supposed to happen is that everyone has their opinion. When there are conflicting opinions, people bring their opinions and their reasoning together and make an informed decision, that everyone then carries out together. It seems like a good idea, and when it works it is a good idea.

The problem is that, like everything else, it’s a two-edged sword. Those policies are supposed to help the best ideas rise to the top. However, they rely on certain conditions being true. That all the people involved are equals, and that there are no, or minimal, penalties for being wrong.

Unfortunately, that is often not true. Building software is a social endeavor. At its core, it’s about people and the way that they interact. And people have their own motivations and goals, and not everyone has the same ones.

What often happens is that instead of a strongly held idea with the best evidence being chosen, the idea with the strongest voice wins. Sometimes that is the loudest voice, sometimes the most persistent, sometimes it’s the most senior person’s idea. That’s not what we want.

And no policy that relies on others to keep it will make it happen. Instead, it’s on everyone, but especially those with more situational power, to make sure it does. By watching what is happening. By making sure that there is a counter to the loudest voice. An amplifier for the quieter voices. A supporter for those that need it. The longer I’ve been doing this, the more often I find that I have the opportunity to help other’s ideas get the consideration they deserve.

That doesn’t give anyone the option of not needing the facts, the documentation, the proof, that their opinion is good. What it does do is make sure that a good decision is made with the best available information.

That takes care of the Strong Opinions part. Which leaves us with the loosely held part. But that’s a discussion for another time.

Stop Designing

Stop designing up front the moment you start speculating.

          – Kent Beck

That’s a pretty bold statement. After all, how much do you really know about what you’re going to need to do at the beginning? At the beginning of a project (or feature, or task, or bug investigation) all you know is a rough idea of the problem to solve, not how you’re going to solve it.

To me, what Kent is saying isn’t that you should only do design on things that are known/fixed/unchangeable, but that the level of detail of the design should match the level of detail of what you know.

As an example, if you’re in the US, and you need to be in England in 2 weeks for 3 days, making the decision to fly instead of going by ship matches the level of understanding. Adding detail to that decision, i.e., deciding what day/time to fly on, or which airport you’re going to fly into, requires more information that you have. That info is probably available, and easy to get, but deciding to leave at 8 AM on Monday morning before you know if you need to be ready to work Monday morning in England. Similarly, deciding to fly into Heathrow before you know that you need to be in Edinburgh is just going to cause you to have to change your tickets later.

It’s the same with software. You have the problem you want to solve. You have some understanding of the situation as it currently exists. You cad (and should) do a design to the same level of detail. A handful of boxes on a whiteboard and some lines and arrows connecting them. You might have persistent storage. You’ll probably have a few different major steps in the process of solving the problem. There’s an expected flow between the steps, and some places where you might need to back up or start again. If you’re like me, you’ve already thought of 15 different ways things can go wrong, so you know you’ll need a way to get information about a failure late in the process back (or forward) through the system. Given what you know, that’s about how much you can design. After that, you’re speculating. You’re guessing really. It might be an educated guess based on past experience, but it’s still a guess.

That’s the point to stop designing and start implementing. Build some APIs. Let some test data flow through the system. Hardcode some good and bad responses and see how the system responds. Adjust your APIs and data structures so things flow well in both happy and sad cases. Learn from the system you’re build. If something seems hard to do with your flow, it’s probably not you. It’s the system telling you that you’ve uncovered an emergent property, and you need adjust to work with it. Once you’ve got it working, look again. Do some refactoring and cleanup. Listen to what the system is telling you and adapt. It’s Test-Driven-Development at work. Or if you don’t believe in that, you can call it Domain Driven Design. Or Behavior Driven Development. Or even Extreme Programming.

It doesn’t matter what you call it. The important part is that you design to what you know, leaving room to adjust as you learn more. Then you learn a bit, design a bit, and do it all again. Rinse, Lather, Repeat. It’s more than a way to sell more shampoo.

Don’t worry (yet) if it can handle 10K transactions/sec or if it’s resilient to a backhoe taking out a datacenter. You might need that. You might even know you’ll need it for a production system, and you might be right, but you don’t need it yet. So don’t worry about it. Don’t preclude it, but don’t code yourself into a corner where you are stuck with a decision you made before you knew what tradeoffs you were making.

Beware of biases. There are lots of them. Sunk cost bias. You’ve put so much effort into making this thing work you don’t want to give it up. Recency bias. I just finished this, so I need to use it now. Overconfidence Bias. I know what I’m doing, and I know everything I need to know already, so my initial idea must be the right one.

So don’t design for things you don’t know. Or, as Jack Burton said, I never drive faster than I can see. You just need to develop the reflexes to know how fast that is.