#55 overall
CIS 194: Introduction to Haskell
University of Pennsylvania
8 recommenders · 10 threads · recommended in 5 years, 2014–2019 · score 9.3
CIS 194 is an introductory Haskell course from the University of Pennsylvania, taught by Brent Yorgey, built as a series of lecture notes with homework exercises. It covers the foundations of functional programming in Haskell, with recommended readings drawn from Learn You a Haskell, Real World Haskell, and the Typeclassopedia.
Commenters call it a great introduction to Haskell and say that working through the lecture notes and exercises is far more effective than books like Learn You a Haskell.
Programming Languagesbeginnerfreeself-paced text#haskell#functional programming#yorgey#monads#lecture notes
Recommendations by year
20062026
Brent is one of the greatest teachers I've ever experienced. I used to take classes from him (and TA some others he taught) and was consistently blown away by his enthusiasm and capacity for sharing concepts. He has a great essay on pedagogy as well (https://byorgey.wordpress.com/2009/01/12/abstraction-intuiti...)
If you're interested in learning some of the beautiful foundations of functional programming, I highly recommend checking out the lecture notes and assignments from his Penn CIS 194 class (http://www.cis.upenn.edu/~cis194/spring13/lectures.html)
That was my guess, but I didn't want to be presumptuous. I tried with them and as well it didn't really stick. In my opinion "Learn You A Haskell" is a great supplememental reference, but a terrible teaching tool. And I think It's done more disservice to enforcing the reputation of Haskell being difficult to learn.
I highly recommend the lecture notes online from the "Upenn Spring 2013 Haskell" class. Search that phrase and it should be the first hit (am on mobile).
Go through the lecture notes, and do all the exercises in the homework. (Link in purple at the top). It's a night and day difference from LYAH.
And you get to build some nifty real world style projects along the way.
Good luck!
Do this course: http://www.cis.upenn.edu/~cis194/spring13/lectures.html
I know it sounds ridiculous but a) it took me about seven evenings b) it's a lot of fun and c) I guarantee you'll get some proper programming insight, whatever language you use for a day job.
I'd start with Haskell or Scheme. They are a lot easier to get started and learn than anything JVM. For Haskell, this course is awesome: http://www.seas.upenn.edu/~cis194/lectures.html
For Scheme, just do the first two chapters of SICP. In fact, do that anyway!
In fairness to Haskell, I didn't exactly go for readability in the above example, and indeed someone's already added a more readable example. I'll break it down for the sake of completeness:
scanr is a reduce function that produces a list of the reduction steps rather than just the final output. So I'm processing the list of primes and punting out (Maybe i, i i) at each stage (I could have included the type signature for "g" but I was deliberately going for a perl-like style.)
fst3 just takes the first element of a triple i.e. Maybe i. mapMaybe maps and throws away the "Nothing"s. Think of those as nulls.
So, returning to g, it returns a (Maybe i, i, i). The Maybe i is the prime if it's strong, Nothing if it isn't. The other two are the previous two primes. So what g does is a) compute the first element and b) copy the new prime (n) into the first location and the previous prime (p) into the second location.
"<$ guard" is a bit of a Stupid Dwarf Trick in all honesty, but the effect is: the expression on the right is a boolean expression. If it returns true, the expression on the left is returned. If it returns false, "Nothing" is returned.
If you are interested, I highly recommend working through this: https://www.cis.upenn.edu/~cis194/spring13/lectures.html (and that means doing the exercises). Haskell's a funny language in that there's a fairly easy way of doing things that would read how you would expect, and a whole bunch of "oh, but this is more elegant" things you can add on top. Thankfully, some of the most cutting edge features like ApplyingVia are actually producing _more_ readable code, not less.
found this[1] to be a great introductory course. Might want to have dipped into functional concepts beforehand, though.
Fairly sure it was recommended in here in the past and that's how I came to know it, can't give credit because I sadly don't remember.
[1]https://www.seas.upenn.edu/~cis194/spring13/lectures.html
I'm not sure Haskell's a freight train anywhere. :) It's an all stations passenger train to deeper understanding.
More generally, learning Haskell (and to a great extent any programming language) is about a different way of doing things. Deep Learning is a thing to do. (It can also be a way of doing other things, but my point is that they're at different levels.)
With that said, your time is limited. Studying Haskell, Deep Learning or Statistics (an option that is criminally underrated) is a choice you have to make, and Haskell isn't necessarily the best use of your time.
If you feel like dipping your toe in the water, though a) install stack https://github.com/commercialhaskell/stack b) try doing this course (http://www.seas.upenn.edu/~cis194/spring13/lectures.html) and _do the homework_. If you find you're enjoying it, you'll have your answer. If you're not enjoying it, it's probably not worth your time.
And for the record, I have no idea what some of the top-flight Haskellers are talking about either. But maybe one day I will.
I'd recommend Yorgey's cis194 course to start learning: http://www.seas.upenn.edu/~cis194/spring13/lectures.html
Each `lecture` is comprised of recommended reading material (sourced from LYAH, RWH, Typeclassopedia, and others) and some reasonably difficult homework problems that build on the learned concepts.
I'm in the process of finishing LYAH, and I'm also following CIS 194 which is available online (http://www.seas.upenn.edu/~cis194/, https://docs.google.com/file/d/0B0_mzHzbl3GbNXBWMVZPVGNtX3M). I've learned about it from https://github.com/bitemyapp/learnhaskell.
I think CIS 194 would be nice to be added in the book listing section? It's a great course with exercises and at the same time refer to chapters of both LYAH and RWH.
I agree!
You're mistaken if you think Haskell users don't take advantage of state or side effects. They do, you just don't understand the difference.
Try this course:
http://www.seas.upenn.edu/~cis194/lectures.html
Then see LYAH's section on the State monad:
http://learnyouahaskell.com/for-a-few-monads-more
Then reflect on ST:
http://www.haskell.org/haskellwiki/Monad/ST
Then this example using mutable variables and closures:
http://bitemyapp.com/posts/2014-03-25-when-nested-io-actions...
Side-effecting closures mutating variables!
It's not "no state or side effects".
It's about making state and side effects typed and explicit so they can be properly composed and manipulated.
A Clojure and Erlang user I got started learning recently was able to get to Applicatives in a single afternoon.
You can easily, easily spend more time debating it - learning nothing - than you would just checking it out for yourself.
If you were banging your head against the wall, you were suffering from bad pedagogy, not a bad language.
I went through the same experience! I know exactly what you're talking about, but you don't know what you're missing!
So lets stop debating and instead focus on fixing the pedagogy. You won't regret it.
Try this course: http://www.seas.upenn.edu/~cis194/lectures.html
Ping me via my email if you need help.
Haskell took me a while, because there weren't many great resources on how to write many kinds of "real" code in Haskell. The quality of material is getting steadily better.
I think you've got a good 6-12 months before Haskell is more productive for you than OCaml or a C/Python/Lua stack. If you're coming from Java, you're more productive than you were at 1 month in Haskell (you still know very little Haskell, but you're pwning your former Java-toting self)... but in your case, you already know quite a few high-level languages. So it's not surprising that you get less done in a language that forces you to contend with monads (which aren't as hard as they're made out to be, but they're one more new concept) just to have state. If you're coming from Java, you're more productive in Haskell almost instantaneously, before you really even know it. If you're coming from Python, you're less productive day-by-day because the compiler keeps burning you, but you find long-term development going faster due to fewer code breakages. If you're coming from Ocaml... the short answer is that they're both great languages with more in common than not (although I prefer Haskell) so it's not surprising that it takes a while to get up to your prior speed (because your prior speed is so much higher than that of someone from Java).
Real World Haskell is a good book, though a bit slow and dated. Learn You a Haskell is a decent intro book but it has some gaps. I'm working on a Summer Haskell Course at my company and will be publishing the slides. And Chris Allen recommends the CS 194 course that Penn offers (you can find it online). Resources are out there.