I'm not sure it's always obvious to ourselves when we have. We humans are amazing at denial and telling ourselves whatever story we want to believe in.

I'm not picking on you. If there's one thing I'm terrified of, it's blind spots.

In my experience, it's an unknown-unknown problem (don't know what we don't know).

Is it important you can recite cache eviction algorithms from memory? No.

Is it important you know there are such things as caches and roughly how they work? Yes. Because then you can quickly look up the details when/if you need them.

Is it important that you understand cache eviction algorithms well enough that you can look at a description of an algorithm and see how it applies to your system? Yes. And if memorising is the way you gain that ability, then memorising is what you need to do.

And what is it important for? Why, for making sure that your software makes efficient use of system resources. This is essential if you're writing application software that's used by other people – but if you're writing server-side code, or some one-a-month business-logic data-processing scripts, or code that's only ever going to run on five specific machines, it's not that big of a deal. I haven't needed this skill yet.

> I'm not sure it's always obvious to ourselves when we have.

Agreed. Some people would have to change employers in order to break through the ceiling, or to even see how they're limiting themselves. And for some of them: why would they?

Agreed. I can almost guarantee you that if you've written code that has any sort of performance needs at all (which describes most code) you've written something badly or suboptimally that you could have easily avoided or improved if you'd had a deeper understanding of the compiler or CPU. Every single one of us have.

Meh. A nicer way to say "gluing things together" is "reasoning with abstractions." There's detail all the way down, but you don't need most of it and can't remember all of it. The key is just knowing when to dip down and when to float on top -- screw that up and you run into trouble.

I think there are different ceilings. And probably everyone has some spaces where they didn't reach their ceiling yet.

I think the ceiling is less about what you can achieve, but about the quality you produce (e.g. correct application of principles, which can lead to better maintainability).

Before I studied I thought of objects in terms of Object Orientation as a memory layout plus some functions to manipulate it. When I studied, I learned that Object Orientation is much less about the implementation, but more about the principles at hand (e.g. polymorphism).

I still love good implementations, but studying gave me a whole new perspective on certain topics.