Which is the most difficult CS subject/theory that you studied but important to the field? And the reason please?
Design & Analysis of Algorithms
I think that question depends on the teacher you had, and how that subject was organized in your career.
Analyzing algorithms can be as hard as someone wants. Take in count that there are unsolved problems, and not only that: problems that can't be solved.
The thing is that you can have a problem, and if you know it can't be solved, that's perfect. But what if you don't? You can spend a lot of time trying to demonstrate it's NP-Complete, or trying to find a polynomial time solution to solve it.
Demonstrating NP-Completness is not easy. Yes, lots of problems are known, but the thing is to find the reductions to demonstrate that it's NP-Complete. And what if you spend lots of hours/days/months trying to demonstrate it, and it can be solved in polynomial time? :)
There are also other subjects, like Compilers, Group theory and Primitive Recursive Functions that can be as hard as the subject plan or the teacher wants ;)
Pattern Recognition i.e. Artificial Intelligence. This refers to smart computing along with other pattern recognition tools like, Optical Character Recognition, Voice to text, facial identification, etc.
Many of the "cool" things you can do or wish you could do with computers rely on these algorithms, and we have been attempting to perfect them for decades without a whole lot of success.
My pick is computability theory
(Hmm... maybe it's not that important, but it sure was difficult)
There are only two hard problems in Computer Science: cache invalidation and naming things. - Phil Karlton
Operating Systems, especially the part that has anything to do with threading.
And the reason isn't because it was that hard to make 5 philosophers eat pizza with a fork. The reason is because writing multithreaded code is in and of itself difficult and not necessarily easy for the human (at least male - according to my wife) mind to compute.
Well technically this is a branch of mathematics, but is highly relevant in CS.
Nearly everything in CS is based on queues (visible (obvious) and invisible (not so obvious or implied)).
In the early days of CS the queues were obvious.
A queue of programs (each program a deck of cards).
Nowadays the queues are not so obvious. The internet for example: a packet switched network, but the packets form queues and routing the packets is a form of queue minimization.
Personally, mine was Formal Logic. It was tough to start with, but once you get the rules down and manage to play with it enough, your brain goes
Logic++;, which in development is a very good thing.
As a side-note, I am answering the question directly - this was definitely not the hardest subject when I did my degree, but it was probably the hardest "real-life applicable" subject.
Kernel Design anyone ? Well I don't really know how it's done and what is the targeted features for an OS, but for me thinking about designing a kernel must be a daunting task.
I also think about computer security; I don't really know what makes a system unsafe except of course, obvious buffer overflows, XSS and SQL injections.
I'm not sure, but there seems that some algorithms are also unsafe; look at the MetaSploit project, it lists all type and kinds of security breaches: you can see there are a lot of ways a program can be flawed.
There are many awkward topics in the field, but my picks for sheer persistent difficulty are those involving Global System Properties. Examples of this general topic include:
- Safe and deadlock-free multi-threading
These are hard because you're after something that only exists when everything is correct; you need a global system property and yet virtually all the tools available (and all the ones that scale to real problems in my experience) only really do local reasoning. It's the process of going from reasoning about the pieces of the program to the whole shebang that's hard, particularly because it's entirely possible to have pieces that are all correct in themselves but where there still are subtle bugs because the components are incorrectly arranged; the bugs can be undesirable emergent characteristics…
Management Information Services
During my college period i used to have one management subject each semester which totally made me mad.
Tough! well subjects like Compiler Design, OS Design etc are tough but they are really Interesting and challenging. I really messed in subjects like Management Information System / Services etc as they are full of boredom and you have to go through lots of theory.
Which is the most difficult CS subject/theory that you studied but important to the field?
It was difficult because the theories are very loosely related to each other but they're used in CS. Too much memorization I guess...
Proof by Induction, Big O, recursion, divide and conqure, Graph Theory, blah blah.. argh!
Compiler for me was easy, because we had to take Theory of Automata. ^^
I like your answers (and I didn't forget upvoting them), like compiler, kernel, etc., but most of programmers never met these problems. There is a bit easier, but more common issue: concurrency - threads, locking. It's very easy to write a program which produces magical errors, if we make even a small bug in the concurrency architecture.
So, I say, it's not the hardest issue in computing, but because it's commonly used, it is a dangerous one.
Object Oriented Programming
It's probably because I cut my teeth on FORTRAN and APL, but the shift from strictly procedural languages to objects has been something I've struggled with for years. It doesn't help that so-called 'experts' write conflicting articles and tutorials on what it means to be object oriented and the best/proper ways of constructing object oriented programs.