I'm helping with an algorithms course next term. I've taught intro programming courses and seminars, but never intro algorithms. I've spoken with previous TAs and instructors, and one of the biggest problems they face is student assignments -- both on the writing and grading side.
The course is more or less abstract (no concrete implementation assignments). While you can argue whether or not this is ideal, it's the hand I'm dealt. This means that pseudocode is heavily important -- in fact, it goes into linear programming quite a bit and handwaves a large number of details on things like "actually efficiently finding a feasible point/local optimum" for simplex and such.
This leads to two major problems: students don't deal with a suitable level of abstraction. They tend to refuse to consider "black boxes" even if they're used in class. While wanting to know details isn't wrong, and if you want to use the algorithms in real work it can be a big deal, it can lead to actually doing the assignments being intractable. Especially when the efficient algorithms they should be black boxing for certain purposes are either complex, open problems, or something they shouldn't need to reroll (sorting algorithms after the sorting section is covered).
On my end, it also leads to grading hazards. I've seen past assignments, and they tend to be very dense, boilerplate ridden, implementation detail-considering chunks of copy+pasted Java or C++ code. Some of this is simply poor coding practice, and would be an issue even with pseudocode, but it's absolutely clear that pseudocode solutions would be shorter (often by several pages) and easier to read and understand.
However, attempts to teach pseudocode tend to leave students confused. They (perhaps understandably) shy away from black boxes, think their Java code is self evident, or think "real code" is inherently better because it can be run. They don't embrace the terseness and magic-of-convenience of things like "sort x ascending by length" and instead rely on verbose comparator implementations. How can I effectively communicate the benefits of pseudocode in abstract algorithms and data structures contexts for both my and their sanity?
(Quick disclaimer: while this is a real question, this is also partially to test how the community feels about erring on the side of inclusiveness on computer science and programming as mentioned in this meta discussion)