Hacker News Stories and CommentsAll the comments and stories posted to Hacker News that reference this course.
Not GP, but: I recommend Standard ML. I can't see a better way to do this than to power through Dan Grossman's three course sequence, which goes back to the drawing board and teaches Standard ML  to introduce modern programming language features such as scope, closures, types, pattern matching, modules, and so on. Then, he uses the concepts introduced in Standard ML as a springboard to introduce Scheme in the second course, and Ruby in the third course. And in the end, you will see how each of the three languages implement in different ways the same powerful techniques.
But with just that first Standard ML course, you can already branch out to more popular languages such as Scala , which gives you the closest thing I've seen to "Standard ML on the JVM". But Standard ML (or Ocaml, which is very close) might even be your preferred language for prototyping , or compiler writing .
P.S.: To make Coursera tolerable, I usually pull the entire course with this nice little script . Works great with ranger and mplayer!
⬐ nicklafI almost forgot to mention: Matt Might has an excellent blog post about what all of these "advanced" programming languages offer: http://matt.might.net/articles/best-programming-languages/⬐ HeWhoLurksLate> Uses script to copy programming course.
That's a little meta, don't you think?⬐ nicklaf⬐ misiti3780Welcome to Lisp: https://www.defmacro.org/ramblings/lisp.html :-)thank you!⬐ nicklafCaveat emptor: Standard ML is not widely used in industry and does not have a large library ecosystem, so if you do recommend it to clients, make sure it's clear that they'd want to follow up with something like Scala or Ocaml, which have far more users/libraries. It's just that for really understanding functional programming, Standard ML is fantastically clear. (Although actually, that Scala coursera course I linked to above is by Martin Odersky, and is also pretty darn good, especially if you're already committed to the JVM.)
Others have mentioned Elixir, which would also be an interesting option to explore. The main difference being that with Elixir you're leveraging Erlang and BEAM (which gives you a fantastic platform for actors and lightweight threads), versus Java and the JVM in the case of Scala (which gives you access to all of Java).
There's a Coursera specialization on Scala, however it seems to focus more on data analysis than web development.
⬐ hiram112I didnt think the Scala Coursera was very good for general developers - a bit too academic and focusing on functional / recursive patterns which aren't a good way to get a feel for the language in everyday web usage (vs Php, Java, etc).
I'd recommend the book 'Scala for the Impatient', tutorials and projects from Twitter, and Maven or SBT template projects.
If you're worried about your resume, just use the down time to pad it with new skills.
Maybe something like this? https://www.coursera.org/specializations/scala
Haskell forces you to think in a certain way. So if you want to learn about functional programming, then when you're searching for programming examples all those examples will be in a functional style. You can then apply those styles to Scala or F#. Personally I'd lean towards Scala (on the back of Spark) - there's the Coursera Scala Functional Programming course  which will give you a good start.
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_afI 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.⬐ davnnI 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⬐ yawaraminJust 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.Have to say, I loved Dan Grossman's work teaching SML. Quite a few of those lecture videos had lightbulb moments for me.
My suggestion is to try to audit a series of courses. This will force you to concentrate on a particular theme; some of the courses are not self-paced and have a deadline to finish problem-sets (which are Juyptor notebooks where you have to actually do the work, and fill-in the code snippet but not to muck around with setting up annoying IDE/dev environment, autograded with unit tests), so will force you to stick to deadlines.
Here are some of courses that you might (read: actually I am) interested.
https://www.edx.org/xseries/data-science-engineering-apache-... (3 courses on Apache Spark using PySpark and introduction to simple machine learning and distributed computing)
https://www.edx.org/xseries/genomics-data-analysis (3 courses on R, next-gen genomics sequencing, annotation and some more cool computation protocols involved with CHIP-Seq and RNA-seq).
https://www.coursera.org/specializations/scala (4 courses + capstone, spearheaded by Martin Odersky; the guy who is the big-wig in the Scala community).
Also, I'd recommend taking the verified tracks for all of them. This will force you to complete them as money is on the line (if possible ask HR/your boss if it's related to your work, for tuition reimbursement benefit).
⬐ lukasLanskyI recommend taking the specializations, but don't expect you will be able to reimburse them as Coursera is unable to provide invoices.
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. I also liked Computer Networks even though it's an introductory course, Functional Programming Principles in Scala which is surprisingly easy unlike the follow up course, High Performance Scientific Computing, Software Security and Cryptography although I prefer Boneh's class. For non-IT related courses I liked Think Again: How to Reason and Argue, Crafting an Effective Writer: Tools of the Trade (Fundamental English Writing), Child Nutrition and Cooking and Work Smarter, Not Harder: Time Management for Personal & Professional Productivity.
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).
Taking that (free) class on coursera was an eye opener on all the things that are discussed in this article. Highly recommended:
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...
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.
If this interests you, definitely consider taking https://www.coursera.org/course/reactive
I found this to be a great introductory course to the topic (Eric Meijer is one of the instructors):
> if you're throwing punches you should know what you're talking about.
Ironically, I think you completely missed his point, probably because of an unfamiliarity with his background and history. He's not dismissive of reactive programming at all, quite the opposite! For example, he gave a course on Coursera about Functional Reactive Programming with Martin Odersky and Thomas Kuhn.
So my take on it is that he's just making fun of himself and his friends in a typical blunt Dutch fashion. Which of course doesn't work if you don't know the context.
Very interesting. By the way if someone is interested in more details about Reactive programming, there is a great coursera course about it (https://www.coursera.org/course/reactive)
This is an interesting topic, which I've been thinking about a lot. It seems like ten years later, we have the same duality going, but with successor models. We've gotten rid of the shared state that makes threading a pain to yield Actor Model/CSP and we've reified callbacks into promises/futures, events into streams, and mutable data into signals to make each encapsulated and composable in Reactive frameworks. It seems that the former model has really taken off in imperative programming and the latter in functional style.
A paper from EPFL  does a great job of breaking down the problems of the Observer/Event pattern and how reactive patterns shore up the workflow. It also contrasts the resulting framework with others, including actor models. Interestingly, both models seem to have settled on message passing, the main difference being whether it's the sender's or receiver's responsibility to initiate the connection. In an actor model, the sender must know the receiver's address in advance, and receivers generally accept messages from anywhere. In a reactive model, receivers are responsible for connecting to a message source, and the sender has no control over whom receives its messages. Unsurprisingly, since Odersky is one of the authors of the paper, Scala has a great deal of support for both models.
I'm not sure I fully understand the contrast between the models. The Principles of Reactive Programming [in Scala] Coursera course  actually devotes subsections to both models respectively, but rather oddly does not make much of a comparison between the two. I haven't read anything that fully explores this duality, or perhaps whether there is a model that generalizes/unifies them.
Does anyone know of good resources on this topic?
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.
⬐ acjohnson55I 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.
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⬐ terhechteI 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⬐ headintheboxI'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.⬐ noelwelshPlenty of people don't like this aspect of Akka. Most of them are using scalaz-stream instead.You are most welcome.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.
⬐ DougMerrittGee, an entire course on functional reactive programming rather than a link to the FRP idioms enabled by generics? For me? Gee thanks.
I was having a chat with someone this morning and said that I thought stream processing would be big in 2014 in response to reactive programming .
I'm checking out Kafka  and Storm  over the holidays in preperation for this.
⬐ chollida1Probably a good call.
CEP (Complex Event Processing) has been used in trading systems since about 2004, earliest I've heard of. By about 2008, it was widely in use in the industry.
It's now considered an old technology, meaning it has to be part of your tool box but no longer gives you any competitive advantage.
I don't see it going away, but the biggest problems with it now is its speed.
Solve how to you guarantee that a signal will flow through your system in a guaranteed time and you can make some money.
Or put another way, trading systems are often like video games. Just like how video games engines limit the time an engine has to draw a frame a trading system will limit the time it takes to make a buy/sell decision based on an input.
TL/DR CEP or streaming architectures often don't guarentee all rules will be run over an input in a guarenteed time frame.⬐ krczI believe Spark  might take the place of Storm as it unifies streaming and batch processing.
Personally, I found the outline of the Coursera course you mentioned a lot more interesting than the "manifesto":
I was reading up on Monads because of the reactive course.  I translated the code in "Monads for functional programming" (the linked paper) to Python a few weeks back – 
Not sure if it will actually help anyone, but it did help me in realising that I had not understood some code, but had instead just glossed over it. The State Monad, for example. 
Your timing could not have been better. There's a reactive programming course going on Coursera right now. Tomorrow we will start the part that introduces Akka. You can still enroll in the class.
Are you aware of the follow-on course?
⬐ mynegationYes, I am following that course, thank you! Although due to crunch at work I am not doing assignments for this one.
Created an account to test it out. Looks good. But I wasn't able to find Reactive Programming class but I assume new classes are still being loaded and added.
A suggested feature, and one I've considered doing myself, is to have a sort of timeline of classes. So that if I sign up for a class from November to January, and one from December to February, it would show that they overlap during December and January. One of the biggest problems I have is biting off more then I can chew, and what I like to do is visualize each class as a per week load and stack them on top of each other. That way I can find bottle necks where several classes might overlap in the final and beginning weeks leaving me with an expected work load of 30+ hours.
All and all it looks great.
BTW if you're interested, Martin Odersky and others will host a brand new Coursera class focusing on Reactive programming starting in November:
It doesn't say so explicitly in the course description, but I guess we will be using Play and Akka during assignments. If it's half as good as his introduction to Functional Programming in Scala, it will be a treat.
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! (and in a month and a half, reactive programming)
⬐ droopyEyelidsOne 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.⬐ pestaaCan you please tell me more about your experience with Haskell?
Thanks, I knew about Revel and mgo.
I just forgot to say: a FRP*  Go equivalent of Play and that there's nothing like these upcoming Coursera courses   for Go with examples.
⬐ sinkasapaI think this course looks like it could be a lot of fun. Erik Meijer is a great teacher with lots of enthusiasm. The introductory video makes it look like we just walked in on a particularly awkward moment, though, like they set the bench they're all sitting on down in a suspiciously bad smelling elevator car.
If you haven't see Erik Meijer's haskell course and are interested in that type of thing, check it out:
It uses this really great book by Graham Hutton called Programming in Haskell.⬐ jcurbo⬐ tomkuProgramming in Haskell is an excellent book, I liked it a lot more than some of the usual recommendations (Learn You a Haskell, etc).⬐ atopuzovThe course is awesome! Highly recommended.I don't think I've ever signed up for something more quickly than when I saw this announcement pop up on Twitter. Really enjoyed the Functional Programming with Scala course when it ran last year, and I'm happy to see the sequel come to fruition.⬐ 727374⬐ rybosomeThe Functional Programming class I took last year was pretty much as good as the expensive CS courses I took at Big Name U. Oh, and it happened to be taught by the guy that invented Scala. I'll admit it, I'm turning into a Coursera fanboy.⬐ nlyNote that the Functional course is a recommended prerequisite for the Reactive one and the former runs again at the beginning of September, meaning you can do both in sequence.⬐ goostavosIs there a place to download coursera videos like you can with Udacity? I'm really interested in the Scala course, but it just kind of sucks that it can only be taken during a certain time frame. I've been working my way through Programming in Scala, but the course seems like it'd be a great compliment for understanding the "functional" style of programming.
As it is now, I feel I'm simply a compiler which translates my imperative Python background into Scala syntax.⬐ mkopinskyWhile the course is running (at least for the course I'm currently enrolled in) every video has a download icon at the far right.
At times (for me), the time-based nature of coursera is a very good thing. If I know that I need to complete a homework by 1am Sunday night, which means I need to finish watching this week's videos by Thursday night, that means there's a chance I'll actually do so. Without that deadline (and with no money or grade on the line) HN or Reddit or other timewasters are far too tempting.⬐ mogrim⬐ moderskyMe too, a deadline really forces me to get down to studying, it's all too easy to let life get in the way otherwise!If you go on the course page
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.⬐ virtualwhysHuh, I don't see any archive links on that page, where are they?⬐ LrigikithumerIt 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⬐ moderskyIt 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.⬐ virtualwhysThat 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.⬐ BystanderXCount me in here. Would love access to lectures or videos.Fantastic! I've been wanting to learn FRP for quite some time. The fact that this is a follow-up to the awesome Scala course is a bonus.
I can't wait for this to begin. =)
EDIT: The syllabus doesn't mention any FRP libs. I'm surprised, especially as one of the professors is the author of RX. Maybe because there isn't a canonical one in Scala?⬐ seanmcdirmid⬐ mgraczykThey don't mention FRP. RX is a subset of FRP oriented around just event streams without continuous signals; think of it as FRP lite. Their actors and futures unit makes me wonder if this is also about concurrency in addition to reactivity. Nothing about state repair at all.
If Conal Elliott ever decides to teach a coursera on FRP...⬐ tomkuOne of the blog posts I saw announcing it had a few more details than the course page, including a mention of RxJava.In case you didn't notice, this course is being co-instructed by Erik Meijer, creator of the fantastic reactive extensions for .NET library.
I encourage anybody who has to write or maintain more than a few lines of C# or .NET code to check them out (and possibly take this class if it turns out to be good).⬐ macca321⬐ ghcIf you're into FRP in .NET, please checkout the OLINQ project on github. It lets you define LINQ queries against reactive sources and have them update themselves as the sources change, letting you do things like realtime aggregation in a couple of lines of code.
I think it's wickles.Back when Borders was still around I stumbled upon a Functional Reactive Programming book by Paul Hudak. To this day it's still one of my favorites. If you know Haskell and don't want to learn Scala, you might enjoy this as an alternative to the course. The book is called The Haskell School of Expression: Learning Functional Programming through Multimedia.⬐ thetwiceler⬐ joshzAs far as I know, Hudak has updated and renamed his book to The Haskell School of Music, and it's available for free from the Yale Haskell Group's website here: http://haskell.cs.yale.edu/?post_type=publication&p=112
The book is a really awesome way to learn Haskell. However, very little of it is actually about FRP; there's one section about GUIs using FRP, and it doesn't go very much in depth.⬐ fusiongyroPretty sure that's just a different book by the same author. "Updating" a book on graphics to make it about music instead doesn't sound like a second edition kind of maneuver.⬐ hrjet... especially true for one dealing with an "immutable" programming language
:)Typesafe also just announced a tutoring program for this and the intro course.⬐ essentialsI haven't taken Odersky's first course, but I'm fluent in Java and Clojure. Do you guys think that would suffice or will Scala knowledge be a prerequisite?⬐ eranation⬐ eranationThe prerequisite course starts in about 2 weeks , 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 ,, to get a feeling of it.⬐ arityfnIt starts in two months so could give Martins books a read. And I think that would be enough. Some of the lectures were based on his book and others on SICP.⬐ oacgnolIf you're well versed in Clojure and FP principles, the only difference for you would be in picking up Scala syntax, in my opinion.⬐ Fishkins⬐ tokipinI'd say the type system is a non-negligible difference. Still, knowing Java and Clojure is a good foundation for learning Scala.you won't have trouble. that said, the first Scala course is excellent independent of its use of Scala because of its fun/challenging homework assignmentsThis is a follow on course to Functioal Programming with Scala, and led by Martin Odersky, Erik Meijer and Roland Kuhn. Signed up⬐ arityfnThis is the most awkward introduction video Ive seen so far. I really enjoyed Erik's introductory course on haskell so really looking forward to this course.⬐ modersky⬐ jskonhovdYes, sorry for the video :-) We had just 1 hour in the same place together, and that was in a hotel conference room and we were all tired from our respective conferences. We'll shoot another one when we meet next and will replace the video then.⬐ arityfn⬐ NoneCool, I got a response from Martin Odersky. I really enjoyed your course on scala :) so looking forward to this one.NoneSigned Up!! The Functional Programming with Scala Course was very good.⬐ lelfNote: this is not about “FRP”
(if you don't believe me — http://www.reddit.com/r/haskell/comments/1l7ru2/principles_o...)⬐ pohl⬐ theboywhoThat's a good thing to point out. The "reactive programming" in the course title comes not from the acronym FRP but from this:This is awesome news. I really enjoyed the Functional Programming with Scala course and can't hide my excitement for this one.
This is also interesting to me because it shows that teaching and learning does not have to be at some big name University.⬐ ridicterCan some explain like I'm 5 the tradeoffs between Go/Scala/JS[node.js]? I've been googlin', and there aren't enough articles that compare and contrast the three.⬐ lobrien⬐ NekorosuGo is supposed to be a better C.
Scala is supposed to be a better Java.
JS is supposed to be popular.
EDIT: Go is intended to be a systems-programming language with an emphasis not only on runtime efficiency and concurrency, but additionally on such things as compilation speed.
Scala is intended to be a hybrid OO-functional language that is approachable by a broad class of mainstream programmers (i.e., Java programmers), with a type system considerably more sophisticated than Java. The emphasis is, I'd say, on a language that has long-term potential, at the cost of a somewhat problematic toolchain.
* Go: statically typed, no type parametrization, good support for CSP-like concurrency, deeply imperative language. Proponents site its speed of compilation, simplicity, and growing community.
* Scala: statically typed, modern and sophisticated type system, supports OO and functional programming, runs on the JVM, has good concurrency support.