The converse of my earlier question. Despite all signs at the time, Theory of Compuation and a Compilers class are the two where techniques learned there have been used again and again. Designing state machines as well as writing tokenizers and parsers have been key skills that have proven their worth.
What have you found invaluable?
Data structures and Algorithms I use every time I program. So that class is definitely worth it.
Compilers. I've found the need to write parsers numerous times. Also, I think the course causes you to think differently about a certain class of problems. Lexers, state machines, and parsers are enormously useful tools.
Cryptography. It helped me develop a critical attitude towards my own code, to always be looking for the non-obvious way that bugs or security issues can creep into code.
"Introduction to Algorithms" (aka, the first 2/3 of the CLR book. Which is now the CLRS book). Despite the soft-sounding name, it was one of the more difficult classes I had to take, as it went through a number of topics at breakneck pace -- asymptotic notation, NP-completeness, graphs, trees, searching (including radix and other wird ones), dynamic programming, and more. The explanations in the book are clear, the exercises challenging, and the textbook is a great reference later on.
There is just no way you can be a serious programmer and not wind up using at least some of the algorithms and approaches described in the book. Being exposed to them early helps tremendously.
Also, Introduction to Databases. For something so ubiquitous, it's amazing how poorly understood it is by developers. Most people's problems with DBs would go away completely if they took this class and understood what it is they are asking for when creating indexes, writing queries, etc. At some point, most programmers will wind up using a DB. Learn about the tools you use.
Optional C++ class. We had bunch of lectures object-oriented design within this course and had to come up with the project built according to strict design guidelines (Law of Demeter, Open-Closed principle etc.)
Though I mostly do Java in this period of time, those design things help me a lot.
Courses in networking and distributed systems. Networking to understand the OSI stack from the wire on up, and distributed systems to understand the challenges involved in designing robust distributed systems and the numerous failure modes they suffer from.
I got a C in my database design class and hated every moment of it. I don't know why, but I retained every morsel of knowledge from that class and use concepts from it every day.
Performance and Optimizations.
I learned how to profile code and only optimize critical sections. I learned what optimizations the compilers will perform for you. We would decompile code after compiling with the different optimization levels and see what those compiler optimizations would do. Now whenever I am looking into a performance issue, I always run the code through a profiler. Afterwards the code that I thought was the problem often turns up to be a small amount of the total execution time and some simple code that is called often turns out to the be the problem.
Data Structures and Algorithms, Database Systems, Software Architecture. Taking electrical engineering courses in C helped a lot as well.
Genome Databases: stats, biology, chemistry and computer science all mixed together :)
Compilers. It combines both the high-level (regular expressions, scanners, grammars, parsers, various parsing algorithms, types, numerous other language-related aspects) and the low-level (assembly, code generation) in a way that is very practical. By learning theories and techniques and using them to build a real C compiler (well, minus some features given the limited time) I learned so much, most important of which is being able to think like a machine. That occurred with code generation and after that I find myself thinking about business logic-type things with much ease. The knowledge of how a compiler really works also helps with C/C++ debugging and understanding operating systems, especially if you mess with the code. The project was quite significant and strengthened my C/C++ skills. Our class also had us use Lex, Yacc and all kinds of tools which will be useful in the future.
Analysis of Programming Languages. It was a great introduction to the different approaches taken by various languages.
this is almost certainly not what you're looking for, but it is something that helps me every day:
touch typing, which i learned in a 9th grade typing class ("F F F space...").
that's decades ago and it's still something i look back on as one of the most useful things i learned. really.
Data structures was definitely useful as was distributed systems, but I think the one that stuck with me the most was real-time programming. Not because I do lots of real-time stuff in my job, but it was during that course that I really learned a lot about time management and working in a team environment. We wrote our own real-time operating system, so we learned about threading models, scheduling, synchronization, and stuff like that. I also learned a ton about error handling, since the hardware we were working on was flaky and we simply had to deal with it.
The professor told us in third year "If you suspect you're getting too much sleep, you might be interested in this course", and he was right; I pulled more all-nighters in that four-month course than the rest of university combined. It was probably the most difficult CS course I ever took, but I learned so much that it has remained to this day my favourite.
Operating Systems - For years I had been writing software but didn't have a CS undergrad. It wasn't until I went back for a masters that I learned about what the operating system was actually doing with my instructions. I'm a much more effective programmer now that the mysticism about processes, threads, exceptions, and memory management has been converted to a solid understanding.
Assembly Language Programming and Digital Computer Organization
This is the class that brought it all together. How your code is actually run on a computer, and how they are designed and why. This is the course that I do not use the skills from it every day, but is the fundamental base of everything I program in higher level languages. This course provided my general understand of the very fundamentals of computer programming.
A variety helped but not because of content, mostly because of the teachers providing useful tips and tricks.
Far and away, Compilers. A two quarter course, we were forced to write a working compiler that produced running code for a fairly sophisticated language. It wasn't just the theory that was useful; it was the first time we were living with code we wrote over a 6 month period, as opposed to throwing it away each time we started a new assignment.
Second best was graduate operating systems: no lectures, just reading of original papers (the original multix, unix, etc papers) and in-class impromptu question-answer sessions.
I have found that working tech support for a software company has been far more valuable for me as a developer than any college course. It gives you an insight into how non-technical people think and use systems, and you can use that to make better apps. If your app is unusable, it's going to be inefficient no matter what algorithms you use. The technical part is important, of course, but remember that people use the stuff you're gonna build.
Structure and Interpretation of Computer Programs definitely is a good CS work every one would face.Also Compilers makes us to think in computers
Discrete Math. Who know being able to count things would be so useful to a coder!
ObJoke: "What's discreet math?" "Shh! cant say."
std::vector<>
Oh, a course. My bad.
Compilers provided the most useful experience.
Structure and Interpretation of Computer Programs. Only when I took it, it was called 6.031 cause the SICP book hadn't been written yet.
And the non-CS class wasn't a class, it was a collaborative writing workshop where we all read and edited each others prose. Learning to write English clearly and directly has had a huge influence on how I think about programming, both in terms of how I approach the product (the program has to be meaningful to the users in their terms) and the process (other developers will read my code, the code has to make sense to a developer in their terms.)
As a non-research programmer, I would actually value clarity of expression above algorithmic smarts in nearly all cases (except those where performance counts above all, which is actually rather rare.)