Tip:
Highlight text to annotate it
X
This concludes the course. Thank you for making it through to the
end. I hope you had fun following it.
There's, of course, much more to be said and to be learned.
I will leave you with a quick overview of what we covered.
I'll point out some topics that might be interesting for a future course.
And, I will also give you some links to get further material, and to stay in
touch. So, over the last seven weeks we have
explored the traits of functional programming and then brought it in the
Scala language. The most important ones of these include
the use of high-order functions everywhere, the use pattern matching and
case classes, The absence of mutability,
So no mutable state, And immutable collections is the workhorse
of most algorithms, And finally, the flexible play with
evaluation strategies. You've seen strict, lazy and by name
evaluation, including a method to reason about evaluations using the substitution
model. I hope you've experienced that as a
coherent set of notations and methods, that's a useful toolkit for you and your
daily programming practice. And that's also a different way of
thinking about programs. But if you want to find some more material
on Scala, there's a wealth of stuff out there.
There's actually, we've a Scala Ref Card or a cheatsheet that's been produced by a
student in this course. Thank you [inaudible].
So, We are going to put that up on the site.
Here's his initial version that appeared in a discussion thread.
And it gives a very useful summary of, the course contents.
For a slightly different outlook, you could also go to Twitter and their Scala
School. So they use that to teach Scala to
essentially all the new programmers who have to use Scala,
Twitter. It's a fairly concise, but also
comprehensive tour through most of the core concepts of Scala.
And also, a lot of practical matters like how to build it, how to test it, how to
interoperate with Java, how to use Twitter's core concurrency libraries that
are written in Scala and so on. If you prefer a book, then I believe the
standard reference book for Scala is the book I cowrote, Programming in Scala." It
appeared at Artima. There's a link to the free first edition
from the resources page of this course and there's also a discount coupon for the
second edition. Or if you want something shorter there's
the Scala tour in the Scala documentation that gives you a quick overview of all the
core concepts of Scala. If you want to stay current in Scala, then
one good idea is to just join a meetup. There are 85 groups of Scala users out in
the world. The largest ones has over a 1,000 users,
that's a New York group and it might to fun to spend some evening with other Scala
enthusiasts, and to exchange ideas and tricks.
Another thing you could do is go to the typesafe.com site, and follow the blog
there, which contains a lot of cutting edge material on, Scala and also the
middleware built on it, which is akka and play! or you could also subscribe to the
newsletter and get news, by e-mail. Finally, another interesting blog is the
one put together by Cake Solutions, which gives you a weekly update of everything
that's new in the land of Scala. So, it was quite a tour what we did over
the last seven weeks and I believe that you have learned a lot about functional
programming, But there's also a lot that still remains
to be covered. I see several topics that I would really
love to cover in another course that didn't have space in this one.
The first one would be functional programming and state.
So, so far, we've explored functional programming in its pure form.
There wasn't a single assignable variable anywhere.
In actual programs out there and most of them, there would be some state portions.
So the question poses itself, what does it mean to mix functions in mutable state?
And what changes if we add mutable state to functional programming?
Does anything break? Do we have to be careful with some things?
What exactly is it that would change and what that would be different?
The next topic that's also fascinating is parallel execution.
I've argued in the introduction of this course that functional programming is
relevant, because it makes parallel execution easy.
We didn't have the time to go into that. We didn't write parallel functional
programs. That's something reserved for another
course. And funnily there's the topic of domain
specific languages. You've already seen that Scala let's you
write very high-level libraries that really model the user's domain from the
user's stand point rather than exposing many implementation details.
If you push that further, you would arrive at, through domain-specific languages that
could be expressed as libraries in Scala as a host language.
Another angle on the problem is to write your domain-specific language not as an
embedded library, but as a standalone language.
And then, you would be interested to read and evaluate programs written in that
language. The programming class I teach at EPFL
covers these three topics in a separate seven week module.
If there's enough interest, I hope to be able to present these topics in another
online class at some point in the future.