Ask HN: What is the most challenging programming course you have taken?

Logical programming (prolog).

I'm not sure I would call it the most challenging class, but it's the one where the most amount of people failed to learn anything. If I had to guess then 90% of the students (or more) ended up not being able to do anything with prolog.

I haven't seen any other class that had such an abysmally low rate of successful learning. I think the only knowledge most people took away from this class is to not use prolog.

"Advanced Programming" at DIKU (Department of Computer Science, University of Copenhagen):

https://kurser.ku.dk/course/ndaa09013u/2023-2024

The course teaches Haskell, Erlang and Prolog over half a semester (7.5 ECTS).

It mainly focuses on Haskell (7 weeks?) and covers Monad/Applicative/Functor bottom-up (i.e. you define your own, rather than use mtl/transformers), property-based testing (QuickCheck, generators, shrinking), parser generators (ReadP, minus points for parsing whitespace ambiguously). It is the 1st MSc course, so those who didn't have an FP-heavy bachelor's degree will have quite a shock. The Haskell part of the exam is writing a parser and interpreter for a non-trivial DSL.

The Haskell part already blasts most people. Then comes the Erlang part (3-4 weeks), where you learn about OTP, supervisors, process hierarchies, map/reduce, or similar problems. I remember one exam was implementing a quad tree where each level in the tree was controlled by a process.

The third part is Prolog, of which only a week of the course is dedicated to. While Prolog is a little mind-blowing in itself, the fact that it's only for one week also means the Prolog part of the exam is typically only a small set of exercises, where the Haskell and Erlang parts can be hard to complete given the allocated time.

When I took the course, I started learning Haskell in the summer break before the course started. Having two months of Haskell under my belt meant I survived the course quite fine (and ended up TA'ing it several times). But I saw lots of people way smarter than me (some of whom are now CS professors) struggle quite a lot with the pace and learning style.

Definitely the hardest course. To some unreasonably.

Programming wise, we had a class where we had to write some image filters in pure x86_64 assembly using SIMD, it was quite hard to wrap your head around the model of vectorized operations, and more so to debug your code either with GDB or visually (sometimes you messed up slightly and the whole image was borked, sometimes the image looked perfect but it was slightly off-by-one and the tests wouldn't pass). This was just 1 of 3 projects, there was also one where you had to build a small 32 bits kernel though I had less of a bad time with that one (guess we got lucky writing the code, because debugging the GDT, etc. if you mess up a single value can be a PITA sometimes).

Moreover in the same class we also had exams, in one exercise you had to write more SIMD code in x86_64 (over images, strings of utf-8 characters, etc.) this was all in paper and no reference was allowed except the Intel Manuals; that was just one exercise there were more in systems programming, etc.

I also had a bad time with Prolog and Haskell in a Paradigms class though those exercises were a bit more bite-sized and streamlined.

Non-programming wise, I'm having the hardest time right now with a Numerical Methods class which involves a lot of proof-based linear algebra, induction over matrices, etc. I also had a bad time with a Logic and Computability class.

A Masters’-level security course at UT Austin. The first assignment was “implement AES and RSA from scratch, without Bignum, and on RISC-V in an emulator.” Just… why.

Spoiler, I did not succeed at that, but neither did most of the class.

My compilers course was definitely the hardest, most rewarding, and most fun course I took. I got to take it my last semester and barely squeezed in since it was a grad course and I was an undergrad, but I had taken the professor's Programming Language Theory course (which was brutal) and he emailed me as soon as a spot was available (thank you Professor Fluet).

My prof maintained a notable SML compiler, so the language we developed our compiler for was an SML style language that was statically typed, type inferred, and functional (very capable language). From parsing, to type checking, to code gen, to optimization, every project in that class was so much fun. I hate a lot of late nights with four or five tmux windows open tracking down errors, but I don't regret any of those. Aced everything in that class except the exam on parser algos (did not study as well as I should have).

That class made me realized that I can probably write any code I needed to, assuming I had some reading on the existing domain. Huge confidence booster.

[CS 402 - Operating Systems][1] at USC during my Master's. I really wanted to develop a mini kernel which I couldn't do in my Bachelor's. This course blew every other thing I ever did out of the water. Was a big reality check too. Fortunately, I had good people around me (thanks Prof. Bill!) who made it easier to squeeze the most out of it. Till this day, it is hardest stuff I have done. Only [MIT's 6.824 Distributed Systems][2] course came close which I couldn't finish as I was going at it all alone (to satiate my Distributed Systems curiosity) and hit a wall. I really hope to get around finishing it someday as it, I believe, will take me to the next level just like CS 402 did.

[1]: https://merlot.usc.edu/cs402-s23/ [2]: https://pdos.csail.mit.edu/6.824/

I took an advanced algorithms course at uni which was purely programming projects, code must be written in either C or C++, and this was on the quarter system. Professor would just give a quick overview of the projects and used class for q&a which most students didn't partake in.

The first was to implement a search algorithm that combines binary search and interleaving search which was pretty easy.

The second was to implement a prime number generator that generates >=1024-bit prime numbers without relying on bignum library. I miserably failed at this, been meaning to revisit this (over 15 years since).

The third was to implement a huffman encoder/decoder and an lz77 compressor/decompressor. Huffman was easy, but I found lz77 pretty difficult to implement efficiently (poor choice of data structure for the dictionary and phrase search on my part). I got a very minor deduction for the implementation not being quick.

Despite not doing well I hold the course in high regard.

I would not call it challenging, but it was a fun and interesting experience. Learning functional programming through the CS 3110 course at Cornell University Here is the link: https://courses.cs.cornell.edu/cs3110/2021sp/textbook/

The OCaml part is free, well structured and does not take long to complete.

I don't know how much this applies to other institutions, but speaking personally, my undergrad Operating Systems course very much threw the students to the wolves.

It wasn't one of those "memorize the textbook and you'll be fine" type of classes. It was a "do a bunch of independent research and figure a whole lot of things out for yourself" type of class.

Maybe it was just how tough on grading my professor was but I had a hard time with a class called "Concepts of Programming Languages". It covered stuff like syntax, typing, garbage collection, etc. My professor was on the Racket dev team, and the whole class was done in Racket. He was actually pretty thorough about recording lectures and notes so it can be found here: https://jeapostrophe.github.io/courses/2013/fall/330/course/

got a book Low Level Programming by igor zhirkov. IT's not technically a course, but he wrote it for his teaching (his classes won a lot, a lot of prizes).

It's ofcourse, about low level programming, but since, the lower levels underpin the higher ones, for me the most useful thing was this book.

It was a super challenge for me personally (no degree in computing or anything), and working through it i felt more things click than any other resource i tapped into before. I feel i understand much better in any language now, what actually happens on the PC, and how to go about investigating what happens if i do not. (finding specifications, isa documents, documentation on interpreters of scripts etc. etc., learning to read code/sources.)

That being said, do you have a specific direction in which you want to improve? Because this obviously leans towards a specific flavor of programming, where it's maybe not as useful if you want a different flavor. I know many good/professional programmers who know nothing of this stuff and are really really good in their own domains.

As far as challenging goes:

Networking: Not really "difficult" concepts, but the teacher had a chip on his shoulder. The programming assignments were "fun challenging", and I think if the course was taught at a slower pace, it would have sunk in better.

Assembly: I personally didn't struggle too much, but a lot of the class did. My secret was that I had read a little bit about assembly programming in high school, and realized that I had to force myself to follow "structured programming patterns." (If true goto true else goto false.) (I also programmed with a lot of GOTOs as a kid, so I knew enough not to make a mess.) I remember showing one of my high-score assignments to another kid in class, it "clicked," and they told me that if they realized that they could make their code kinda look like normal structured code it would be much easier.

(Also, I forgot that I really, really struggled with the first assignment, which was to write "hello world" using the DOS debugger. That was the angriest I ever got in college.)

As far as "not limited to programming courses":

Foundations of Computer Science: This was difficult because of the professor. They really didn't click or empathize with the class. Most of the class was about regular expressions. They never made sense to me, so now I just have ChatGPT write them for me.

Compilers: I really, really enjoyed the homework, but again, difficult because of the professor. It basically picks up the theory from Foundations of Computer Science.

One thing I noticed was that theoretical CS classes at my school had professors who didn't really understand the students and their goals. Most of us were targeting software engineering careers: The professors would often get us lost in the theory and not bring it back to concrete terms.

Not programming, but all the math classes that were required as part of the major. Most of the programming classes were challenging in that type 2 or type 3 fun way, where they are challenging but you lowkey enjoyed the challenge. That said, I went to a bit of 'java school' so the programming classes weren't as tough as some other schools.

Automata is a good one to give you some understanding of how things work 'underneath'. The different algorithm ones are good because by implementing algorithms from scratch you learn how they actually work and that helps inform when you'd choose specific ones. I find that a decent background in algorithms is what really separates the self taught folks from the college educated ones.

Database programming was kinda tough, at least the theory side of it, because relational algebra and relational calculus are complicated and the whole normalizing databases during the design stage of things.

Finite Automata and the Theory of Computation.

Lots of Turing Machines and constructing proofs. I'm not sure I would have passed if it wasn't for my friend who worked with me on the homework.

If you want to get more technical, lean in to the Electrical Engineering department and find some courses there. You'll learn a lot about the underlying hardware and logic that your programming is interfacing with.

If you want to learn about applying your skills more successfully, look into an area where you think you'll be working. Most people don't graduate with a CS degree and start working on compilers. I worked at a network vendor where we made firewalls/routers, a lot of our programmers didn't have a clue how customers implemented our products in the real world. In that case, taking networking and security courses would be beneficial.

Knock yourself out:

https://cryptopals.com/

https://sarabander.github.io/sicp/

Operating Systems back in uni (UNSW). Hack your own mutex in two weeks, then hack virtual memory in two weeks, then hack a file system in two weeks. Of course we have other classes with their own assignments too, so you'd have to get all this done within a day.

What's great about it vs other courses is you had to understand an extremely complex thing and learn to modify it, instead of building something from scratch. In the real world, many things are not documented or misdocumented, so it's a vital skill to be able to understand how something works from the code.

The title asks specifically for a programming course but the post text says not to limit to programming courses. It's a little confusing.

Programming is something you will get better at as you do it, so I wouldn't worry too much about it. Instead I would look for computer science courses that interest you and a course outside of comp sci that requires a lot of writing. Although technical writing is probably what you will be mostly doing, consider taking a creative writing or a critical reading course.

Well, it depends on what you consider challenging:

Most work in terms of hours spent: compilers (you had to write one from scratch)

Hardest due to inherent difficulty of the material: theory of computation. Turing Machines and the Halting Problem and such weren't too bad (well, duh) but some of the more advanced stuff was pretty challenging, at least to me.

Hardest due to the material being a collection of bizarre recipes and jumping all over the mathematical map: tie between an undergrad numerical methods course and a graduate modeling and simulations course. It wasn't conceptually difficult to write the code, but understanding exactly why it worked was a different story. I've never been good at memorizing stuff unless I understand how it works (advanced statistics suffers from a similar glut of "magic recipes", in my experience).

Edit: the compilers class was the one that's proven to be the most useful over the rest of my life. I've written specialized parsers and so on a bunch of times.

I've never used the stuff from theory of computation again, nor can I imagine that anyone would who wasn't a researcher in that area.

I could see numerical methods being useful if I did a lot of down and dirty work with the physical world, but I mostly haven't done that..

Computer Graphics back at Virginia Tech. No libraries, build the 3d yourself. I learned a lot in that class, including the fact that I did not want to make games for a living.

Binary and Malware Analysis (x64, ida pro)

Hardware security (implementing rowhammer in JS powered by WebGL)

These were by far my hardest courses. One course that comes somewhat close is a course in Buddhism (meditatie en paychologie - meditation and psychology). The issue is that I didn’t have prerequisite knowledge. The psych part was easy. Reading a 1000 year old Burmese text on Buddhism/meditation at that time had so many crazy traps that it was just fascinating how wrong I interpreted that text.

Easiest course that I took: social psychology

Best course that I took: a teacher that said “I am too lazy to teach. Just make a cool project.” I taught myself iOS development and made an iPhone app that led to a job for a year creating an iPad app

All at the Vrije Universiteit Amsterdam

Most fun course: technology & games. Creating a game with unity3d and publishing a paper, that was fun. This was at the Universiteit van Amsterdam. The course doesn’t exist anymore sadly

Binary and Malware Analysis (x64, ida pro)

Hardware security (implementing rowhammer in JS powered by WebGL)

At the Vrije Universiteit Amsterdam

These were by far my hardest courses. One course that comes somewhat close is a course in Buddhism (meditatie en paychologie - meditation and psychology). The issue is that I didn’t have prerequisite knowledge. The psych part was easy. Reading a 1000 year old Burmese text on Buddhism/meditation at that time had so many crazy traps that it was just fascinating how wrong I interpreted that text.

Easiest course that I took: social psychology

Best course that I took: a teacher that said “I am too lazy to teach. Just make a cool project.” I taught myself iOS development and made an iPhone app that led to a job for a year creating an iPad app

Cryptography in masters program of Moscow State University. Although it’s usually more challenging to learn something new before it reaches university courses…

Edit: noticed that it’s not just about programming. Then it’s complex analysis and theoretical physics at MIPT. Most computer science problems felt simple compared to that stuff.

For me personally it was SICP [1] at MIT

https://ocw.mit.edu/courses/6-001-structure-and-interpretati...

A course on abstract interpretation [1], taught by Radhia [2] and Patrick [2] Cousot at ENS in 1989. To my shame, I must admit that I didn't appreciate it at the time.

[1]: https://en.wikipedia.org/wiki/Abstract_interpretation

[2]: https://en.wikipedia.org/wiki/Radhia_Cousot

[3]: https://en.wikipedia.org/wiki/Patrick_Cousot

I took a functional programming in Haskell course first year in Uni without having much previous programming experience at all. Quite early in the course we were tasked with implementing a huge bidirectional graph and an efficient shortest path algorithm for finding the fastest way between any two nodes. I hadn’t taken any DSA course and was totally unaware of graphs and shortest path algorithms and the course material was pure Haskell syntax. I failed miserably and so did most of the others.

UNH CS 720, OS programming ... it was basically posix programming in C. All my cohorts told me not to take it cause I wasn't going to pass it. I busted my butt and I clawed a B-. I basically worked a 40 hour week on that single class, sometimes more. My entire CS degree was a struggle. What a great value - that degree dealt me into a domain I wouldn't have had access to on my own. I have felt very blessed since then.

My Numerical Methods class always felt just a bit beyond what my brain was capable of understanding. It was easily the most difficult course I had.

Probably compiler class focused on the theory aspect of it.

It was much more interesting/useful the other compiler class I took which actually had me create a parser+compiler for a made-up language. Still somewhat challenging to think in that way, as it's not the usual way to process data.

Uni would've been way easier if they taught us TDD in the 1st semester instead of the 5th

Either my Ocaml course or my prolog course. In the end, I managed to use Ocaml, but endofunctors are still a mystery to me, while I managed to build half a prolog in common lisp (the inference engine part), so I'll say Ocaml.

In Computer Engineering, my most challenging course was “Communications Theory”.

Computation Learning Theory with Rocco at Columbia. Proof heavy course where you spend the whole time deriving bounds of learning algorithms, average on exams and take home assignments was like 40/100

Compiler Design. Dragon book and all. Learned a ton from that class

In undergrad, Operating Systems was pretty challenging. (Duke)

My brain regularly explodes once it comes close enough to delimited continuations. I haven't even understood what a "prompt" is in that context.

CSC265: Enriched Data Structures and Algorithms (UofT)

Ed Lamagna's "Algorithms and Data Structures" course at Univ. of Rhode Island.

I really had to work for that class, but the payoff was tremendous.

If you wanna something that will require most of the options in the other answer here: Database engine.

The Pavlov course is good.

Formal methods in Z notation or predicate logic in prolog... Still have nightmares 20 years later.

If you are searching for challenges, then whats the point of limiting yourself to school level?

I guess the first one ?

A course being challenging is not a good indicator of its quality I think.

Check out cses.fi not a programming course per se but still relevant.

I took an advanced perl class at the local JC back in 2003.

Denthor’s tuts, aged 11