I found that I'm a schizophrenic programmer.
When I write C++ code, I make it a sport to avoid unnecessary heap allocations (e.g. by replacing std::vector with something similar to Boost's `small_vector` when I expect the size to almost always stay under a small limit). I also obsess over CPU cache friendliness, e.g. by eschewing OOP for data-oriented programming techniques like "struct of arrays rather than array of structs" where applicable. I almost always avoid virtual inheritance. My heart warms when I know that the target platform ABI will pass a function return value in registers, or that RVO is guaranteed to apply, or that a move constructor will be used rather than a copy constructor.
Buuuut... when I write Java code, I go full no-fucks-given OOP code-monkey. Lots of polymorphic method calls via interfaces. Singleton classes, Adapter classes, Observer classes. A Factory object creating a Builder object which creates the final immutable object. Instantiating an object with two fields (with the heap allocation and all the Java object overhead that entails) just to return two integers from a method. I worry about the overall "elegance" and "self-documenting quality" of the Java code, but not about how much it rapes the RAM and CPU.
And funnily enough, in both cases, the code that comes out (and the speed at which it gets done) seems to be satisfactory to my boss and customers.
Is anyone else like that, or just me?