"Premature optimization is root of all evil" is something almost all of us have heard/read. What I am curious what kind of optimization not premature, i.e. at every stage of software development (high level design, detailed design, high level implementation, detailed implementation etc) what is extent of optimization we can consider without it crossing over to dark side.
When you're basing it off of experience? Not evil. "Every time we've done X, we've suffered a brutal performance hit. Let's plan on either optimizing or avoiding X entirely this time."
When it's relatively painless? Not evil. "Implementing this as either Foo or Bar will take just as much work, but in theory, Bar should be a lot more efficient. Let's Bar it."
When you're avoiding crappy algorithms that will scale terribly? Not evil. "Our tech lead says our proposed path selection algorithm runs in factorial time; I'm not sure what that means, but she suggests we commit seppuku for even considering it. Let's consider something else."
The evil comes from spending a whole lot of time and energy solving problems that you don't know actually exist. When the problems definitely exist, or when the phantom psudo-problems may be solved cheaply, the evil goes away.
Steve314 and Matthieu M. raise points in the comments that ought be considered. Basically, some varieties of "painless" optimizations simply aren't worth it either because the trivial performance upgrade they offer isn't worth the code obfuscation, they're duplicating enhancements the compiler is already performing, or both. See the comments for some nice examples of too-clever-by-half non-improvements.
Application code should only be as good as necessary, but library code should be as good as possible, since you never know how your library is going to be used. So when you're writing library code, it needs to be good in all aspects, be it performance, robustness, or any other category.
Also, you need to think about performance when you design your application and when you pick algorithms. If it isn't designed to be performant, no degree of hackery can make it performant afterwards and no micro-optimizations will outweigh a superior algorithm.
what kind of optimization [is] not premature
The kind that come as a result of known issues.
When is optimization not premature and therefore not evil?
It is difficult to say what is good and evil. Who has that right? If we look at nature, it seems we are programmed for survival with a broad definition of "survival" which includes passing on our genes to offspring.
So I would say, at least according to our basic functions and programming, that optimization is not evil when it is aligning with the goal of reproduction. For the guys, there are the blondes, brunettes, red-heads, many lovely. For girls, there are guys, and some of them appear to be okay.
Perhaps we should be optimizing towards that purpose, and there it helps to use a profiler. The profiler will let you prioritize your optimizations and time more effectively on top of giving you detailed information about hotspots and why they occur. This will give you more free time spent towards reproduction and its pursuit.
The full quote defines when optimization is not premature:
A good programmer will not be lulled into complacency by such reasoning, he will be wise to look carefully at the critical code; but only after that code has been identified. [emphasis mine]
You can identify critical code in many ways: critical data structures or algorithms (e.g. used heavily or the "core" of the project) can give major optimizations, many minor optimizations are identified through profilers, and so on.
You should always choose a "good enough" solution in all cases based on your experiences.
The optimization saying refers to writing "more complex code than 'good enough' to make it faster" before actually knowing that it is necessary, hence making the code more complex than necessary. Complexity is what makes things hard, so that isn't a good thing.
This means that you should not choose a super complex "can sort 100 Gb files by transparently swapping to disk" sorting routine when a simple sort will do, but you should also make a good choice for the simple sort in the first place. Blindly choosing Bubble Sort or "pick all entries randomly and see if they are in order. Repeat." is rarely good.
My general rule of thumb: if you're not sure you'll need the optimization, assume you don't. But keep it in mind for when you do need to optimize. There are some issues that you can know about up front though. This usually involves choosing good algorithms and data structures. For instance, if you need to check membership in a collection, you can be pretty sure you will need some type of set data structure.
In my experience, at the detailed implementation phase the answer lies in profiling the code. Its important to know what needs to be faster and what is acceptably fast.
It is also important to know where exactly the performance bottleneck is - optimizing a part of the code which takes only 5% of the total time to run wont do any good.
Steps 2 and 3 describe non-premature optimization:
- Make it work
- Test. Not fast enough? Profile it.
- Using the data from step 2, optimize the slowest sections of the code.
It's not optimisation when picking things that are hard to change eg: hardware platform.
Picking data structures is a good example - critical to meeting both functional and non-functional (performance) requirements. Not easily changed and yet it will drive everything else in your app. Your data structures change what algorithms are available etc.
I only know of one way to answer this question, and that is to get experience in performance tuning. That means - write programs, and after they are written, find speedups in them, and do it iteratively. Here's one example.
Here's the mistake most people make: They try to optimize the program before actually running it. If they have taken a course in programming (from a professor who doesn't actually have much practical experience) they will have big-O colored glasses, and they will think that's what it's all about. It's all the same problem, prior optimization.**
Somebody said: First make it right, Then make it fast. They were right.
But now for the kicker: If you have done this a few times, you recognize the silly things you earlier did that cause speed problems, so you instinctively avoid them. (Things like making your class structure too heavy, getting swamped with notifications, confusing size of function calls with their time cost, the list goes on and on ...) You instinctively avoid these, but guess what it looks like to the less-experienced: premature optimization!
So these silly debates go on and on :)
** Another thing they say is you don't have to worry about it any more, because compilers are so good, and machines are so fast nowadays. (KIWI - Kill It With Iron.) There are no exponential hardware or system speedups (done by very smart hard-working engineers) that can possibly compensate for exponential software slowdowns (done by programmers who think this way).
When the requirements or the market specifically asks for it.
For example performance is a requirement in most financial applications because low latency is crucial. Depending on the nature of the traded instrument, optimization can go from using non-locking algorithms in a high-level language to using a low-level language and the even the extreme - implementing the order matching algorithms in hardware itself (using FPGA for example).
Other example would be some types of embedded devices. Take for example the ABS brake; firstly there is the safety, when you hit the break the car should slow down. But there is also performance, you would not want any delays when you hit the break.
Most people would call optimization premature, if you're optimizing something that isn't resulting in a "soft failure" (it works but it's still useless) of the system due to performance.
Real world examples.
If my bubble sort takes 20ms to run, optimizing it to 1ms quicksort is not going to enhance the overall utility in any meaningful way despite being a 2000% performance increase.
If a web page takes 20s to load and we decrease it to 1s, this can increase the utility of the website from 0 to near infinity. Basically something that was broken because it was too slow, is now useful.
What kind of optimisation is not premature?
An optimisation that fixes a known performance issue with your application, or an optimisation that allows your application to meet well defined acceptance criteria.
Having been identified, some time should be taken to establish the fix and the performance benefit should be measured.
(i.e. it's not - "I think this bit of the code looks like it could be slow, I'll change X to use Y instead and that will be faster").
I have encountered lot of premature "optimisation" that has ultimately made the code slower - in this instance, I'm taking premature to mean 'not thought through'. Performance should be benchmarked before and after optimisation and only code that actually improves performance kept.
protected by user40980 Jun 15 '15 at 20:07
Thank you for your interest in this question.
Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).
Would you like to answer one of these unanswered questions instead?