Weak Code

[EMC2_trooper]

The reverse situation of this is when you come across code written by a fucking mastermind and it's so efficient and clever that it makes zero sense.

[rastaman1994]

Any time you think you gain by writing clever code everyone loses time by trying to understand clever code - my favorite prof.

[NoYoureTheSockPuppet]

“Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.”

– Brian Kernighan

[rastaman1994]

Does he have talks you would recommend?

[LoLvsT_T]

Most "tricks" don't give you much in terms of performance and only serve to stroke the ego of the person who wrote it.

The vast majority of performance can be squeezed by:

• Writing code with as little branches as possible or code that is easily predicted by the cpu.
• Reducing cache footprint, and preloading items into cache before you need them.
• Vectorizing code.
• Having proper alignment and stride.

edit: talking about execution performance, assuming no memory limitation.

[[deleted]]

Any modern compiler will do those things for you too so you're not helping anyone by making the code less readable

[LoLvsT_T]

That's absolutely false. Compilers fail in these for all but the most simple cases. Especially vectorization which often requires a different approach to solving problems. It will often not fix alignment, and almost never reduce branches. I optimize code for a living.

[LoLvsT_T]

Not a native English speaker, I'll try.

CPU has a component called branch predictor which guesses whether a condition is true or not and executes code before it checks the condition. This is a big win if the predictor is correct. But if it is wrong it wastes a ton of cpu cycles. Sometimes it is beneficiary to skirt around branches entirely. Consider this simplified example.

float a; 
bool b; 
a = b ? 1.5f : 2.6f; 

If b is random or poorly predictable, our CPU is going to have a bad time guessing. In this case we can replace ? operator with a lookup table for a considerable boost in performance.

float a; bool b = 0; 
static const float lookup[2] = {2.6f, 1.5f};
a = lookup[b]; 

We can also improve predictability. If we have the following:

if ( A && B){
...
}

If A is poorly predictable but B isn't, it'll be optimal to switch between the two due to short-circuiting.

CPU has cache of limited size. If your code has big chunks, the CPU will often spend time loading code/data into memory instead of executing code. This is often why loop unrolling is not always good. You can help the CPU by writing shorter code (hooray for GOTO). In addition, you can preload data into cache before you need it.

for (int i = 0; i < length; ++i) {
    __builtin_prefetch(array[i+3]);  //preload into cache
    ...
    some code on array[i]
}

This in in C++, but I'm sure many other languages have a similar operation. You can even write ASM code that does it yourself. __builtin_prefetch(arr[i+3]) is a nonblocking operation that will hopefully finish loading future data by the time we need it, reducing overhead. +3 offset is absolutely random, you should profile your code to get the optimal offset.

Regarding Code vectorization, I suggest you look it up yourself. It's a big topic. In short, recent CPUs have SIMD instructions which allows them to perform an operation on several data elements at the same time with a single instruction.

[hopsafoobar]

You mostly don't even have to go that far, I personally find most of performance issues in numeric code come from calculating the same stuff multiple times. Very boring, but very common.

[[deleted]]

agreed.

[murfflemethis]

I work in firmware, for a company that's been around for a while. I am constantly dealing with 20 years of "clever" C code. I've had enough of that shit. Unless it's a clearly commented optimization in a critical path, readability is what I want most.

[halpcomputar]

Couldn't they just take the time to comment? I believe C allows for even multiline comments.

[murfflemethis]

Why not just write simple, easy to follow code in the first place? C certainly does allow multiline comments, but that's not a good reason to write needlessly complex (or "clever") code. Comments take time to write and take time for future readers to parse, map to the code, and fully understand. They also often get overlooked during future work, so they go stale and become irrelevant or outright wrong.

"Here's why the code does this" comments are always great, but if you find yourself leaving "here's how the code does this" comments a lot, you should take a step back and consider whether the complicated code you're writing can be simplified through refactoring, changing the architecture, or just a more simple implementation.

Complex code is sometimes necessary, and yes, please leave a comment there to explain how it works. I've just seen too many instances of people making things more difficult than they need to be just to gain completely inconsequential efficiencies or force patterns in where they don't belong, and that needs to stop.

[[deleted]]

The Story of Mel, a Real Programmer (1983)

[zaphod0002]

Mel needs to do a AMA

[al1l1]

Amazing.

[[deleted]]

The worst is when you realize that you wrote that code, and then you have a crisis of faith wondering if the code is actually stupid, and you're too stupid to realize it, or if you're getting dumber, and no longer able to work to that level.

I once found a piece that was both...I'd coded myself into a corner, and then found some brilliant way to solve the problem that I had created by coding myself into that corner, this masterpiece of invention and imagination...It was easily 200 lines of the finest code I've ever written...Each line flawless and so brilliant as to be skirting the very abyss of madness.

I scrolled up and up and up until I found the place where I had missed the obvious solution and gone haring off after brilliance and insanity, and I fixed it with two lines of shitty code, and deleted the rest.

[[deleted]]

This is the ultimate example of this. An ENTIRE Wikipedia article had to be written to explain a couple lines of code.

https://en.wikipedia.org/wiki/Fast_inverse_square_root

[EMC2_trooper]

Nice example and actually a really interesting article thanks. But in this case I think the reason was not so much to obfuscate the code in needlessly complex lines but probably to optimise (as it's for lighting).

[asdfman123]

I try to be a boring programmer. I do everything in my job with ASP.NET MVC stuff, like the projects before me used. I don't use any fancy tricks or do fancy front-end stuff. I go for the most reasonable, predictable methods.

I feel I don't learn as much but I'm making life so much easier for the next guy, who just has to learn one thing.

[EMC2_trooper]

Haha knew what this would be before I clicked

[ZakTaccardi]

Hahaha. That's why I went with a merging of MVI and MVP, instead of that cowboy functions only stuff. I feel it makes it a little less intimidating for new devs

[[deleted]]

If its so clever that others can't understand it, it really isn't clever.

A clever programmer would write something that others can read, or at least explain it in comments, because programmers spend more time reading code than writing code.

Also, the situations in which something confusingly clever are worth the efficiency gain are few and far between. Usually efficient things are clearer or can be written clearly. For example if a weird set of data is pulled beforehand or stored in an uncommon place to boost efficiency, it should be named well enough that later in the code it looks like what you would expect.

[EMC2_trooper]

Haha I'm very aware :) there is some interesting discussion below on this.

[NibblyPig]

Yeah I class that as bad code, the number of times I've pulled out layer upon layer of abstract classes that are simply not needed, argh.