Ask HN: What are the 20% tips that will get my code to performance 80% faster?

I believe the intention was more Zen -- don't write code that isn't really necessary -- and the "use standard libraries" code was separate. (If you are using a language where the standard libraries are so poorly implemented that you can easily write better versions, you might want to consider using a different language.)

I would also add the cargo cult suggestion of "precompute and cache everything you can". Whatever can be done in an indexing process instead of a search process should be; whatever doesn't need to happen at serving time shouldn't.

It's a bit unique to each situation, but a few topics that come to mind immediately:

* Profile & measure to narrow down where time is being spent

* Memoize repeated function calls

* Cache data that doesn't frequently change

* Minify web assets

* Gzip compress web output (a la mod_deflate)

* Load balance

* Shard

* Strategic database indexing

* Asynchronous workers when beneficial

* Use the correct data structures

* Minimize Disk I/O

^ I suppose the last few are architecture-related more so than code.

These topics are mostly specific to web, but, here is a "curated list of Web Performance Optimization"

https://github.com/davidsonfellipe/awesome-wpo

Since nobody has quoted Donald Knuth yet (and this quote sometimes gets bent to fit situations that it shouldn't):

"We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil"

> If you are using a language where the standard libraries are so poorly implemented that you can easily write better versions, you might want to consider using a different language.

Standard libraries are typically generalized for a wide array of use cases, you can easily write much faster implementation specialized to your needs if you have any idea what you are doing.

Sometimes standard libraries handle such ridiculous cases (e.g. many ES5 array methods and Function.prototype.bind) that your needs don't even need to be that special.

My first advice is always:

Check your loops, it's where your mistakes get amplified.

Trust no one, not even yourself: Profile your code.

That said, if you aren't profiling already you are probably trolling us to get suggestion for your next blog article. ;-)

As others have mentioned, use better algorithms i.e. it makes no sense to speed up a bubble sort routine instead of using a quick sort approach.

A lot of speed improvements come from just not doing stuff in the first place vs. speeding up a naive or brute force approach.

For example, suppose you want to determine when something enters the frame of a camera image that is 640x480 pixels big.

The naive approach would be to compare every pixel of the frame to every pixel of the previous frame. The area of the frame is Width x Height: 307,200 pixels.

A more efficient approach is to process just the edges (perimeter) of the image/frame since nothing can enter the frame without crossing the perimeter first. The perimeter is 2 x Width + 2 x Height: 1080 pixels.

The 1st approach is 284 times slower (307,200/1080) and no amount of optimizing it is going to make it as fast as the 2nd approach.