HN Academy

The best online courses of Hacker News. [about]

Functional Programming Principles in Scala

Coursera · École Polytechnique Fédérale de Lausanne · 144 HN points · 53 HN comments

HN Academy has aggregated all Hacker News stories and comments that mention Coursera's "Functional Programming Principles in Scala" from École Polytechnique Fédérale de Lausanne.
Course Description
Functional programming is becoming increasingly widespread in industry. This trend is driven by the adoption of Scala as the main programming language ...
HN Academy Rankings
Provider Info
This course is offered by École Polytechnique Fédérale de Lausanne on the Coursera platform.
HN Academy may receive a referral commission when you make purchases on sites after clicking through links on this page. Most courses are available for free with the option to purchase a completion certificate.

Hacker News Stories and Comments

All the comments and stories posted to Hacker News that reference this course.
Functional Programming Principles in Scala https://www.coursera.org/learn/progfun1 on Coursera. It's taught by Martin Odersky, one of the language's creators. Very well organized, highly automated assignment testing (you submit via CLI). I went in wanting to learn Scala, but what I learned about FP has stayed with me for years. Even though I've moved on from Scala I'm a much better programmer for having taken that course.
Functional Programming Principles in Scala [1] taught by Martin Odersky, professor at EPFL and creator of the Scala language.

[1] - https://www.coursera.org/learn/progfun1

necrobrit
Seconded! Odersky is a great lecturer (and very practical lecturer despite Scalas "academic" reputation) and the course was very well organized.

I did the course on the first or second run however, not sure if it has been kept up to date or if it is still well run.

Was disappointed with the follow up courses though, the lecturers didn't live up to Odersky.

andy_wrote
I'm in the middle of auditing the Scala track on Courersa.

The first course was great. I agree that Odersky is a very good lecturer, organized and easy to follow. I'd recommend it to anyone interested in Scala.

The second course was OK but not quite as good, it felt a little less systematic. It was mostly Odersky, but for part of the final week the course switches tracks to a different lecturer who clearly was preparing slides for a different lecture series, and I thought both the lectures weren't as clear and the stitch-in of the different material wasn't handled smoothly.

I've just started the third and while it's not Odersky, the lecturers have been good so far.

wongma
Would this course be appropriate for those with a lot of general programming (OOP) knowledge, but little to no FP experience?
acjohnson55
I'd go as far as to say that those folks would be the ideal audience.
dragonwriter
IMO, yes, very much.
There is a course on Coursera thaught by the Scala creator: https://www.coursera.org/learn/progfun1
gingerbread-man
It's actually a series of 4 courses, 5 if you include the "capstone project." I've watched a few of the videos-- it's pretty decent, but intended for those who don't have much experience with functional programming. The first course I believe is modeled off the Structure and Interpretation of Computer Programs.

I think the answer to this question really depends on where you're coming from. An experienced Java developer will need to focus on different things than someone who has spent the last decade hacking Common Lisp or OCaml.

joncrocks
I would agree and disagree.

The first course is the one that's dedicated to Scala the language, whereas the rest are more focused on reactive/parallel programming that happens to be in Scala.

The first course is good, and acts as a good introduction if you've encountered functional programming before.

The canonical source for learning Scala from scratch (at least, when I was learning a couple of years ago) is the Coursera course by Martin Odersky, one of the language's founders. It appears that the course has grown somewhat, but you can still find part 1 here: https://www.coursera.org/learn/progfun1
dv35z
I took the course - unfortunately, and to be honest, it didn't have the approachability and "fun" of Zed's books. To me - it felt very dry, academic, and quickly became a chore to complete rather than a joy. I need the version aimed for "C- python programmer" / newbie rather than "eager CS student" or "experienced Java dev".
blacksmythe

  >> Coursera course by Martin Odersky
Brilliant course.

Unfortunately, the next one in the series is not nearly as good.

I have suggested Odersky's introductory MOOC [1] to many of my students and they all thought it was great. It's heavily inspired by SICP, so it should be easy, given your background.

[1] https://www.coursera.org/learn/progfun1

wpietri
Yes, I second the recommendation for the course. And I can happily recommend it for people who don't even plan to use Scala, but who just want to get a feel for functional vs OO approaches. Odersky sees them as complimentary, and in some sense Scala is his way of proving the point.
That's interesting. Just a few days ago with great regret I decided to drop the (free) Scala course on Coursera after almost finishing week #3 (of 5 I think). I'm actually already pretty familiar at least with the essentials of functional programming but would like to go even deeper.

However, I found the step too steep between the easy to understand lectures and the exercises, and the latter not as useful as they could be. It felt like I was suddenly dropped off and left to my own devices with no guidance. "Now implement this!" Uhm... what? Sure, that's easy, I've been implementing much more complicated things for decades. The problem is I have no idea how to approach it "the right way" as far as Scala is concerned, that's why I'm taking the course!

Looking at the forum - extremely sparsely populated even after over 4 months - showed that I could also expect no guidance from there. That meant that even when I finished a task I was unable to find out if what I had done was the right (functional) way. For one and most importantly, there is hardly anyone to respond, but also since the only exercises are the homework assignments you can't just post your code, that's an "honor code violation". There also is no "solution", i.e. you can't see how the course author(s) would have implemented it.

Another example, people in the forum complained about extreme differences in performance for very minor differences in the way you wrote something, and you had to find all of this out completely for yourself, again no guidance at all.

Another point is that I found the problems too academic. Sure, I can walk a list of head.tail or a tree of left.element.right tuples. But overall the problems were all from what I did a long time ago at university and it felt very, very far from what I deal with now - and I don't just do CRUD or other boring stuff and actually do have interesting algorithms to implement. The course feels like being made for university students - in a negative way.

Overall I found the course more frustration than it was worth. I could have solved the programming challenges easily enough in a way I already knew, but what's the point? I wanted to learn the new (Scala) way, but felt all alone in trying to do that.

The course was like a good violin player demonstrating a piece and then giving me some sheet music and shoving me out the door "come back when you can play that". It's hard to complain about "free", but if course forum participation is a guide, both total numbers as well as the steep drop-off after week 1 and 2, it isn't very successful.

The course: https://www.coursera.org/learn/progfun1

Note: Enrolling in the courses individually is possible for free, going through the "specialization" page at https://www.coursera.org/specializations/scala only shows the for-pay option.

the_af
I actually liked the progfun1 course, which I took a few years ago. It's one of the cleanest courses I've taken on Coursera. It's true that it's slightly "academic", but that's what many introductions to functional programming often feel like.

However, the follow-up courses, Reactive Programming (retired) and Functional Program Design, are a total let down. They are a rip-off, especially if you paid for them: a complete mess, no relation between lectures and assignments, no introduction of new concepts in relation to a greater context, the slides are not proof-read, constant mentions to non-existent slides and lectures, repeat material from previous courses (a side-effect of the courses being mash-ups of previous material), and example code that doesn't type-check or compile. It's not any single mistake, but the aggregation of them all, and the feeling that the authors just don't care enough. Thankfully I didn't pay for this.

In my opinion, the gold standard for Coursera is Dan Grossman's excellent Programming Languages, which I fully recommend.

davnn
I share the exact same story. Progfun is a really smooth introdu tion to FP in my opinion, no crazy syntax and only the core concepts. For any deeper concepts and if you don't understand what FP really means you should check out a purely functional language.
Noseshine
Just to clarify my opinion on progfun: The lectures are good.

The coding tasks could have been okay - if there was any guidance. I don't even get to see any sample solutions. So even if I make it work, I don't know if that is a good way to do it, the "functional", the "Scala way". And the performance issue I mentioned, it was a major one, the difference between the code even being usable for more than a thousand elements in the list or getting a stack overflow, and the difference was extremely minor, in one case the order in which you called "union" on sets. All of that had to be found out by the students, and even after they found out nobody really had a good idea or explanation for why it was so.

Also, there only was one (small!) opportunity to actually practice what you just learned per week - and that came without any feedback apart from "works/doesn't". Since the course was about a particular programming style that really wasn't enough.

yawaramin
Have to say, I loved Dan Grossman's work teaching SML. Quite a few of those lecture videos had lightbulb moments for me.
They are orthogonal. Program in Scala and do both.

http://www.scala-lang.org/

Free course(s):

"Functional Programming Principles in Scala" https://www.coursera.org/learn/progfun1

"Functional Program Design in Scala" https://www.coursera.org/learn/progfun2

(There are two more free courses in the "specialization" - only the certificates and the capstone project cost money - original announcement http://www.scala-lang.org/blog/2016/05/23/scala-moocs-specia...)

pekk
"Program in Scala" is just promotion, not an answer to the question. There are more than a few languages which advertise the possibility of using both OO and functional styles.
mafribe
That's correct, but in which other ones is the integration so smooth as in Scala?
ridiculous_fish
Swift, OCaml, F#, Common LISP?
airless_bar
No?
ridiculous_fish
I am not a Scala programmer. Can you please give some examples of how Scala integrates OO and FP better than other languages?
I took:

1. Functional Programming Principles in Scala[1]

2. Machine Learning Specialization [2]

[1]: https://www.coursera.org/course/progfun [2]: https://www.coursera.org/specializations/machine-learning

goralph
1 is a fantastic course. It changed my life, quite literally. Lead me down a path to a new job, new city, and a new partner.
Mar 11, 2016 · hythloday on Scala School
I've taught Scala to tens of engineers. The golden path is the Coursera course "Functional Programming Principles in Scala"[1]. It's a pretty comprehensive set of lessons, by the author of the language, of how to tastefully compose the basic elements of Scala to solve interview-sized questions. I really think that Martin Odersky's skill as an educator is a highly underrated part of the success of the language.

[1] https://www.coursera.org/course/progfun

mafribe
I have asked tens of final year students to learn Scala for their final year projects, and pointed them towards Odersky's Coursera course. All my students liked the course, picked up Scala quickly, really enjoyed programming in Scala afterwards. Once they get it, they typically say something along the lines of "I never want to go back to Java".

As an aside, part of why Odersky's course work so well is that it's influenced by SICP (Structure and Interpretation of Computer Programs) by Abelson and Sussman.

mathattack
I'm curious - is the harder part of learning Scala the language itself, or getting one's mind around functional programming itself? (Does having a Scheme/LISP background help?)
acjohnson55
For me, I grasped most of usage of the language fairly quickly, from a standpoint of working functionally. I think there are a couple parts of Scala that are intimidating to beginners.

First of all, there's a lot of choice in how to organize a solution to a given problem. Say you've just started to grasp the idea of algebraic data types and manipulations thereof. You might still find it hard to know how to apply it in a given situation, because there are several ways to do it [1]. As you gain experience, you start to get a feel for which option is more appropriate in a given situation.

Secondly, a lot of the basic concepts of Scala are super general, so you can sometimes see language elements used in ways that are surprising. In my experience, you start to build a mental model for actual usage of language elements, but it's still intimidating at first. See this question and answer about the `object` keyword [2].

But then, even as you master the language, there are all sorts of little gotchas you learn to navigate. This is true of any language of course, but it can be more frustrating when you're operating at a higher level of abstraction. The Dotty project seeks to rewrite the Scala compiler in line with an improved framework of some of the more innovative type system features of Scala. I think it's ultimately going to lead to a better foundation with less gotchas. But it's still a long time coming.

Oh yeah, and the `implicit` system is a beautiful concept, but pretty unique to Scala, and intimidating at first.

[1] http://stackoverflow.com/a/26690131/807674

[2] http://stackoverflow.com/a/28036272/807674

justinhj
I was a long time hobby level Common Lisp and Clojure programmer when I started learning Scala. Understanding functional programming before coming to Scala definitely made it easier. That said I think Scala has a little extra learning curve because you need to understand some syntax especially around type declarations, and understand how flatmap and map work, not just on lists but on many different kinds of data structure.
goldbrick
It doesn't help that Scala takes a lax attitude towards functional principles whenever it's convenient -- for instance, you can map over a set, and certain maps will get you a different type back. Haskell it's not. It's more like a terse Java with optional types and pure functions added on.
tylerpachal
Is it possible to see the material even though the course isn't currently running?
tsotnet
Yes you can see lectures, homeworks, etc. Only you can't submit homeworks for evaluation.
Oh yeah, there are not many options nowadays. I know this one which is offered by Coursera: "Functional Programming Principles in Scala". I didn't take it, but it should be helpful if one want to explore that "weird wizardry functional stuff" -and discover that there is not much wizardry at all. Oh and as others stated above, it is not that difficult once you really dive in :)

[1] https://www.coursera.org/course/progfun

My Coursera profile lists 67 courses, I have completed ~15 of them and with a passing grade ~8 of them. My most favorite one, which for me was the hardest as well, was The Hardware/Software Interface by Gaetano Borriello and Luis Ceze[1]. I also liked Computer Networks[2] even though it's an introductory course, Functional Programming Principles in Scala[3] which is surprisingly easy unlike the follow up course[4], High Performance Scientific Computing[5], Software Security[6] and Cryptography[7] although I prefer Boneh's class. For non-IT related courses I liked Think Again: How to Reason and Argue[8], Crafting an Effective Writer: Tools of the Trade (Fundamental English Writing)[9], Child Nutrition and Cooking[10] and Work Smarter, Not Harder: Time Management for Personal & Professional Productivity[11].

I often take time to think why I have so many started but not finished courses. Most of them are abandoned on the first week and my assumption is that when I enroll my expectations for the course content and the workload needed are wrong.

Occasionally, I abandon courses because they demand too much time to get something working on linux or because of luck of time. The thing that I noticed about me is that when I get a little behind the schedule then it's almost certainly that I will abandon the course. Additionally, when I try to commit on two courses at the same time then it's certain that I will abandon at least one (usually both).

[1]: https://www.coursera.org/course/hwswinterface

[2]: https://www.coursera.org/course/comnetworks

[3]: https://www.coursera.org/course/progfun

[4]: https://www.coursera.org/course/reactive

[5]: https://www.coursera.org/course/scicomp

[6]: https://www.coursera.org/course/softwaresec

[7]: https://www.coursera.org/course/cryptography

[8]: https://www.coursera.org/course/thinkagain

[9]: https://www.coursera.org/course/basicwriting

[10]: https://www.coursera.org/learn/childnutrition/home/welcome

[11]: https://www.coursera.org/learn/work-smarter-not-harder/home/...

Algorithms: Design and Analysis Parts 1 and 2 (https://www.coursera.org/course/algo and https://www.coursera.org/course/algo2) taught by Tim Roughgarden of Stanford. Tim's the best professor I've ever had either on or offline and he does a fantastic job explaining the concepts and breaking down the algorithms into digestible, intuitive pieces. His enthusiasm for the topic and the impressive algorithms is contagious and keeps the challenging courses fun and interesting.

Functional Programming Principles in Scala (https://www.coursera.org/course/progfun) by Martin Odersky, the inventor of Scala, is also excellent and a great way to learn and start using Scala and functional programming. Be forewarned though, once you get a taste of Scala, you'll have to be dragged kicking and screaming back to using Java :-).

jedmeyers
Also, Algorithms, Part I and II (https://www.coursera.org/course/algs4partI and https://www.coursera.org/course/algs4partII) by Kevin Wayne and Robert Sedgewick of Princeton University. They approach algorithms from a slightly different angle than Stanford course does and in my opinion they complement each other very well. I was very impressed by the lectures, practical problems, the autograder, and the 'Algorythms 4th edition' book.

p.s. don't expect any certificate of acomplishment for those courses though. I did them both close to 100% and they did not even show up in completed courses on Coursera. I guess it's the Princenton thing, and I came just for the knowledge so that was fine with me.

truncate
Also MIT OCW lectures for Algorithms. These are old and video quality is not nice, but course is really good. I think they published a newer version of this course too. http://ocw.mit.edu/courses/electrical-engineering-and-comput...
whitenoice
Here's another very well explained data structure and algorithms course lectures from IIT - http://nptel.ac.in/video.php?subjectId=106102064
Agreed with it basically being lots of hard work, and that you have to be very motivated.

I'm currently 29, working as a Software Developer, and also started late. Got my MSc in Oceanography, had some basic programming experience (built basic websites for beer money, some light scientific programming), but not much. Decided I liked the analytics more than the rest of science, and got a job at a SaaS company as a Data Analyst. Really started falling in love with programming quickly there, and did the following: - took online courses like crazy (often waking up early to get some in before work, and more on evenings/weekends when possible) - always took on the most technical tasks at work, where I'd get to write as much Python/R/SQL as possible - started a coding club at work, great for group learning and motivation

After ~2 years of this I had gotten myself to a point where I could legitimately work as a Software Developer, and got a new job as one (at the same company). Stayed in my area of expertise, data science/analytics, but as a developer instead of an analyst.

I wouldn't suggest codeacademy, though. Maybe it's changed since I tried it, but my experience was that they introduced you to a bunch of syntax, but left out most of the fundamentals of how computer science and how to structure programs. I'd much more strongly suggest taking more involved courses. Some of my favourites include (note - bias towards Python, Scala and SQL courses, as that's what I happen to use a lot of):

Intro to Comp Sci (Python) https://www.udacity.com/course/intro-to-computer-science--cs...

Intro to Web Dev (Python) https://www.udacity.com/course/web-development--cs253

Data Structures and Algos (Python): http://interactivepython.org/runestone/static/pythonds/index...

JS intro: http://eloquentjavascript.net/

Functional programming (Scala): https://www.coursera.org/course/progfun

Reactive programming (Scala): https://www.coursera.org/course/reactive

Good databases courses (boring but good content): https://lagunita.stanford.edu/courses/DB/2014/SelfPaced/abou...

My personal feeling is that things like codeacademy get you superficial knowledge, like learning to use tools, when what you really want is deeper knowledge about how to build houses, regardless of the tools.

For a ground-up, thorough, and free course on functional programming in Scala, take the course Martin Odersky teaches our undergrads at EPFL (Functional Programming Principles in Scala): https://www.coursera.org/course/progfun

Given as a MOOC on Coursera.

eranation
Great course, well tought and constructed. Great auto grader for the excercises. Both challenging and fun.

P.s. I liked your talk at north east scala symposium about scala's type system, looking foreword to more like this

worklogin
That course is definitely targeted to people with previous programming experience.
ramblerman
I would argue the same about the language in general. Not from an elitist perspective, but I don't think it is a particularly beginner friendly language.
moondowner
Sadly this course dwelves too much into mathematics. Most of the time, when learning a new language one might want to make a simple real-world app.

Don't get me wrong, the course is good, but sometimes some things could be presented in a simpler way. If I were to enroll into the course again, first I'd check out Twitter's Scala School page to learn some basics: https://twitter.github.io/scala_school/

davegurnell
Totally agreed with Heather. Martin's Coursera course is an excellent functional programming course. The fact that it's free is kind of crazy.

Differentiating Coursera and Creative Scala, Coursera is aimed at people with some programming experience and is intended as a comprehensive introduction to functional programming. Creative Scala is intended as a taster rather than a comprehensive course. It is designed to be run as a workshop in a few hours to a day.

The bulk of Underscore's basic Scala training is our Essential Scala book/course, which is aimed squarely at people requiring learning Scala for commercial purposes. Essential Scala is a follow-on from the material in Creative Scala.

The Coursera Functional Programming Principles in Scala[0] course is definitely worth the time. Coming from being a Java programmer in my day job, it's made my Scala I've written since a lot cleaner, in my opinion. It's also had the side effect of making Java a bit more unbearable. It's definitely not to be approached as a beginner to programming though.

[0] - https://www.coursera.org/course/progfun

Usually we have programmers take the Odersky coursera course. [1]

1: https://www.coursera.org/course/progfun

jgrowl
I took this course about a year ago. It was my real exposure to a functional language. I had a lot of fun!
I'm not sure about the best possible resource to read, but in the traditional of functional programming, immutability is preferred in nearly all cases. This is particularly important when it comes to data with long-lived scope (e.g. members of objects, data within the scope of closures, etc.) because the functions that operate on non-constant data lose purity and become more difficult to reason about and test. In other words, mutability leads to side-effects, wherein operations on data in one part of a program are visible within other function, without explicitly being passed in.

In many functional languages, mutation of variables is only allowed in special cases, and in some languages, it's not allowed at all. This can be weird if you learned programming in a tradition where modifying variables is one of the first things you were taught, but once you get used to not mutating your variables, the benefits really start to shine. As you mentioned, it often prevents entire categories of errors. For instance, I haven't written a for loop with an index variable in well over a year, in favor of using map/flatMap/filter/fold and friends, and for that reason, I can't remember my last fencepost error.

Like I said, I don't know the best resource, but learning Scala was really influential for me in immutable programming, and the Functional Programming Principles in Scala Coursera course [1] and the (unrelated) Functional Programming in Scala book taught me a lot of what I know on the topic.

[1] https://www.coursera.org/course/progfun

[2] http://manning.com/bjarnason/

Touche
In JavaScript const is not immutable.

    const foo = {};
    foo.bar = 'baz';
This is valid, you cannot reassign foo, but you can mutate it.

Native immutables in JavaScript would be great, but would be hard to pull off given prototypical inheritance.

EDIT: Now const + Object.freeze gets you close to immutable. I'm not sure what that means for inherited functions, can the parent prototypes not be mutated either?

acjohnson55
Yeah, this is also true of the `val` statement in Scala too. I suppose though that in Scala, one would probably make all data members of classes `val` as well, whereas in Javascript, there's no in-line syntax for constant object properties (Object.freeze being a bit verbose to use everywhere).

But even that limited form of enforced immutability is helpful. I personally find it easier to understand a complex function when I can assume that no names are being rebound.

tel
Double down on Rúnar's book! You have only learned half of Scala until the day that "FP in Scala" is trivial to you.
iMark
Ta muchly - I shall investigate.
> The only real form of code reuse that OOP addresses is direct object inheritance.

Not really, or at least, not with a well designed system. Give me a system with small, composable objects. I can reuse code by creating a new object for one of the components of the system, or by writing an object that knows how to talk to a previously existing objects. Sandi Metz' POODR [1] should be required reading for anyone who is writing object oriented code.

Functional programming is also worth learning as well, and Martin Odersky's Coursera [2] shows how Scala can be used for code that is both object oriented and functional.

[1]: http://www.poodr.com

[2]: https://www.coursera.org/course/progfun

Oct 31, 2014 · bkeroack on Scala Best Practices
a) Martin Odersky has admitted as much[1].

b) The compiler internals are reportedly a mess[2]--likely due at least in part to the extreme number of different syntax variants.

c) I find rule 4.1 in OP interesting ("SHOULD avoid concurrency like the plague it is"). According to Odersky's Coursera course[3], one of the main advantages of functional programming as enabled by Scala is easy, safer concurrency (reduced/absent mutable shared state). Yet here we see a presumably seasoned Scala veteran basically saying that this is a failure and we should avoid concurrency whenever possible because it results in too many bugs.

1. http://www.infoworld.com/article/2609013/java/scala-founder-...

2. https://www.youtube.com/watch?v=TS1lpKBMkgg

3. https://www.coursera.org/course/progfun

frowaway001
It's always funny to see how these things get interpreted. :-)

a) There is a lot of work going on at the foundations of the language – most of the stuff is unlikely to be felt by users.

b) Compilers are hard, there is very likely no "nice" compiler out there (except for toy languages). This has almost nothing to do with syntax variants. Nevertheless, there are multiple groups which are working on improving the codebase.

c) Concurrency is hard to get right, especially "traditional" approaches like synchronizing, locks, etc. If it's not necessary, don't use it. Otherwise use the right abstractions for your problem, as mentioned in the next paragraphs.

bad_user
I really can't reply to that, sorry.
Scala's creator's course on coursera certainly doesn't encourage complicating things beyond the minimum necessary

https://www.coursera.org/course/progfun

orteipid
I've used Scala on and off professionally for about 4-5 months and the best advice I could ever give to someone using it for the first time is to try and treat it like Ruby but with type safety.

As numerous people before me have said, the language is a mess. Although it offers some benefits, the syntax is so absolutely bloated that you're probably better off taking the time to really consider whether or not you absolutely need it for all of the headaches and unreadability you're going to run into in terms of code. There aren't many Scala developers out there and the learning curve can and likely will punish you when things need to get done, assuming you're bringing in new developers.

The open source libraries all generally seem to have glacially slow development processes, which in some cases might be considered acceptable, but when the main Scala team pushes out 2.11.x (and to some degree actively encourages its use) and X framework you're using literally cannot run because library Y is not compiled against it, you end up stuck on Scala 2.9/2.10 which is really unpleasant for you because you're missing out on the speed increases and other quality of life improvements (how many times have you run into the 22 argument limit for case classes on 2.10?).

Perhaps I'm asking for too much, but Scala strikes me as a language that's supposed to be moving a bit faster than Java in terms of development, but that doesn't really seem to be the case. All in all, while it has some neat parts, if I never got to work with it again I wouldn't be crying about it.

lmm
I'm not sure what libraries you could be talking about except the Twitter ones, which yeah, are slow, don't use them.

There really are a bunch of new features and a faster development pace than Java; look at the differences between 2.11 and 2.9 (e.g. macros).

_pmf_
I resent Scala because it takes up a spot in the JVM ecosystem that I wish a ML family member would occupy.

I really hope Java 8 will slow down Scala's growth.

spopejoy
I really wonder why we need the JVM at all.

For Haskell at least, the GHC runtime is getting pretty good, and seems to have at least basic tools for GC analysis etc. I'm ignorant of MLs so perhaps someone can speak to their status.

Of course there's the much-touted "Java Ecosystem" but it's looking crustier than ever methinks. Maven?? Blech! Also, it doesn't seem wise anymore to build a website on Servlets/JSP/SpringMVC etc, esp. if you want to attract devs. Rest APIs maybe.

What's the killer feature these days recommending the JVM?

frowaway001
Reliability, performance, maturity, instrumentation, diagnostics.

Just picking one example from the list, performance: How is GHC's runtime dealing with 100GB+ heaps?

sixbrx
Do the Oracle or OpenJDK JVMs deal well with heaps that large? I have no interest in other JVMs because my employer would not consider switching and I can't say I blame them.
kasey_junk
It depends on what you mean by "deal well with heaps that large". You can certainly set them that large with no problems. But given your memory patterns they can cause dramatically bad GC times.
frowaway001
Yes. It's routinely done.
jfb
I enjoyed Dr Ordersky's course (of course, it's based largely on SICP, which I also enjoyed), but there's a world of difference between the code you write for those exercises and the code you write in the real world.

I'm on record as being a Scala skeptic; I've already run into things that the type system seems to encourage but causes headaches, and the size of the language means that no matter how small a subset you write yourself, you can't help but page out when someone else's subset is different than yours. I know that C++ or Perl wizards eventually get to the point where this isn't a problem, and I guess that Scala is positioning itself as Java++, so the same caveats apply.

Sep 15, 2014 · 4 points, 0 comments · submitted by himanshuy
Sep 15, 2014 · 10 points, 1 comments · submitted by palcu
facorreia
I highly recommend this course for anyone interested in learning about functional programming and/or the Scala language.
Martin Ordersky hisself is teaching Functional Programming in Scala starting September 15th:

https://www.coursera.org/course/progfun

If you don't know C, or Python or Ruby, there's always "The hard way" with Zed Shaw:

http://learncodethehardway.org/

October 2, Coursera is abain offering Dan Grossman's Programming Languages, it covers general concepts in programming language design using SML, Racket, and Ruby.

https://www.coursera.org/course/proglang

squiguy7
Thanks for the links. I am really interested in functional programming in Rust and Scala as well as some systems level stuff with Go and Rust again. I will check these out.
I found the Functional Programming Principles in Scala course on Coursera to be incredibly helpful

https://www.coursera.org/course/progfun

The course was very challenging and I learned a lot in a very short period of time. Highly recommend it.

I'm not a fan of Scala and I absolutely loath sbt, but I absolutely recommend the FP Coursera Functional Programming Principles course[1] that uses both of them. There's an edition already running now but close to the end, however you can still join and work through it. Because it's an online course you'll find other people also working through it and, depending on where you're based, maybe some real world study groups as well.

I'd argue that the pain of downloading jars with JMV isn't that bad. Sure, it's a real pita to download them, but afterwards they're cached and immediately available. Also, if you're using Scala or Clojure then it's really easy to jump into the repl and start playing with the language.

If you're looking for "real world" fp then those may be your best bet. Haskell is a beautiful language and becoming a lot more real-world, especially compared to it's history and reputation as only an academic language. I'm not really a Haskell expert but I worked through Learn You a Haskell for Great Good [2] and found it to be one of the most enjoyable texts about a PL that I've ever found. You can read it all online for free or buy it in real-world book form.

As well as those I've worked through SICP in Racket (a lisp), SICP is a classic and well worth taking a look at even if you don't want to lisp.

I've written in all of the above with Emacs where there's great support, I'm sure there are vim equivalents of the language support, although I'll have to rely on some other HNer to point them out.

Finally, elements of FP are seeping through into non-fp languages, you can already see them in Java 8, C#, JS, Python, Ruby and more. No one can really call these languages FP languages, but if you know some of them then it might make jumping into FP seem a little less alien.

[1] https://www.coursera.org/course/progfun [2] http://learnyouahaskell.com/

Senkwich
Thanks for the comment! I wish this site let initial posts be more than 2000 characters so I could have gone into more detail.

The main reason I am hesitant to work with Scala/SBT is because I've been using Docker to package/deploy a lot of the web applications I've written. Since Docker is a one-or-nothing for each line you execute, I am getting either all of the dependencies installed at once (which takes awhile the first time) or - if something fails - I get none of them. The caching that sbt offers is basically thrown out, which is really frustrating.

There's that, but I also just don't like how much weight there seems to be with Scala because of all of the large jars I have to download to do anything. At least, that's what it feels like for me.

So, I'm not sure what specific language you would recommend. You indicated that Scala/Clojure aren't too bad and offer repls to start playing, but how hard are they to really set up for a decent-sized project? One team that I'm working with has used Clojure for DSL-related work, but mostly use Java for their main application.

Haskell is the language that I've been reading about recently that seems to have more "meat" available each year (from Hackage), which is encouraging. Everyone (including yourself!) claims that it is a beautiful language, and quite a few believe that learning Haskell - and I mean really learning it - has redefined how they approach software development. That kind of change is what I'm hoping to discover if I delve into a functional language in a big way.

I'd forgotten that I had used DrRacket in academia at one point, but not enough to learn much of it. What exactly makes SICP a classic to you?

As for other languages that are beginning to exude some functional... functionality, I've noticed that (with Java 8 and Ruby), but I'm afraid that I'm not really grasping the strengths of said features. I'm trying to jump into a more functional language to really understand why they can be good and hopefully take away something really meaningful.

Thanks for the links! I'll check them out later today!

May 15, 2014 · 37 points, 15 comments · submitted by draq
brudgers
Enrolled in current iteration and think it's good enough to finish.

A great excuse to learn Scala. A serviceable introduction to functional programming. Middle of the road in quality relative to other computing coursrs on Coursera I've taken. Work load toward the lighter end for a Coursera course focused on programming [among those I've taken]. Use of IDE encouraged. Use of SBT required.

Of note: assignment structure and IDE encourage and facilitate testing practices. Also for a later iteration of a programming course the discussion forum is very active.

ch4s3
I would love to hear from someone who took (and completed) this class with no prior experience in Scala or FP.
austinz
I fit your criteria. I really enjoyed this class; I felt like there was a good balance between Scala-specific features and conventions, and a more general overview of the functional programming way of thinking. The programming assignments were surprisingly involved for an online class.

Since I can't learn anything from lectures unless I force myself to pay attention by taking detailed notes, I took detailed notes. You can find them at the link below, although I make no guarantees about their correctness. (Note that they may also spoil the answers to some of the impromptu in-lecture quizzes.)

https://docs.google.com/document/d/1Uk54kbCIKUx8eX2vJsX591ss...

chowells
I wasn't a fan of the course. For context, I've got a lot of experience in FP, but no experience in Scala. I took the course hoping to learn Scala.

The course didn't teach me Scala. I suppose if I was an FP beginner, I would have learned something, but not much. It had about the same depth in FP as my college Programming Languages course, except that course also covered a ton of other topics.

Part of how dissatisfied I was is because I took the course immediately after Dan Boneh's cryptography course, in which I learned a ton. I was very disappointed how little content was actually in the course.

the_af
The title of the course is "Functional Programming Principles in Scala". To me this indicates the focus is FP principles, and Scala is the tool used. The FP content they teach is very good for an introductory course, in my opinion.

If you took the course and read the forums, you probably noticed a LOT of people really struggled with the FP part. Imagine if it also added more in-depth Scala features...

eweise
There was very little content or you already knew fp so you didn't learn much?
chowells
I felt like there wasn't much content. Some of it was also very misguided, like having an Int => Bool set representation, and then having part of the assignment say "pretend the domain is limited to 0-10000 for this next part". It took 4 or 5 weeks to get to examples of using map. That just felt remarkably slow.
platz
I took this class and enjoyed it; it was my first experience with scala, but I had previously taken grossman's programming languages course which introduce me to FP (https://www.coursera.org/course/proglang).

Actually I thought grossman's was better at giving a comparison of FP and OO and hit on some more of the theory in FP (for example, odersky doesn't talk about the expression problem, but grossman did).

There will still be a lot in scala that's confusing after taking this class, but it's trying to teach the concepts rather than the language details.

That being said, I really enjoyed it and would recommend it.

Scala is an interesting blend of FP and OO. Just be aware that the ML-style languages (or even a lisp e.g. Racket) really feel more like FP. The blend is what makes it a mind-expanding course.

thothamon
I also fit your criteria. I learned a lot, however I would say I didn't really "get" functional programming until after reading some more books and taking a different course that emphasized functional programming. In this course, I was trying to write imperative programs just as much as I could. However, without this course as a foundation, I doubt my other reading (and the other course I took) would have been as valuable.
xydinesh
I have worked most of this course myself and I am finishing last two assignments. I think, I have learned a lot too. Would you care to share other books you read and course you took ?
peejaybee
I had no previous experience with Scala or FP. I thought it was an excellent course, and one of the most intellectually challenging things I had done in a long time.

I review the course in more depth at http://bigscary.com/2013/02/27/functional-programming-in-sca...

zoomerang
It was fantastic for me, really helped give me the 'bootstrap' I needed to start writing functional code.
ojbyrne
I enjoyed (and completed) the class. I had no scala and only minimal FP experience.
dkarapetyan
It is a pretty basic course. Depending on your level of programming experience it might not even be worth it.
ishbits
I did most of the course and was pretty new to FP. I have no plans to do Scala development, but the course did help me become a better programmer in the languages I do use.

I've been a developer for 10+ years but have been ignorant to FP. It just opened my eyes a little bit.

For side projects, have you considered Racket? Like Python there's a beginner friendly ecosystem - it might be argued that it has a better one based on Racket being the product of several decades of research into the problem of teaching programming languages.

Being a Lisp, it doesn't have the backwards/forwards compatability issues of Python 2/3 and of course has the Lisp goodness of Clojure [1].

Unlike Python, the community tends to row in the same direction because the active development community is strongly rooted in academia. This also means that just about every software theory gets rolled into the ecosystem as someone's graduate thesis or a professor's publish or perish publication. Yes, I'm a fanboy (but if it's any excuse it's because I'm a Lisp fanboy).

Another option for learning FP is Scala and Functional Programming Principles in Scala by Martin Odersky just started on Coursera [Odersky designed Scala]. Like Clojure, Scala runs on the Java Platform, and is designed to address some of the same programming issues.

Racket: http://docs.racket-lang.org

A long but great presentation on Scala: https://www.youtube.com/watch?v=LH75sJAR0hc

Odersky's Course: https://www.coursera.org/course/progfun [2]

[1] And you can tell your friends that you are using the same programming stack as was used by PG for Hacker News even if it's a bit of a stretch it does have some snob appeal.

[2] Odersky's course is loosely based on SICP but using Scala.

scobar
I hadn't considered Racket nor Scala. The first I'd heard of Racket was while reading about Arc. Thank you very much for the suggestions, and for the links to get started.

It's off topic from my original question, but what's your opinion of Arc? Is it a good idea to try to learn it as my first FP/Lisp language, or learn another first and explore Arc afterward?

brudgers
Many of the issues PG addresses with Arc are those he encountered as a professional programmer in Common Lisp - the project is more analogous to Clojure or Scala than Racket in that way. That's not to say that you can't use it. People have worked through SICP in Arc. The question is what makes this better than MIT Scheme or Racket?

I've read through PG's tutorial. It claims to be for anyone, but there's a lot of discussion about fairly specific Lisp idioms - I don't think it's all too beginner friendly. In fairness, introductory tutorials where the messy interwoven details of the real world are left out doesn't seem to be consistent with PG's thinking, I don't think he's a big fan of dumbing things down, but I could be wrong.

Unlike Racket, Arc is very much batteries not included. And there aren't libraries full of them. Almost anything you want, you will need to build yourself. It's the hard way that's harder than Zed Shaw. Think On Lisp sort of programming.

http://www.paulgraham.com/onlisp.html

--- Edit ---

What the hell, I'll just go all in.

If you're serious about Functional Programming, then why not Haskell? The documentation and community is pretty strong and it forces you to think about side effects and use strong static typing.

I don't like Python. I've tried and I've tried. Parenthesis may be visually unappealing, syntactic white space is mentally unappealing. And the whole 2/3 incompatibility suggests IE 6 and Cobol [which I find Cobol actually interesting with it's focus on data and emphasis on readabiilty]. Maybe if I was doing scientific computing, I'd use Python, but only if I could not afford Mathematica.

To me, and one of the reasons I wanted to like Python is that I grew up watching Flying Circus in the 70's, turned my son on to Holy Grail when he was five [thereby giving him an excuse to blame me for his adult problems], and have the 16 Ton DVD's. But my snarky conclusion is that Python needs the gimmick to distract attention from it's warts. It just doesn't work for me, though. Spam and eggs is cute, but it the effort might have been better spent.

Python is better designed than JavaScript. But JavaScript is unapologetically kludgy as to merit respect.

I do like Ruby. It's design is elegant and for general scripting, it's going to be just as fast. Mix in mixins for objects and blocks for higher level function passing and it's got a lot going for it. One of the big things for me that it has over Python is explicit `end` statements for blocks - Python ends blocks by indentation which means that formatting errors can give GOTOfail type errors.

Coming back to Scala, it reminds me of ML. It has the same sort of light syntax. The only reason I wouldn't use it over Python is the overhead of the Java platform - if you've got Java's libraries, you probably don't need Python's.

If you're on Windows, then C# and F# and TypeScript make a lot of sense. Lot's of documentation, lots of libraries, solid IDE, and the equivalent of the JVM you get for free.

Prolog is pretty cool. I here Smalltalk changes the way people think about programming, and I've toyed with learning Drakon.

http://drakon-editor.sourceforge.net/

Relevant: "Functional Programming Principles in Scala" starts in 4 days on coursera, which was created by the author of scala.

https://www.coursera.org/course/progfun

eranation
This is a great course, love it and recommend any developer taking it.

Having that said, if all you want is to "switch from imperative language X to Scala", (e.g. from Java) and you want to learn first how to do the "non functional" stuff in Scala, then keep in mind that this course is teaching functional programming first, Scala later. You can do (if you want) very imperative and object oriented style of coding in Scala but this course is not focusing on that part of the language (not because it's bad, but simply because the course is about functional programming)

With that said, go and enroll, it's one of the best coursera courses I took. Great videos, and very interesting programming assignments (many are adaptations from SICP I later learned) and great forum discussions.

the_af
Of course you're right, but I actually thought the strength of the course was that it teaches you FP first, Scala later. Scala I'm still undecided about, but I loved FP.
sateesh
Another complementary course is "Paradigms of Computer Programming" https://www.edx.org/course/louvainx/louvainx-louv1-01x-parad... which is being taught by Peter von Roy. The course covers the functional, declarative, and dataflow programming paradigms.
raphinou
This is indeed a great course. The videos are well done, and Peter Van Roy's explanations are very clear. Even seasoned programmers could learn a lot from this course.
terhechte
I concur, this is a really good course. I've since switched to Clojure but I still think that I gained a lot from working through this course. It is a really great introduction into functional programming paradigms, and well worth it even if you don't plan to continue using Scala.
some_pythonista
Have you seen the follow up course "Principles of Reactive Programming" too?

It's also by Martin Odersky, but also with Erik Meijer and Roland Kuhn.

https://www.coursera.org/course/reactive

acjohnson55
I took both classes, but I really didn't care for Reactive as much. The first Coursera class really turned me on to the elegance of functional programming with Scala's unique type system, but much of that elegance is really lost dealing with some of the structures introduced in the second class, in my opinion.

Reactive is split into three "subclasses". The beginning part, taught again by Odersky, was a pretty useful extension of what was taught in the first class. As with the first class, the lectures were very well thought out. Although, some of the examples abandon the beauty of side-effect free programming, which was a letdown after really being turned on to that style in the first course.

The middle section on Futures and ScalaRx was pretty rough. Those lectures, done by Erik Meijer (I believe), were less clear and less well planned. I don't know if there's an impedance mismatch between Scala and the reactive style or if ScalaRx is just the wrong abstraction, but the joy of Scala was completely lost for me in these two lectures. I'm used to Javascript's Promises/Deferreds, which are essentially the same thing as Scala's Futures/Promises, but the former are far more intuitive syntactically.

I did, however, find the final three lectures on Akka to be very well taught. I had no experience on actor model programming, but I came away very intrigued by the possibilities.

A complaint that spans all three sections was that the assignments could be better focused on the the concepts at hand. Each can require a fair bit of constructing your own test and debugging frameworks to figure out how to pass the rather opaque and unhelpful automatic grading system. I eventually lost patience and quit doing the assignments after floundering with the tools.

the_af
I concur. I loved the Functional Programming Principles in Scala course and recommend it to everyone I can. However, I'm not at all sold on the Reactive Programming course.

Erik Meijer's lectures -- at least in the first iteration of the course; maybe they've gotten better -- were riddled with errors, confusing exercises, and an overall lack of coherence with the rest of the course. It pains me to say this because Erik seems like a cheerful guy and I really wanted to like his lectures, but they are a mess.

Even Roland Kuhn's lectures, which are pretty good and a lot clearer than Erik's, didn't manage to sell reactive programming to me. One glaring problem was that the actor model seems to throw away most of Scala's static type checking, which we had learned on the previous functional course. Suddenly it's ok to pass whatever message to actors in a way that seems closer to dynamic typing.

haakon
I've always found this to be a strange duality in the Scala community. On the one hand they praise strong, static type checking in general Scala programming, and on the other hand they praise an almost untyped paradigm in the actor model. And few people seem to take issue with this.
noelwelsh
Plenty of people don't like this aspect of Akka. Most of them are using scalaz-stream instead.

See http://noelwelsh.com/programming/2013/03/04/why-i-dont-like-... and http://www.chrisstucchio.com/blog/2013/actors_vs_futures.htm...

headinthebox
You are most welcome.
terhechte
I did start that course, but after the first 2-3 videos I couldn't find the time to continue working through it. Back then I was working on a customer project that required a lot of attention. I may want to try it again the next time that it is being offered.
agumonkey
A nice complementary one on coursera is proglang, taught by Dan Grossman (at least the first run was), uses racket/sml/ruby.

Very nice, with a focus on interpretation and comparison points between paradigms.

platz
Yes! Grossman hit on many higher concepts in FP and PL in general than Odersky's, and offered compare/contrasting views.
eweise
I took this and its really good. Highly recommend
anotherfadjs
Scala is a hideous programming language designed in the egocentric world of academical masturbators.

Furthermore, it exists outside of the real world, it's unflushed academic diarrhea. Adding syntactic sugar (more like salt) on top of Java's async functionality doesn't make a programming language, neither does importing the worst from languages like Perl and OCaml.

Functional programming should be done with an elegant functional programming language, not a six headed monster.

Nov 28, 2013 · noahmarc on Choosing Scala
Thanks for joining the discussion. Just want to say I'm working through the the videos for your coursera course (https://www.coursera.org/course/progfun) and, in addition to being a great introduction to Scala, it's changing how I approach other functional languages like JavaScript and R
mercurial
At most JavaScript is an imperative language with functional flavour
klibertp
Try LiveScript: http://livescript.net/

JS semantics are those of a functional-oop language. It lacks a few standard functions (LiveScript has prelude-ls) and a ton of syntactic support for things. Once these are in place, you can write the code which looks and feels like Ocaml.

For example, moment.js function is `moment(dateString, formatString)`. In LiveScript I used it as:

     parseDate = (flip moment) "DD/MM/YYYY"
Now tell me that this doesn't look like functional code :)

(The only really lacking feature in JS is of course TCO, but then Clojure, so yeah, let's just trampoline everything.)

Sep 25, 2013 · jmduke on Working hours: Get a life
A big distinction for me is "programming as work" and "programming as play". I can spend eight hours at work and be absolutely drained when I get home, but still leap at the chance to say, take a bite out of my functional programming course (https://www.coursera.org/course/progfun -- it's awesome, and taught by the guy who designed Scala, so he knows a thing or two) because its a completely different context for me, or scroll idly through GitHub issues as I eat dinner.
redblacktree
Taking that class now. As a professional developer, it pains me to say: That class is fucking hard. I haven't managed a perfect score on an assignment yet, though I'm still working on Week 2. Good luck to you! It should be a great adventure regardless.
This is great, thank you. Some links for Scala:

Documentation: http://www.scala-lang.org/ Twitter School for Scala: http://twitter.github.io/scala_school/ 99 problems in Scala: http://aperiodic.net/phil/scala/s-99/ Coursera with Martin Odersky: https://www.coursera.org/course/progfun

Sep 16, 2013 · 2 points, 0 comments · submitted by bgar
I have similar feelings about Scala. Combines functional programming w/ a strong/static type system and all the benefits of the JVM. Very practical and fun which I found was not the case w/ Haskell and ML languages. And you couldn't ask for better timing, first day of class starts tomorrow[1]! (and in a month and a half, reactive programming[2])

1 - https://www.coursera.org/course/progfun 2 - https://www.coursera.org/course/reactive

droopyEyelids
One ding to Scala's practicality, it's such an enormous language that to use it in production with a large team almost requires a C++ level of discipline in deciding which elements of the language to use. It's a terrific language though and the fact that it runs on the JVM is a huge advantage.
pestaa
Can you please tell me more about your experience with Haskell?
Sep 10, 2013 · jjsz on PayPal hardware powered by Go
Thanks, I knew about Revel and mgo.

I just forgot to say: a FRP* [0] Go equivalent of Play and that there's nothing like these upcoming Coursera courses [1] [2] for Go with examples.

[0] http://www.reactivemanifesto.org

[1] https://www.coursera.org/course/progfun

[2] https://www.coursera.org/course/reactive

If you go on the course page

https://www.coursera.org/course/progfun

You see archives of the two previous iterations of the course. Their material is always available, and you can stream or download the videos from there.

virtualwhys
Huh, I don't see any archive links on that page, where are they?
Lrigikithumer
It may just be for people who previously took the class, I haven't taken it and cannot find any of the archives mentioned by modersky, but I can find it on other courses I have taken
modersky
It looks like you are right. Only enrolled students can see the material and enrollment is closed for the previous sessions. I'll check whether there's a practical way to make the material available.
virtualwhys
That would be great, very likely won't have time to participate in the Scala FP course this session, but would love to see the videos regardless.
BystanderX
Count me in here. Would love access to lectures or videos.
The prerequisite course starts in about 2 weeks [1], so you can still take it if you want before Principles of Reactive Programming starts, you'll be able to see what parts you feel you can skip and which ones are useful. There are other quick introductions to Scala you can take [2],[3],[4] to get a feeling of it.

[1] https://www.coursera.org/course/progfun

[2] http://www.scala-tour.com

[3] http://scalatutorials.com/tour

[4] http://learnxinyminutes.com/docs/scala

Aug 26, 2013 · 3 points, 3 comments · submitted by vukmir
The Martin Odersky's course starts September 16th. Has anyone taken this course before? If you did, what's your experience?
vukmir
The course starts September 16th. Has anyone here taken this course before? If you did, what's your experience?
eranation
I have, it is a good introduction to both functional programming and Scala. I later found out that many of the assignments are derived from SICP.
vukmir
Thank you eranation.

I've played a bit with Scheme and Haskell. Scala is the next on the list and this course looks like an excellent opportunity to check it out.

Aug 19, 2013 · joshz on Scala School
Coursera has a class as well. Martin Odersky tweeted a while ago about a possible advanced course in the fall but it doesn't look like it's happening yet.

http://www.coursera.org/course/progfun

pramalin
I finished the course when it first came out last year. This appears to be the third session of the same class. I'm also eagerly looking for an advanced course. I used Scala in "Algorithms: Design and Analysis, Part 1" programming problems. Even as some algorithms are described in recursive style, using tail recursive implementations fail for large data sets and I have to fallback to imperative styles with lots of mutable data structures to complete the assignments. A Scala based algorithms course would be very useful.
Jul 22, 2013 · sampo on FP vs. OO, from the trenches
> In OCaml, objects can contain mutable values but they must be explicitly marked as such.

Or in Scala, you have to mark object's variables either as `val` (immutable) or `var` (mutable).

Like /u/Fishkins said, the Scala course in Coursera gives some examples of the use of immutable objects ( https://www.coursera.org/course/progfun ). I am sure they are used in a lot of places in Scala code, not only in Odersky's course.

It's the topic of the third week of Martin Odersky's Scala FP course: https://www.coursera.org/course/progfun
Also, _Functional Programming Principles in Scala_ course on Coursera by Martin Odersky (Scala's designer) is very good.

https://www.coursera.org/course/progfun

dhugiaskmak
I just finished the most recent session of this class and I found it incredibly frustrating that there was no discussion of the homework assignments after the due dates had passed. What's the point of having homework if there's no way to get the correct answers and get feedback on your solutions?

And take the "in Scala" part of the course title with a grain of salt. You're only taught enough to complete the exercises.

Apr 18, 2013 · rz2k on Economies of Scala
One advantage is the Coursera class being taught by Martin Odersky[1] right now.

[1] https://www.coursera.org/course/progfun

(Though I suppose that is like saying you should only look for your lost keys under a street lamp)

> Scala... REPL starts up pretty slow.

I wonder if your setup is faulty. My Scala REPL takes a couple of seconds to start. Admittedly longer than Python's, but not enough to worry about it. I'm on an old clunker laptop too.

Also, you may be interested in this course on Functional Programming in Scala run by Martin Odersky himself. It started last week. https://www.coursera.org/course/progfun

happy_dino
I'd say that this sounds pretty too slow, too. My REPL starts in less than a second.
At https://www.coursera.org/course/progfun they state that the workload is around 5-7 hours/week.
Yeah, I should've submitted https://www.coursera.org/course/progfun link instead. Too bad I can't edit it now.
There's a page with a description of the course that doesn't require logging in: https://www.coursera.org/course/progfun
Feb 22, 2013 · 2 points, 0 comments · submitted by ooooak
Jan 28, 2013 · 2 points, 0 comments · submitted by weh
Dec 29, 2012 · ddw on Why Learn Scala in 2013?
Funny, I had already planned on this as a 2013 goal of mine - this blog post only reinforced it!

Coursera has a Scala course from Odersky that's worth giving a shot: https://www.coursera.org/course/progfun

Another resource for learning Scala is Werner Hett's 99 problems in Scala: http://aperiodic.net/phil/scala/s-99/. I tried it after doing Odersky's Scala class (https://www.coursera.org/course/progfun). If you've done the class, it's not a bad way to get some practice with constructs that weren't particularly useful in the class.

If you haven't done the class, the problems are simple enough that you could probably learn scala by just working through the problems and googling for relevant syntax. They start to get more involved around problem 50, but, by that point, you'll have a good grasp of the syntax.

If you want to try them out, I have unit tests for the problems I've done (only up to 58, so far) here: https://github.com/danluu/ninety-nine-scala-problems. The tests are pretty rudimentary; I'm sure there's at least one github repo that has more comprehensive tests, but I looked around at tens of repos of other people's tests on github when I first started and I didn't find much.

P.S. If you're in Austin, there's a Scala group that gets together that isn't a meetup, and hence, isn't findable from Graham's link in step 9: https://groups.google.com/forum/#!forum/austin-scala-enthusi.... The majority of the folks there actually use Scala in real production code.

JohnCohorn
The ATX group is indeed a good one.
pohl
Thank you for the repo of test suites!
the Coursera course "Functional Programming Principles in Scala" just ended but they're keeping all the content online until the next run of the course

the lecturer, by the way, is the designer of Scala

https://www.coursera.org/course/progfun

pohl
It was an awesome course. I can't wait for part 2.
grlea
Great resource. Thanks heaps for sharing it. I've added it to the blog as an alternative.
As someone (college student!) who's been skeptical about free online courses for quite sometime - I'm finding that as I finish up Martin Odersky's "Functional Programming Principles in Scala" course [0] on coursera, I've learned more in the span of 2 months than I have in 90% of my college classes thus far. One could argue 100%.

I'm really looking forward to seeing where this goes.

[0]: https://www.coursera.org/course/progfun

I am a polyglot programmer even though I try to concentrate on languages that I need to get stuff done. I am really enjoying Martin's Scala class https://www.coursera.org/course/progfun, I use Clojure a lot on customer and my own projects, and (J)Ruby is so often my go-to language. And, I use Java a lot, but less than these other JVM languages.

That said, I was having a quiet think while walking in the wilderness recently (I live in the mountains) and I asked myself the tough question: would I have accomplished more in my professional life in the last ten years if I simply always used Java? I honestly don't know the answer but I suspect that the answer is that in some absolute metric of both money earned and productive work for society, just sticking with Java would have been the better call. In the past I have had the same quiet think about just using (J)Ruby.

The big win of being a polyglot programmer is reshaping one's mind to think about problems in different ways, and I don't know if it is worth it.

kaffiene
That's a really thought-provoking post. Thanks for that. Regarding being a polyglot programmer I think that it's important to know how to approach a problem from different angles, as you say. Knowing imperative, functional and OO approaches is in itself a useful thing. But I don't think it's just that - it's also useful to know that you could do a particular task in another language where it's idioms or libraries or performance characteristics are more appropriate.

I don't use Lisp a lot these days, but I'm always grateful that I learned it, because it increased my toolkit of possible solutions. I think people that think "there's only one way to do it" sometimes produce bad solutions. But not always! I think pretty much everyone hates VBasic, but one of the people I work with created a great product in VB because that was what he knew. I wouldn't take the language-bigot approach of calling him a 'blub programmer'. Just because he used a poor language, it doesn't mean he's an idiot.

tl;dr - knowing more languages increases your toolset which is good, but it doesn't in itself make you a superior programmer

Sep 18, 2012 · 10 points, 0 comments · submitted by Toshio
For anyone who's interested, coursera is offering a Scala course taught by Odersky this fall. It starts the 18th of September.

https://www.coursera.org/course/progfun

I feel someone should mention this here: Less than a month from now Martin Odersky himself will begin teaching a free online course "Functional Programming Principles in Scala".

https://www.coursera.org/course/progfun

Looking forward to Odersky's course Functional Programming Principles in Scala.

https://www.coursera.org/course/progfun

spacemanaki
Kinda interesting that SICP is the first book on the suggested reading list. Too bad the start date is months away!
nessus42
Odersky's own Scala book has some large examples that are based on sections of SICP. E.g., the digital circuit simulator.
tikhonj
SICP should be on the suggested reading list for basically all CS classes :P.
Jul 17, 2012 · 74 points, 13 comments · submitted by pedro-pinto
petercooper
We are a social entrepreneurship company that partners with the top universities in the world to offer courses online for anyone to take, for free.

What's the business model? I can see why Odersky might want to promote his own language but more generally, why would someone of his caliber devote the time? Philanthropy? Or do the universities pay?

nl
I believe companies are paying them for access to the best students of specific courses (for recruiting).

For example, the Princeton Algorithms course says:

.. Coursera will maintain limited data regarding student progress and performance in this course and, with your permission, provide authorized third parties with access to such data.

https://www.coursera.org/course/algs4partI

Given what recruiting fees are, I'd imagine this could work quite well. It is unclear how well it will scale, but if they can keep their costs low enough it may not need to.

whazor
"The founders said they were not ready to announce a strategy for profitability, but noted that the investment gave them time to develop new ways to generate revenue."

So I think letting universities pay for the data or students paying for certificates.

Source: http://www.nytimes.com/2012/04/18/technology/coursera-plans-...

davidf18
Odersky is also Chairman and Chief Architect of Typesafe which promotes Scala and is backed by Greylock Partners. Typesafe offers its own courses as well.
thebluesky
That is seriously impressive. How many universities get the creator of a language in to teach you how to use it?
noelwelsh
Note that Martin Odersky is a Professor at EPFL. So it's not like they got him in teach Scala -- he already works there and naturally wants to teach a course on programming using the language he designed.
bartonfink
The big one that comes to mind is Stroustrop at Texas A&M.
zackzackzack
Which is sort of an odd situation.

I took a CS intro class at Texas A&M there and he came in at the end of the semester to talk more about C++11x. So he ended up going off about support for threading and things that were way over most people's heads and how the language was getting all of these new features.

From a university standpoint, every intro CS class is C++ for the most part. There is some Java thrown in, and maybe some Python, but all of the algorithms/data structures, really the meat of the basic CS education, is all in C++ because of him. Other professors do some of their research in C++ mainly because they can just walk down the hall and ask him questions about the language if need be.

I think for grad students he would be an awesome resource to have. For the undergraduates, he has cast a strong and complex shadow on the department. The environment has become you learn C++ and then go into the Oil/Engineering/Accounting industry.

No major point here, just reflecting on the topic of "Stroustrop at TAMU"

elviejo
Bertrand Meyer creator of Eiffel teaches at ETH Zurich
evanelias
It's impressive, but also unusual, which makes sense: most language-specific courses tend to be geared towards beginners / people who are relatively new to programming in general. Some language developers are great teachers, so they make excellent instructors for an introductory course. But I wouldn't say this quality is universal, much like how many respected CS professors/researchers aren't so great at teaching.

Not commenting on Odersky in particular, since I'm not sufficiently familiar with him, besides the white Scala book. I will say though that course description claiming Scala "provides the core infrastructure" for my employer is a small overstatement. We definitely use it for some important services, and continue to use it for new projects, but it isn't accurate to imply it's the dominant language in our codebase.

nl
How many universities get the creator of a language in to teach you how to use it?

I think that is why lots of people are attracted to working at Google (Pike, Thompson, van Rossum, Bloch, etc)

Q6T46nT668w6i3m
Ross Ihaka, coauthor of R, is an Associate Professor of Statistics at University of Auckland.
frou_dh
His Clojure analogue Rich Hickey gives great presentations at conferences. If he had the time and/or means to do a course, it'd also be excellent news.

Edit: Though I don't think he's affiliated with a university. Oh well, there's still lots of good Clojure-oriented stuff available: http://alexott.net/en/clojure/video.html

HN Academy is an independent project and is not operated by Y Combinator, Coursera, edX, or any of the universities and other institutions providing courses.
~ [email protected]
;laksdfhjdhksalkfj more things
yahnd.com ~ Privacy Policy ~
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.