How can we teach good naming practice for students learning Java? In writing software we name things. In Java we name classes, interfaces, methods, variables, etc. How can we teach both the importance and the skill of choosing good names?
What teaching practices will lead students naturally to good practice in naming their programming constructs?
How important is naming in the creation of quality software? In particular, how important is it to teach good naming and insist on it in student programs?
Moreover, what practices impede the student from learning and practicing this skill?
Good naming is important for both the creation and maintenance of programs. Good naming also makes the evaluation of the student programs easier when the student uses, for example, intention revealing names consistently. .
Note that much of this applies to other languages, but Java is a popular teaching language. Java is mandated in the Advanced Placement courses commonly taught in the United States. It is also a common language in first courses taught to undergraduates.
Fair warning, I do not demand any particular naming convention (such as NetBeans) from my students.  This leaves me with variable naming only for the purpose of clarity.
I speak constantly to my students about the two different audiences for code: the computer itself (which is the one kids naturally think about), and other is human beings, which students find more difficult.  And I also strongly believe that this is the single biggest impedance to good naming: students don't think that it matters, because they think they are writing for a computer.
I also grade all of my labs using code interviews, and my students are aware that I will be looking for clarity above almost all other considerations.  (There is good reason for this; deeply clean and clear code also has very few bugs. When you engage in the difficult process of cleaning and refactoring, you can polish your code until there is basically no room left for them!)
My intuition is that good code correlates much more with good writing than it does with good mathematical skills.  Good code demonstrates a clean rhetorical structure.  This part of the code cleanly and clearly accomplishes this task, while that part carefully lays out the thinking and organization for that task.
This could simply be a function of the kinds of people who are naturally attracted to coding, but I have found that asking kids to write clean code is often very difficult for them.
What works
I have found that the following question is a useful overriding guide for most of my students:

&quot;If you were not someone who had just spent the last 15 hours looking over this code in detail, what are the odds that you could figure out what it was doing at a quick glance?&quot;

Naming norms
This is the best tool that I use, and these work for all of my students.  There are a few direct practices that I ask for in all submitted code:

With regard to booleans, what do we know if this variable is true?  Create a name based on the true condition.  (e.g. if this variable will be true whenever the foo is inside the bar, we would name the variable fooInBar)
With regards to accessor methods, what information is being returning?  Simply name this information.  (totalTrials(), unusedElements(), nextItem(), etc.)
With regards to mutators, what command (verb) is being issued? Use this verb, possibly with an attached noun.  (increment(), consume(Item i), fixVertex(), etc.)
Single letter variable names should be used only for throwaway counters and such. (e.g. for(int k = 0; k &lt; items.length(); k++))
For other variables, we enter into broader territory, and things can get trickier.  Which brings us to...

Miscellaneous variables
Unintuitively, I have had mixed luck with the question,

&quot;what does this variable actually represent?&quot;

This is the question that I ask myself while I code, and it works for many students, but for students who really struggle to come up with good names, the question does not seem to grant much insight.
This doesn't mean that I don't use the question, but it has become a last resort. Students who present poorly named variables often seem unable to cleanly articulate what a particular variable is accomplishing.
If I'm honest, the fact that this question rarely helps strugglers makes little sense to me (and is rather disheartening), but I have come to accept it as a fact.  Going back to my intuition that strong writers create clean code, there could be some language difficulty going on here, but that is only a hunch.
For such strugglers, I might help them by having them describe the variable in broad terms, and writing what they say.  I will then sit and progressively distill what they have written with them until we arrive at a good name together.  Unfortunately, this practice is time intensive and does not scale well, but it works, and I haven't found any better solutions for my strugglers.