Good variable naming is more than giving things good names... it requires decomposing your problem into thought-sized chunks so that you can give things good names. If you cant think of a good name something, it should again lead you back to evaluating your design. Sometimes though, you really do need to invent a new term to communicate a concept in your system.
You should be able to read code that calls out to several different methods and be able to have a decent idea whats going on. If you look at the implementation and are surprised at what it does, thats a problem. Surprises lead to misunderstandings -> mistakes -> and defects. Theres general rules of thumb, e.g. only doing one thing, or not unexpectedly mutating input arguments. But other kinds of surprises are much harder to just list. We attach complex meanings to words as metaphors for concepts in every day life, ideas in a specific domain, or common patterns and conventions that we use in code. Words don't always mean the same thing to different people, or can have multiple meanings in different contexts. On most projects, we end up making a glossary at some point of agreed on terms and meaning so that we can communicate better in speech, but also in code. It's a massive help to have a common set of building block ideas with the people you have to 'group-think' with in code.
Learning design patterns will help you pick up some general vocab, but other conventions are established more from tools. Like a method getXXX() should generally return a property, if it does something other than that, it will generally surprise people. Even if the method does essentially 'get' something, its still surprising because its an established convention, so sometimes you need to use a different word that means the same thing to convey a different meaning. :) Sometimes a popular tool will pick unfortunate names for things and they'll be adopted into general vocabulary and cause confusion.
Most of the code out there wasn't written to be understood. And yet we spend way more time trying to understand existing code than we ever spend writing it. But it's not easy... even when people try to write understandable code, they often still miserably fail. Per Scott, "thinking is hard." :) Breaking down a problem into thought-sized chunks so that you can think about one chunk and know you don't need to worry about the other chunks... is hard. That's the kind of stuff you spend your career working to master, and when I say a developer is 'really good' that's usually what I'm referring to. It's the ability that crosses languages, tools, or frameworks that's responsible for massive increases in productivity.