Oh I understand it well, I think. I went through phases such as this in both photography and other fields. I sort of skipped it in programming thanks to a theoretical CS education, and being told constantly "the language doesn't matter" throughout my learning phase.
I think you're always striving for higher quality at the beginning. You always want to skip over the developing mastery part right into mastery, but it never works that way. So you take shortcuts, and you see that they have effects. To continue with the photography example, if you buy a more expensive lens, for a while it looks like your photographs are getting better. On the surface, they improve. They're smoother, sharper, with better color; whatever. For a while, you think that's what photography is all about, the quality of the image, the lust for higher and higher quality.
We do the same thing in programming. You learn a language. It lets you do stuff. But then you learn a different language and it just seems so much better in the areas you believe are important right then. On the surface, it's easier to code in and easier to understand and it results in more polished code, or faster, or it lets you do things in a way that seems cool. You think "why would anyone ever use Old Language when they could use New Language?" You build lots of cool things and no one uses them but they're cool anyway.
In both fields, the beginner is just learning their tools. It's important to go through that phase in photography, because you learn that lenses and cameras and flashes and gear really do make the result different. The mistake is thinking they make the result better. Because better has many different meanings that are deeper than the surface level that the gear can affect. Same with programming: you make this mistake that New Language is better because it does XYZ better, without realizing that what you're actually building has a deeper meaning than just what the language does better. That it actually takes a lot of different languages, or that Old Language might actually be a better choice because you don't need XYZ, you need ABC. Or something.
It's the difference between mastery and the illusion of mastery or the desire for mastery, and it's the process of learning what tools are for and why they're important, before realizing that they're only important on the surface: as a means to an end. It's an attempt for quality before mastery, which has a limit.
Once you have mastery though, if you've got all the other parts right, then chances are you're going to choose the right language. Language isn't unimportant because it's not important (it is); it's unimportant because if you have everything else right, then the choice of language follows naturally. It's not a concern. It's an afterthought that a true master will already have the answer for.
This is why if you go up to a professional photographer and ask them what kind of camera and lens they're using, they'll just give you a quizzical look and roll their eyes. In their head, the answer is obvious. "The right one."
Will they still be attached to their gear? Of course. Will they still prefer what they're used to? Of course. But they have no illusion that it means anything more than that.
In the end, the photographer in the right place at the right time with the right light still wins, regardless of the gear—even though he still has the right gear. And in the end, the programmer with the right project and the right customers with the right need still wins, regardless of the language—even though that programmer has probably already chosen the right language.