"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.
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.
"Premature optimization is root of all evil" is something almost all of us have heard/read
True. Unfortunately it is also one of the most (maliciously) misused programming quotes of all times. Since Donald Knuth coined the meme it's worth to add some original context from the quote:
We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3 %. ... A good programmer ... will be wise to look carefully at the critical code; but only after that code has been identified. ... the universal experience of programmers who have been using measurement tools has been that their intuitive guesses fail
Note that Knuth talked specifically about speed of execution in runtime.
..Programmers waste enormous amounts of time thinking about, or worrying about, the speed of noncritical parts of their programs..
Also, he wrote the article in 1974 when any machine resources where at premium and negative correlation between speed of execution and maintainability of the program (higher speed - less maintainable) was probably stronger than now.
OK, to answer your question, according to Donald Knuth, optimization is NOT premature if it fixes a serious performance bottleneck that has been identified (ideally measured and pinpointed during profiling).
As I said before, "premature optimization" is one of the most maliciously misused memes, so answer won't be complete without some examples of things that are not premature optimizations but sometimes being shrugged off as such:
- bottlenecks which are visible with the naked eye and can be avoided before being introduced such as O(N^2) number of roundtrips to database with large N where O(1) alternative exists
Further are not even related to speed of runtime execution:
thoughtful upfront design
static typing (!)
etc. / any forms of mental effort