For the CS majors out there what were the hardest CS classes or concepts that you learned in your undergraduate schooling?
Did you find once you learned the basics,(data structs, OOP fundamentals, discrete math, pointers, recursion, etc) the rest followed naturally or did you hit a wall at any point in your higher classes like OS'es and Compilers?
Thanks for the input!
Parallel Algorithms was probably the hardest concept I had to learned. Or course, Compilers classes were pretty tough too.
Computational complexity in general was difficult. Not so much the Big-O stuff, but things like NP-Complete were just really hard to comprehend at first.
I thought that the compilers class was the toughest; thought I recall my Theory of Computation class not being a walk in the park.
Linked-lists, recursion, and finite-state machines.
Linked lists bugged me because I also just started learning pointers right before them, so trying to learn how to manage memory and a linked list at the same time made things a bit tricky.
Recursion was difficult when I was first introduced to it. It didn't click right away because it was introduced at the very end of an intro to programming course. It wasn't until the next programming course I took, where it started with recursion, that I really "got it." Once it clicked though, it became easy.
Finite-state machines were the most challenging for me though. Although not a truly "programming" concept and not a super-difficult concept to grasp on paper, trying to implement it was extremely hard for me. It was the first time I felt really dumb in a programming-type class. Before I reached state machines, I never really struggled as much and never struggled as much since.
The hardest (and most interesting) undergrad CS class for me was a group project class where we wrote an assembler, linker/loader, and hardware simulator. There was a fair amount of work and the specs for the system changed multiple times per week.
Surprisingly enough the hardest CS class I took was Logic for Computer Scientists. It's amazing how difficult a simple classical branch of mathematics can become when drilled down to it's depths.
Statistics, mathematical logic/formal methods, algorithm analysis.
Software Engineering. I liked the teacher, but couldn't stand most of the theoretical bureaucracy and paperwork.
My Computer Graphics class was tough, because the 'Visiting' Professor had an incredible accent, and wasn't that good. I ended up spending four days sleepless to finish my 3-D House Walkthrough project, which came out beautifully, but he gave me a C, because he says he couldn't run it.
Computer architecture, learned a lot of low level stuff, also I liked very much Assembler, hard but fundamental knowledge...
Two areas I really struggled with was writing pure recursive code and managing solo a compiler over the course of a semester.
I'm not sure if it was the curricula or just me (or a combination), but the concepts I learned flowed from one to the next so that it wasn't difficult for me to grasp the next concept.
I think a lot of it had to do with my linguistics background...if you can comprehend 5 declensions of nouns and 4 conjugations of verbs (along with different tense and voice), CS is child's play.
Computer graphics, it was very mathematically intense and had very little to do with computer graphics in simple sense. And I guess everything to do with computer graphics in a complex sense. It was definitely one of the classes that makes you realize you're going to a really good University.
Hierarchical modelling and ray tracing were some of the more important topics covered.
Hierarchical modeling is for creating a data model in which the data is organized into a tree-like structure. So for example when you move/rotate your arm, so will your hand. (arm and hand being represented as seperate objects)
Ray tracing generates an image by tracing the path of light through pixels in an image plane.
For me it was a class called computation theory and more specifically pumping lemma...still have no clue what it does.
Neural networks specifically related to vision, these are the type that self learn to spot patterns, was very interesting but complex.
Looking back though I would say the biggest misunderstanding was oop, until you actually start using it for complex models not the simple programs they have you do at college and university I think it is hard to fully understand why it is so good.
My Operating Systems course was pretty hard and interesting.
We implemented an operating system named "Not Another Completely Heuristic Operating System"
Not Another Completely Heuristic Operating System, or Nachos, is instructional software for teaching undergraduate, and potentially graduate level operating systems courses. It was developed at the University of California, Berkeley, designed by Thomas Anderson, and is used by numerous schools.
Originally written in C++ for MIPS, Nachos runs as a user-process on a host operating system. A MIPS simulator executes the code for any user programs running on top of the Nachos operating system. Ports of the Nachos code exist for a variety of architectures.
For me the toughest part was in a class called 'Programming Language Concepts'. There was this strange function named call-with-current-continuation we learned in scheme. Eventually, with enough head banging, it made sense.....mostly.
Numerical Analysis of least squares, in particular Matlab's execution of this, while at the same time also being introduced to this topic in a statistics course. What fun I had that semester.
Implementing a variant of the Warren Abstract Machine for executing Prolog. I think I reread the same chapter in Hassain Ait-Kaci's book at least 20 times before really grasping how unification works in a WAM.
The knowledge I gained in operating systems helped me a lot understanding how programs function actually. I enjoyed that course. Analysis was an eye opener for me, too and helped my understanding a lot.
For me, it was Finite State Machines, especially semester projects on them was hard. I also had to learn Lisp, that was pretty hard too, coming from C/C++ world.
Transformation between Non Deterministic Finite Automata (NFA) to Deterministic Finite Automata (DFA) in theory of formal languages, it was very strange at once but when the time has gone and the practice made its magic everything was clear then.
I never understood Bayesian algorithms, the maths just went right over my head. I understand how they work and what they do in a general sense, it's just the finer details of the higher maths that escapes me.
I think that computability and complexity (Turing machines, halting problem, NP, ...) are rather hard. I had a hard time in cryptography, it was a pretty heavy use of algebra. And yes, computer graphics. We were supposed to learn a lot of algorithms for everything from fast line/circle/ellipse drawing through splines, radiosity, lightning models, cropping, Z - sorting and more.
At first, it was recursion. Then came the Big-O. Took about 3-4 different classes until I got it. (although, 2 of the classes did not really required me to understood what it meant, only that I memorize values of certain algorithms).
I never had problem with pointer. But then again, I don't think I fully understand it because I don't know why it is hard for others.
I am taking class on Jasmin and another one on CS theories from century ago, probably will find worthy foes soon and I be waiting >D.
Hail Assembler!
Gap-Location and the PCP-Theorem (I still don't completely understand the latter). Both deep in the field of approximation algorithms for NP-hard problems.
According to my grade sheet, Philosophy of Science (where we talk about what science is, what CS is, how CS != math even though CS ~= math). But we were graded on something we were never taught: how to analyze and discuss a text (think high-school essay).
According to my own estimation of my skills: usability and functional design (what the application should do, not how it should work internally), as taught to me. I don't deal well with wooly, unspecifiable problems which I felt bombarded with.
According to my own opinions: the software architecture course. I get that you want to slice your code into loosely coupled pieces which are small (so they're easy to understand) and few (such that the interactions are easy to understand), but I can't agree that passing around single-method stateless classes around is anything other than a really sucky compensation for Java's lack of anything resembling first-class functions. I also can't agree that a unit testing tool which makes me write a python script which autogenerates lots of boilerplate Java code qualifies as convenient. Nor that drowning your code in useless patterns helps you against interface breakage when you have to implement a change which invalidates an invariant of that interface.
That being said, I think philosophy of science is really interesting, I want all usability bugs I find to be fixed, and it's kinda' neat to say that in
sortBy (<) xs
the (<) is an instance of the Strategy pattern (and Just is a Factory instance).
I see the majority of people struggling with their Algorithms, Graphics, and Programming Languages (functional programming with type-inferring OCaml? yuck!) courses. I could add Operating Systems to that - mutexes and locking, resource scheduling, pipes, file systems, virtual memory... a handful of stuff.
I had a class in which we learned Prolog the first half of the semester and Haskell for the second one.
Prolog went well, but I had a really hard time learning Haskell. I don't know if it's because the 2 languages don't mix well together, but the concepts of Haskell just felt wrong to me...
Because of this, I'd say functionnal programming is the hardest concept I learned in school.
I'd have to say 3D transformations (linear algebra) in 3D graphics programming. Urgh.
Design and analysis of Automatic linear/nonlinear Control Systems
enough said ...