#9 overallClassic
Functional Programming Principles in Scala
Coursera
42 recommenders · 41 threads · recommended in 12 years, 2012–2026 · score 60.3
Martin Odersky's introductory MOOC on functional programming using Scala, covering recursion, higher-order functions, immutable data, pattern matching, and collections. It is based largely on SICP-style exercises and includes automatically graded programming assignments.
Commenters call it an excellent, well-taught introduction to functional programming, praising Odersky as a lecturer and the course's automated grader and assignments.
Programming Languagesbeginnerfreemiuminteractive MOOC#scala#functional programming#odersky#recursion#coursera
Recommendations by year
20062026
It sucks for Pluralsight employees that were affected by this. Though I think that the company couldn't wait 2-3 weeks before announcing also sucks, at least make it over Christmas.
Pluralsight is one of a few companies in the "education" business that I don't really have high hopes for in general. Pluralsight, Lynda / Linkedinlearn, Udemy, etc. They either target enterprise companies as a way to "skill up" and save money on training. Or they sell to aspirational individuals. But the main problem is that the overall quality is really really low, borderline useless. I haven't seen a site with this model that does better than just buy a book and practice. I think most sites could be beaten by finding good videos on youtube.
I do like Coursera's model, namely because you can come away with a certificate or degree, and the average quality is way higher. Functional Programming by Martin Odersky on Cousera was one of the best online courses I've taken.
I would highly recommend learning FP fundamentals in another language, not Javascript.
For example, there is an excellent introductory FP course on Coursera by Martin Odersky ("Functional Programming Principles in Scala"). It happens to be based on the Scala language syntax, but most of what you learn there will be directly applicable in other FP languages too. For me, taking this course was a game changer ~10 years ago. Highly recommended.
Once you understand the basics, picking up stuff like "arrow functions" (lambdas) will be just a matter of adjusting to the JS syntax.
I've watched some of the lectures of CS50 in the past, and the one question that has always come into my mind is this: "How do these lectures help you learn at a deep level?" I already knew most of the material, so I found it to be an entertaining review, but that's different from a beginner needing to learn new material at a deep level. I kind of think it'd be a nightmare to take good notes while watching his lectures. I'm not bashing the lecture style, but if I were a student, I'd prefer a good textbook to those lectures.
In contrast, I watched all the lectures of Martin Odersky's functional programming MOOC. I learned a ton from that even when I'd already seen the material. His presentations were lower tech, with less razzle-dazzle, but my goal was to learn. His presentations are optimized (intentionally or not) to facilitate good note taking and later application.
It depends a bit what specific stacks you are interested in. Pluralsight and Lynda's "all you can eat" monthly subscriptions are probably the best since they just have more classes all around. Lynda by and far has the most classes available. They have more tech classes than Pluralsight, but they also have classes in many unrelated categories as well. The flip side; I think Pluralsight holds content authors to a higher standard. Once Pluralsight was heavily focuses on .NET, but they've branched out a lot more.
Coursera has some good stuff and it's free if you don't care about the cert. Their Functional Programming in Scala class is excellent.
My preference is Java 8 because I find the Scala tooling to be so-so. I really don't like sbt. I find Java 8 to be "good enough."
If you do like Scala, I recommend Martin Odersky's Coursera class. I took it a few years ago and it was great! Really fun and I learned a lot. He is a great lecturer.
One way that Scala does win big is supporting a repl style of development. One great example of this is the Spark repl.
If you live in the JVM world, Clojure (which I use more than any other programming language) and JRuby are also worth a good look.
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.
Coming from CS and computational math background, I used mostly C++ for production and Python for prototyping and data analysis. I wanted to learn some new language for JVM, Clojure and Scala being the main (if not the only) contenders. I may learn Clojure anyway, but what tipped the scale to learning Scala first was wonderful Coursera course in functional programming by Martin Odersky, using Scala as a language, obviously.
A very short summary of my impressions from Scala: * It is beautiful, I felt the half-forgotten beauty of functional programming once again
* Scala worksheets (quick scratch to evaluate whole code snippets with immediate feedback) are awesome. I love them even more than REPL (Then again, I love IPython notebook more than Python REPL too)
* Scala seems a bit heavy in terms of number of concepts
* Scala can be terse and very expressive, but pretty verbose if you need it to be
* Compilation of large programs is slow and eats gobs of memory
* tail-call optimize everything
I'm taking Coursera's Introduction to Functional Programming with Scala and Machine Learning classes and Udacity's Intro to Parallel Programming class. All out of interest.
I really recommend Machine Learning, this is my second time taking it (taking as a refresh). It really gives a good introduction on how to predict or classify data.
If you want something more practical, Introduction to Functional Programming with Scala is really informative, teaches you Scala and gives you another perspective on how to make functions and classes. It's definitely a great course for recursion lovers.
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.
If anyone wants an introduction to functional programming using Scala, I really recommend Martin Odersky's coursera course (https://class.coursera.org/progfun-2012-001/class). He restricts you to functional Scala; there isn't a mutated variable in the whole course. It isn't officially a course right now. You won't get a certificate for taking it, and I don't think the grader is turned on, but the other materials are still there.
In my mind, the really mind altering thing was seeing not just that Object Oriented and Functional programming styles could be compatible, but that they were in many ways complementary. Good OO design, particularly the idea of small single responsibility classes, is kind of enforced by functional style. If you need to pass around fifty variables just to increment a counter, you'd go crazy. So writing functionally forces you to figure out ways to split things up. Similarly, its easy to convert well small, single responsibility OO objects into functional ones, and just a nightmare otherwise.
I was just blown away at how much a course on functional programming helped me to understand OO design.
The Odersky Scala course was pretty cool. It gave me a basic understanding of monoids and monads that has stuck with me. Robert Sedgewick's courses were very good. Learned a lot about graphs.
I took the Functional Programming Principles in Scala class on Coursera and it was excellent! It's taught by Martin Odersky who is the creator of the language, and had lots of very effective short exercises which let you apply the concepts he teaches in the class.
https://www.coursera.org/specializations/scala
If anyone is interested in learning FP and how to think about it, I personally recommend three resources:
1. Martin Odersky's "Functional Programming Principles in Scala" MOOC on Coursera. Do not focus on the Scala part (5-10% of the course is about Scala).
2. The Little Schemer book. Among the best programming books U have ever read in my life. It actually teaches you how to think recursively. It actually does that.
3. Graham Hutton's Haskell book and YouTube playlist.
I feel this one. I really liked the ambition and ideas of Scala, and after I took Odersky's own Scala course, I was all charged up to use it. But so many things about it end up being a giant pain in the ass that it just wasn't worth it to me for general-purpose coding.
If you haven’t done any functional programming I can recommend this course:
https://www.coursera.org/learn/progfun1
The techniques you learn there will transfer to javascript and make you a better web developer.
I took Martin’s Scala class years ago and it was awesome. He is a great lecturer.
okay, f# has curly braces. but not in the sense of other C-like languages like c++, java, and c#. they are primarily used for sequence expressions and computation expressions like async.
well that first sentence is simply not true, and i don't know what gave you that impression. f#'s repl, f# interactive, is available on linux through mono and will soon be available through .net core. i can't help you being needlessly allergic to a major operating system or company. f# came out of microsoft research.
they do? take:
def test(x): "something"
so what does
test(2)
return?
i don't know why you're upset. i am not for sure where i was discourteous. i didn't mean anything by my statement other than to check out the languages and courses (the coursera one is very good). if those are your reasons for python, i just thought you would honestly like an ML-based language. i just used "owe it to yourself" as an expression, which apparently came out wrong through text. of course you don't owe anyone anything. i was just making a suggestion.
The Odersky's course is phenomenal. Highly recommended and it shows how much attention and craftmanship was put into designing Scala. Bonus: Martin speaks like Arnold and it's very enjoyable to have a "Terminator" voice teaching you complicated material.
I have completed several courses earlier for free and have one paid (Functional Programming in Scala) this year. The experience has met my expectations. The forums were not as active as in the early days, but the participants were discussing and some TA were posting too. Of course, it is mostly self study but I was not expecting a lot of live mentoring for 79 USD per course. I do plan to take more courses on Coursera as well.
atleast go through initial 4 chapters. then go through the coursera lecture of Odersky. Though SICP is lisp, the structure is very similar to scala.
I would recommend the stairway book and the coursera course. I would also steer away from the some of the other recommendations posted here, including "Functional Programming in Scala", which are basically teaching you how to write Haskell in Scala. I don't think this is a good way to learn Scala because I don't think Haskell-style code makes for effective Scala.
Take a functional programming class. Martin Odersky on Coursera now has a while track. It's Scale. If that matters. Functional programming is the blood-brain barrier between programming and math with lots of activity bringing the two closer. It may not be directly useful in Machine Learning type of math, but it's a strong foundation for parallel programming and multi-core programming due to the statelessness of pure functions. Good luck!
Why specifically YouTube? Are you looking to learn a new language? If yes then check out the Scala coursera courses.
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/...
To put it simple - Scala puts together the best parts of Standard ML (functional programming - so one could reason about code as a form of calculus, plus pattern matching on type-constructors with destructuring, partial application, etc) Smalltalk (everything is an object and objects communicate via messages passing by calling methods - the original concept of "pure OO" by Alan Kay and the best part of Smalltalk implementation) plus foundation ideas from Erlang (an Actor and messaging DSL based on high-order procedures and some syntactic sugar). Together it is already worth switching, especially afrer realizing what a crap Java is compared to this conscise and well-researched mix of complementing each other features). Scala is also famous for its emphasis on immutable collections, which makes GC less painful.
Scala initially is a product of a single remarkably well-trained mind, instead of committee of mediocrity.
Clojure, BTW, was a solo remake of Scala's approach (Java interloop, emphasis on collections, immutability, etc) while starting from Common Lisp (strong, dynamic typing) instead of Standard ML (strong, static) as its basis.
Actually, the Scala course on Coursera is very good start.
Depends on the class. There's a series of excellent Coursera Scala courses taught by the creator of the language, those will stay on my resume for a while.
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.
I would definitely recommend Martin's Coursera course, it's incredibly well structured and very well delivered, with enough difficulty to be challenging but it guides you through very gently. Well worth it for learning both Scala and Functional Programming.
Usually we have programmers take the Odersky coursera course. [1]
1: https://www.coursera.org/course/progfun
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.
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/
The Scala course fits a common template for Coursera - by which I mean that a meaningful fraction of Coursera courses have similar features, but not all Coursera courses.
That template: A course taught by the person who 'wrote the book', in this Odersky teaching Scala. Others on Coursera: Ullman/Automata, Wetherall/Networking, and Sedgewick/Algorithms. The great thing about these courses is that the instructors know what is important and what isn't and therefore the courses don't get bogged down stuffing every detail into the lectures or reflecting every detail in the homework assignments. The big ideas are the big ideas.
There are also courses taught by mid-career professors - e.g. not fully tenured. These tend to be pretty good, but there is an undercurrent that the course assignments must defend their employer's brand by being hard just to be hard. These also tend to be quality courses, though there seems to be more variation.
The last group are those taught by newer academics and these vary more widely in quality. They tend to take a less general approach as there can be the feeling that 'making a name for oneself' in a publish or perish world is part of the motivation. If the instructor's interest closely aligns with the course and the student's interests, then it can be really good. If not, then there's the 'unenroll' button.
I took the second edition of Grossman's course and it was very good. Kickzales's Introduction to Program Design was also good as was Pascal Van Hentenryck's Discrete Optimization - his enthusiasm is infectious.
Odersky himself is teaching Functional Programming in Scala later this month, and I'm looking forward to that.
Strange ... I felt the same feeling of sadness and it was only amplified by the last video where he spends half the time thanking us for taking the class.
How do I even express my gratitude?
This was my second Coursera class - I started with Martin Odersky's Introduction to Functional Programming in Scala (which I also highly recommend).
If anybody really wants to learn Scala, I'd recommend starting with the video lectures on Coursera for the course Functional Programming in Scala.
Allow me to suggest Coursera. They have nice courses about FP. Somehow in simple -> difficult order.
Systematic Program Design by Gregor Kicsalez (I believe influenced by HtDP). Programming Languages by Dan Grossman. (50 50 HtDP SICP and Brown University material)* Functional Programming using Scala by Martin Odersky (influenced by SICP).
In case you can already do the SICP exercises without issues then you won't need these, but otherwise, the deadlines and automatic grader were great ways to keep a regular pace in learning.
*) this course focuses on semantics, and language design, the problems are not hard applied problem solving, that's why I put it in 2nd, but they can twist your mind quite a bit when dealing with different meta-levels.
Also, _Functional Programming Principles in Scala_ course on Coursera by Martin Odersky (Scala's designer) is very good.
https://www.coursera.org/course/progfun
I'm injecting my own language bias here, and I must admit that this is not an opinion that everyone agrees with, but I think you're better with Scala or Clojure than with Java. (Both run on the JVM, so you end up learning the Java ecosystem.)
Scala is a "better Java" and you can learn both the JVM and functional programming (take Odersky's course on Coursera). Clojure is a great Lisp but the Java stuff will be very confusing if you haven't seen it before (the JVM-interop functions like proxy, gen-class, and reify don't have the easiest APIs).
This (Structure and Interpretation of Computer Programs) is a great book to get started on the deeper aspects of CS: http://mitpress.mit.edu/sicp/full-text/book/book.html
Also, I like this one: http://www.amazon.com/Concepts-Techniques-Models-Computer-Pr...
Bingo.
The only things I'd like from Coursera courses are:
* more that take 8-10 weeks rather than 6 weeks
* if the CS course happens to use a particular language then make it incredibly easy to get setup and provide downloadable structure for any assignments (the scala coursera course has that nailed)
* better estimates for # hours a week
In general thought the synchronous approach works perfectly for me and is the big reason I haven't yet felt the need to do any Udacity courses.
Not a great example because actually you can't override simple assignment but that aside, I was disputing that Scala had more features. It doesn't. I've acknowledged that the features it does have are more powerful and could be abused.
The fact that operators are methods and can be overridden simplifies things - you no longer need to know and remember operators. They are always methods on the type you are looking at. This is what I mean by more regular and fewer surprises, the footprint is smaller.
So you can use this simpler, more powerful feature to create DSLs. They are compile checked and are "real Scala". The tools autoamtically help you. Of course, DSLs exist in Java but they often involve tools like JTB and JavaCC, extra compilation steps, no compiler assistance for users - I could go on. Which is more complex?
Anyway, I agree you could abuse the more powerful language features to write hard to comprehend code. However if you take a look at Scala code in the wild, you will see that these concerns so far have been largely theoretical and of course you can also write incomprehensible junk in Java or any other language should you wish.
I'd encourage people to try the Coursera Scala course which is running again soon, and see for yourself.
The quality of the courses I have followed was excellent:
Coursera:Cryptography I - Dan Boneh
Coursera:Functional Programming Principles in Scala - Martin Odersky
Coursera:Compilers Alex Aiken
class2go.stanford.edu Introduction to Databases Jennifer Widom
+1 for the 'functional programming in Scala' mention. Really awesome and fun class to take.
Lecture are available here: https://class.coursera.org/progfun-2012-001/class/index
If you're coming from Java, I recommend the Scala for Java Refugees[1] series of blog posts. If you're interested more in the functional side, there is a course by Odersky on Coursera right now.
I haven't found any Scala IDEs stable or enjoyable yet. I've been using [insert favorite editor] with sbt[2].
[1] http://www.codecommit.com/blog/scala/roundup-scala-for-java-...
[2] https://github.com/harrah/xsbt/wiki
Honestly forget Rentacoder you won't make any real money at it and the projects are all mostly junk software anyway. Also its hard to get started there without already having reputation. Much better to work on your own side project - either open source or your own business. Even if your project never makes money you've at least got something you are more passionate about and to talk about in your interviews other than cleaning houses.
edit to add: one more idea maybe take some free online classes like from Uber or Coursera? I think this is a great idea for anyone actually I just started the Coursera Scala class myself and having more fun programming than I had in a long time. This is not so much for resume builder as it is more to clear out the cobwebs and get you thinking like a programmer again.
This would be so good if it were available off of Coursera, which is essentially a shake-down for certificate fees at this point. Nand2Tetris is a fantastic course.
Back in its heyday 3 years ago, I did a ton of courses on Coursera. They weren't perfect, of course. There was no higher-level coordination that could lead to covering an entire 4-year degree's worth of material and it was hard to match up courses from different institutions with different prereqs. It was hard to find advanced courses in general and the enforced speed at which content was expected to be completed sucked.
But the automated graders were great. I went through parts of many, many courses before having to abandon them due to work pressures and I finished a few, like the scala course and the fantastic automata course and some stuff from Berkeley before they bailed and moved to edX. It wasn't ideal for adult independent learners, but Coursera used to provide real value, especially for introducing niche topics that wouldn't be available via OCW.
It's a pity they never figured out a business model that would fit what its learners really wanted and just threw up a paywall instead.
Being a Java/JVM expert, I wanted to add a couple of thoughts to your process. I'm not insinuating that you should change anything you've done!
- Dropping JBoss Seam as a framework was a good choice because the important parts of Seam have been added to the JavaEE system, which provides an end-to-end set of technology specifications. If you choose to run a Java Application Server (such as JBoss EAP, Glassfish or Wildfly), then the server will support the full set of specifications, but you don't have to use them. Since JavaServer Faces (JSF) is one of those specification, I'm not really surprised you hadn't heard of it ... it's essentially JSP with lifecycle control and data-binding.
- GWT is indeed a Java technology, but it produces client-side code. For big projects, I generally use GWT with Bootstrap to generate the client. It compiles into Javascript producing several versions optimized for different browser groups. Using Martin Fowler's Passive View pattern, it's easy to write fast tests for your client-side business logic, and since it's typesafe, you get compiler errors before the compilation to Javascript instead of the run-time errors you often see when writing in Javascript (or Coffeescript). Since I generally write the back-end for a generic JavaEE server, I also tend to use REST calls from GWT to an Application Server for client-server communication.
- If you're looking for an ORM, none of the Java frameworks will include one directly, but it should be pluggable. When people talk about Java web frameworks, they're often constrained to just the "View" tier. Spring provides a much more full-featured stack (with DI and JPA) and is more analogous to JavaEE as a whole. I think you should consider those two as the full-stack contenders in Java. You can add GWT onto either if you need a client-side Java technology (I'm sure you'd NEVER use Java Applets for the client side right?).
- I happen to like Scala and appreciate how purely it seems to add a syntax to Lambda calculus. Martin Odersky's "Principles of Functional Programming in Scala" on Coursera was a great class, but I'm hoping the Scala IDE advances quickly. I'll admit I've never written production software in Scala (or using WAVE) but I also admire one project that's using it successfully (https://github.com/takezoe/gitbucket).
These days a lot of folks take the HTML route into programming. They start by fiddling with web pages, then add CSS, some Javascript and then building backend stuff. But this is a risky route to take. You might end up being just good enough to make a few bucks at it, pick up some PHP or Ruby on Rails, and drive yourself straight into a dead end.
None of this is really programming. Sure there is a bit of going through the motions, but you have all these frameworks supporting you, whether HTML or Rails or whatever, and you fail to get to the heart of the matter.
Far better to get a book like SICP (now freely downloadable) install one of the free Scheme packages out there and struggle through writing all of the code for all of the exercises in that book. It will be tought. You will suffer. And at the end you won't have much to show for it; i.e. no pretty websites. But you will have trained your mind to think the way programmers need to think. And you will also have learned to persist in the face of disappointment and failure because that is what programming is really all about.
Of course, there are more marketable languages like C# and Java and it is definitely worth while to work through exercises from a good book in a similar manner, but you won't get as good an education as someone who pushes through SICP. Those of us who learned programming in an imperative language like Java, are now either in a stagnant rut adding features to big balls of mud that hang like chains around the neck of our employer or else we are slowly pushing our way along the path blazed by SICP.
If you already know a bit of programming in any language, you could also take Functional Programming in Scala followed by Reactive Programming at Coursera. They run these courses a couple of times a year and they are good. SICP is recommended reading for this course even though the language is completely different. True programming is all about mathematics and using it to solve problems in a simple way. You need to understand functions, sets, boolean logic, lambda calculus, algebra, category theory in order to truly excel. Mathematics is something that you build inside your head and something that you can apply to any programming language or platform.
By the way, most CS degrees do not teach this. If you find a school that DOES teach this, then by all means, get the degree if you can afford it. But too many schools leave the real stuff for the Masters and Doctorate level folks. If you self-learn, like I did, then you can do better. But you better be prepared to work real hard because most of the time there is no course to keep you on track. Learn every day without fail and you will get there.
Unfortunately, it depends on what sort of job you're going for, and I would be surprised if there wasn't regional differences too. Plus some people have negative preconceptions about the sort of person that would go through SICP (happily, they are exactly the sorts of people you don't want to work for). If you're looking to join a larger company or looking to enter the job market in the next 12 months or so, then probably experimenting with more frameworks and getting some code up would be better bang for your time. Even better if you have contributed to existing OSS projects.
But for your own general longer term career development, SICP is a very good bet. But SICP wasn't really designed for home study so it will be hard going. Personally, I would be very impressed if an interviewee made it halfway through SICP by themselves. I have tried multiple times and never got very far before .. er ... reprioritising.
If you want to learn more functional programming, I highly recommend learning Haskell with Learn you a Haskell (http://learnyouahaskell.com/). This is a much easier start to functional programming and get you productive quickly. Haskell will force you to really learn functional programming as there isn't an easy imperative backdoor (not to say you can't write imperative code in Haskell - see (http://www.haskellforall.com/2013/05/program-imperatively-us...) for example, just its not particular easy how to get there). My current project is writing a web app in Haskell and its a very interesting experience.
If you want to learn functional programming, but still be attractive for jobs, then I would recommend learning Scala ideally with the 'Functional Programming in Scala' coursera course and then working through Odersky's "Programming in Scala" book. Scala is a JVM language so it can interoperate easily with Java code, and I've seen companies in London using knowledge of Scala as a signal of a good quality Java developer. It is also (successfully in my view) a multi-paradigm language which can be used both as a functional language, and as an imperative one without feeling too much like a compromise on either side. Though in my view, its harder to learn functional programming properly when you have an "easy out" back into the imperative world.
Also, check out communities you can join such as (http://lambda-the-ultimate.org/) or Haskell Cafe or local Meetups with others interested in functional programming.
Good luck.
I don't think this is a good guide for Learning Scala.
The Introduction from scala-lang.org and a Tour of Scala are not good introductions. They are meant as a TL;DR that will leave you scratching your head and reading the list of features without the larger context of a language is an awful way to learn about that language.
IntelliJ IDEA with the Scala plugin is a good IDE, but the article should have included a link to the Scala-IDE plugin for Eclipse. It's not friendly for beginners to make them install a plugin, which is why Typesafe is already providing a download of a completely configured Eclipse here: http://typesafe.com/stack/scala_ide_download
Also, when starting out with a language I would rather use a plain text editor and the compiler directly, because complicated tools bring with them complicated problems ... Hello World with just the compiler is just one text file that you can directly execute, versus the notion of whatever a project is in an IDE. And you should start with the REPL anyway.
"Scala for Java Refugees" is an article series that's out of date and not that good frankly. There already is a comment here from somebody saying he was scared when he saw in that series the usage of implicit conversions - a feature that in Scala 2.10 is considered experimental, for really advanced use-cases and that has to be enabled manually, as for most purposes there are better solutions available - but on the other hand, the context of a feature matters a lot. Implicit conversions are great for dealing with the "expression problem" and through their means, Arrays (a fundamental JVM data-structure with a broken interface) behave like plain Seqs in Scala, while Strings are considered to be lists of chars (as in Haskell or Lisp).
I didn't like Alex Payne's "Programming Scala" book. It's boring, it's poorly organized and it's out of date - for instance a big part of it involves dealing with Scala's Actors, but Scala's Actors were terrible, which is why in Scala 2.10 the implementation in the standard library gets replaced with Akka, which is the defacto standard anyways, but it also has a slightly different API and concepts. Actors are also the kind of powerful construct that's not easy to tame, being an awful way to start learning Scala ... before Akka Actors, look into Scala's Parallel collections, or into Akka's Futures and Promises or into ScalaSTM.
Speaking of Parallel Collections and Futures and Promises, no mention of Scala's Documentation project?
http://docs.scala-lang.org/overviews/
A much better introduction to the language is "Scala for the Impatient", a book that wasn't mentioned and one third of the book (enough to get you started) is available from Typesafe's website: http://blog.typesafe.com/free-pdf-from-typesafe-scala-for-th...
You also cannot write about learning resource, without mentioning "Programming in Scala" by Odersky, a wonderful book also meant for human beings. Its only problem is that it's a tome of information and you may not have the patience for that, but it's not a hard to digest book so if you've got the time and patience, then this is THE book you should read: http://www.artima.com/shop/programming_in_scala_2ed
And you must also mention "Scala in Depth" by Joshua Suereth, which is like the equivalent of "Effective Java", a ~ 300-pages book you definitely must read once you're done with "Scala for the Impatient": http://www.manning.com/suereth/
On the other hand the Coursera Course taught by Odersky on Function Programming is awesome. I've took it and it was worth every minute of it.