views:

2058

answers:

34

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!

+11  A: 

Parallel Algorithms was probably the hardest concept I had to learned. Or course, Compilers classes were pretty tough too.

Julien Grenier
Agree, parallel algorithms made my head hurt. Didn't help that it was 4 hours straight on a Friday morning and all the bands played at the bar on Thursday nights.
WW
I liked parallel algorithms although it could be difficult. I especially liked it when you could prove a parallel algorithm could outperform a serial one with like for like hardware such as the library problem (putting unsorted books on shelves working as a team).
PeteT
+13  A: 

Fourier transforms for Computer Vision

Toby
did you do that in an AI class?
Mark Lubin
I Forgot about that one. Personnaly I did that in a class called "Analyse d'images" (Digital Image Analysis)
Julien Grenier
I was going to write that :)
Brian R. Bondy
I did fourier transforms as well. Makes my brain hurt to even think about it.
ConcernedOfTunbridgeWells
Yup, they're definitely up there!
Ray Hidayat
Speaking as an EE, you CS guys should refrain from learning fourier transform theory in depth (it gives me better job security :) ).
temp2290
+16  A: 

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.

Jason Whitehorn
I wonder how much you find yourself using that in day to day work?
Mark Lubin
Not so much of the mathematical part is directly useful, but the general "gut feeling" that you acquire for which algorithms are better is a very useful skill for any developer.
Jason Whitehorn
It wasn't until someone pointed out that the "nondeterministic" in NP referred to nondeterministic Turing machines that NP-Complete made sense.
outis
+5  A: 

I thought that the compilers class was the toughest; thought I recall my Theory of Computation class not being a walk in the park.

Giovanni Galbo
seems to be an early consenus for Theory of Computation, very abstract class right?
Mark Lubin
That was my favorite one.
Julien Grenier
It's abstract, but it's going to be something you learn that will still be relevant in 50 years. You can't really say that about the majority of concrete software engineering courses.
Antonio Haley
My compilers class was a breeze, mostly because a) it was graded on a curve and b) the professor gave us at least half the code we needed for the project in class. One of the few As I got.
Dave DuPlantis
Don't know how it was for you but our compilers class was difficult just because of the volume of work, not because it was conceptually difficult.
Graphics Noob
+7  A: 

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.

Dan Herbert
is that another sort of subject that would be covered in a "Theory of Computation" style course?
Mark Lubin
Finite-state machines (FSM) were taught to me in a Discreet Math for Computer Science course. We were taught the basics of FSMs and then asked to program one for extra credit. I really couldn't get it.
Dan Herbert
how does a poll question have an accepted answer?
grom
+4  A: 

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.

Mr Fooz
that sounds like a class i would enjoy!
Mark Lubin
class != concept
Graphics Noob
@Lubin: yes, it was a great class. Since it was a team project class, it also gave the chance to learn some people [email protected]: "what were the hardest CS *classes* or concepts" (emphasis added)
Mr Fooz
+1  A: 

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.

Antonio Haley
That was simple! (but I was in EE not CS, these things come naturally to us)
Osama ALASSIRY
+3  A: 

Statistics, mathematical logic/formal methods, algorithm analysis.

tvanfosson
+3  A: 

Software Engineering. I liked the teacher, but couldn't stand most of the theoretical bureaucracy and paperwork.

Lance Roberts
+1  A: 

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.

Lance Roberts
+3  A: 

Computer architecture, learned a lot of low level stuff, also I liked very much Assembler, hard but fundamental knowledge...

CMS
A: 

Two areas I really struggled with was writing pure recursive code and managing solo a compiler over the course of a semester.

Paul Nathan
+1  A: 

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.

Mike Brown
+2  A: 

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.

Here is the course homepage

Brian R. Bondy
+1  A: 

For me it was a class called computation theory and more specifically pumping lemma...still have no clue what it does.

oneBelizean
With regards to the pumping lemma, see http://stackoverflow.com/questions/133601/can-regular-expressions-be-used-to-match-nested-patterns
jleedev
See also: http://stackoverflow.com/questions/461619/in-laymens-terms-what-is-the-pumping-lemma, http://stackoverflow.com/questions/2137003/are-there-any-examples-of-pumping-lemmas-with-real-languages, http://stackoverflow.com/questions/233243/how-to-check-that-a-string-is-a-palindrome-using-regular-expressions#answer-233275, http://stackoverflow.com/questions/461539/do-theoretical-computer-science-topics-such-as-regular-vs-non-regular-languages
outis
+1  A: 

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.

PeteT
+2  A: 

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.

Brian R. Bondy
+3  A: 

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.

Dashogun
I definitely agree with this one. I had a friend who knew Scheme very well yet could not get me to understand continuations. I even read the relevant chapter in SICP. I ended up botching that homework.
DV
A: 

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.

JB King
+1  A: 

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.

JesperE
+4  A: 

Dynamic Programming

A: 
  • Analysis
  • Machine learning (neural networks et al)
  • Operating systems (much work)

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.

mstrobl
A: 

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.

omermuhammed
+2  A: 

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.

milot
A: 

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.

JamShady
A: 

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.

Roman Plášil
A: 

Data Structures and Algorithm, Graphics, and Discrete mathematics

askgelal
A: 

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!

A: 

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.

mdm
A: 

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).

Jonas Kölker
A: 

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.

DV
Don't knock OCaml. I wrote an OCaml type inference engine *in* OCaml for a project at one point and it was one of the more fun things I did for school.
Tyler McHenry
I wish I shared your love for OCaml. Half of my class loved it, the other half hated it.
DV
A: 

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.

skinp
+1  A: 

I'd have to say 3D transformations (linear algebra) in 3D graphics programming. Urgh.

Phong
+1  A: 

Design and analysis of Automatic linear/nonlinear Control Systems

enough said ...

Ahmed Kotb