This list feels rather more like "this is all the courses I took in college, and why you should take them too" than what should be the minimum knowledge level of a computer scientist. For that list, you need much fewer things--I can think of 5 things, but learning them well may require several courses:
1. Communication skills. This should need no explanation.
2. Required math curricula. You need high school algebra and discrete math. Light introductions to statistics, linear algebra, calculus, and logic are too damn useful to pass up, but a full semester course in these topics is often overkill. Abstract algebra, graph theory, and numerical analysis are more situational in their utility.
3. How to design software. This is more than just programming 101 and software architecture, you also should know how--and when--to use IDEs, version control, refactoring, testing, debugging, code review, how to report bugs, navigation of large codebases you didn't write, etc.
4. What makes fast software fast and slow software slow. Computational theory and data structures and algorithms fall into this bucket. There's a fairly standard set of data structures to learn, but I would caution that you don't ever need to know how to actually write a good hashtable or binary search tree, but you should know how they work and what the performance ramifications are. Basic computer architecture should also be required, and I think there's often too little emphasis on the impact of the memory hierarchy in software. I also think you should understand how a compiler is going to interpret your code, what it will and won't do to make it faster, and what you can and can't do to make compilers work better. (Lexing and parsing theory, which tend to be the bread-and-butter of early compiler courses, need not apply).
5. A deep understanding of different programming languages. First, you need a workhorse language that most software is written in, just to get you employed. In addition, you should cover the four major programming paradigms: imperative, object-oriented, functional, and logic. It is more important to deepen your understanding of one of these paradigms than to pick up another language. Once you understand all of these paradigms, you should be able to quickly pick up whatever language you need to get your job done.
As you can see, I definitely favor depth over breadth. The utility of breadth is mostly in knowing that there are topics out there that other people know much more about than you do, and you should defer to their opinions (and in choosing something to specialize in if you're unsure). But many intro classes will probably leave students with an inflated impression with their competence. This is particularly dangerous in cryptography, which is so easy to screw up that even experts do so on a regular basis; if you're not an expert, you shouldn't even try.