Taking score

First, I should have spent more time on practicing Scala, as I haven’t actually finished anything in the end. It is probably an excuse, but after using Python for such a long time, getting used to a compiled language with its own weird path-, naming- and import conventions, was just a little bit too much. Mostly I was reading the Pragmatic Bookshelf: Programming Scala, practicing the examples within. That book uses Scala 2.7.x and the current version is 2.9.0.1, so there are a few things that work differently and I ended up having strange error messages with little to no clue how to fix them (mostly imports, and some method signatures must have changed as well). So it was a limited but exciting success.

All in all, I liked the language even if I don’t have a clear usage case for it in my mind (just yet). Some bullet-points of my experience:

Good

• Different way of thinking about “batch” operations (i.e. foldLeft)
• Once I figure out the Actors that well that I can write related code without referring to the tutorials, that’s going to be a very powerful tool
• Pattern matching, pattern matching everything. This is one thing that blown my mind in the little Haskell I checked so far, and missing from Python a lot.
• Flexibility with class definitions, they can handle so many different situations in a very logical and powerful way

Bad

• Length of compilation and program start. Will have to get used to it, though I read some hints that this can be improved.

Ugly

• Pretty frequent need of using things directly from Java, so one is never quite independent
• Special methods that have reserved name for certain functionality (act, apply, …) that are non-obvious, and not easily distinguished from the arbitrarily defined methods.

Future

Definitely will come back to it and learn it in more detail. It looks like a fine language to do parts of larger projects in. In the meantime I will update the link collection in the previous post with new links that I find. I certainly notice more and more Scala posts on Hacker News these days.

The post Language of the Month: Scala, part 3 appeared first on ClickedyClick.

Start

I tried to find a couple of starting points to start to know about Scala. First thought video tutorials or talks would be useful, so been around checking on YouTube. It seems the mainly referenced intro is Scala: a scalable language. Well, it told me a lot about how Scala compares to other languages and how is it better than those, but not much to start learning it. Though the talk made it sound like it is one of the best and most modern languages out there, taking the most useful ideas from loads of other languages.

Had a copy of the Pragmatic programmer: Programming Scala, and just finished going through it. By that I mean that skimmed all the chapters and did try some of the code samples that looked interesting or strange. Not bad, but from the book I just have a very limited answer to the question of: “but what is it really great for?” Concurrency, sure, but that is probably not all.

I don’t know a language before I code enough in it, but before I know it I don’t have to much inspiration what to code. In this case, programming puzzle sites come very handy, though not all of them support Scala. I went to Coderloop because they do and I can submit my solution for performance testing, or could use Project Euler because they are language agnostic (one sends the results only).

Experience

Since Scala is built upon the Java Virtual Machine and supports pretty much all of Java, it feels a little Frankenstein language: every now and then, even for some things that should be quite commonly used, things have to be programmed in Java. Lots of language features are cool, though, even if most of it feels just syntactic sugar. In a way, maybe the whole language is just that? It’s not bad, makes things very concise and powerful, but always feels there’s something more in the background.

Actors and concurrency are pretty cool, though. In the talks I’ve seen people compared them to Erlang, just even more powerful. This is something more to play around with, would like to make something interesting, scalable and fault-tolerant – those are the fun stuff aren’t they? (But this also makes me want to try Erlang soon so I can compare).

Since I was doing mostly Python lately, it feels a bit weird to use a compiled language. For simple programs, it takes quite a long time to do that compilation, enough to wind me up a little when I was troubleshooting. That said, maybe I’m doing a little bit too much “programming by accident“, so I deserve it? Also, starting a Scala program takes a while as well, though once it is up and running, it’s pretty fast.

At this point, I’m not totally sure yet what project to make until the end of the month. I need more programming itches to scratch. The only ideas I came up so far are self-playing games with actors. Or some server/provider. Well, just keep brainstorming, something better has to come up. Maybe when I dive a little bit more into it, since at the moment I cannot really “think Scala” yet.

There’s also a web framework for it, called Lift, which is probably not surprising. The close connection wit Java (and hence with so many of enterprise software) and event based, fault tolerant concurrency is just too juicy. Not sure if anyone’s hosing it, tough (got to check out), either way I can just try it on my local network. I wonder how does it compare to Django, since that’s what I have a bit of experience with.

Links

Information

• Scala language reference
• Programming in Scala
• Programming Scala
• Scala by Example (PDF)
• Hidden features of Scala

Example sources

• Scala source repo, now on Github
• Google Code – Scala tag
• Github – Scala tag
• SourceForge – Scala Tag
• Google Summer of Code Scala projects

Companies using Scala

• Typesafe, a new company launched by Scala’s creator
• Linkedin part 1, part 2
• Foursquare

Others writing about Scala

• The Static Language that Feels Dynamic

(Last updated: 2011 June 23)

The post Language of the month: Scala, part 2 appeared first on ClickedyClick.

I was watching the Programming Paradigms lecture series from Stanford. I quite enjoy it, mostly because Jerry Cain seems to be a good lecturer. A quick check confirms that others feel that too. I haven’t finished it yet (24 lectures in to the 27 long series, each ~50 minutes), he talked a lot about C, then Scheme, now about Python. He also mentioned a couple of other languages he suggest for the students to try. That got me thinking: I love languages (human and programming as well) and always looking out to learn more things. Why not do some more exploration in this area – trying out languages that are quite different from each other and see what can I take home from each. I did have similar idea last year, “Language of the Week”, but one week is just too little to get to any practical depth in a language and that idea died. Now, I’m hoping to resurrect it in the form of “Language of the Month”. It is conveniently the beginning of a month so I can just start right now. :) Also, let’s make it round – a 12 language series, one for each month until the same time next year. That should be a challenge. So I made a 12 item list for planning:

• Haskell
• Erlang
• Lua
• Smalltalk
• Prolog
• Lisp / Scheme
• OCaml
• Forth
• Go
• Scala
• ?
• ?

Many of these I was planning to check out for a long time and now I have proper motivation. Some of them I got intrigued about while I was checking this humbling list. Note, that “?” are not weird languages, but I keep things open to add more as I get more experience with this (you too can give me recommendation in the comments!:). Also note the absence of some languages, like C and Ruby: those I really should know more, that’s why I won’t do them here, they have enough intrinsic motivation, here I want to try somewhat more off-the-path things.

The simple rule for this series is: every month choose one new language and by the end of the month implement something practical in that language. Something that scratches a real life programming itch. Other than this, all bets are off. See what I can learn.

Now the hard part: which one to start with, since the above list is rather a “set” – ordering is not included. I did roll a dice, but didn’t like the result (like most rolls of dice:), so let’s just choose one: The Language of the Month for May is Scala (because I know absolutely nothing about that, unlike some of the others).

Let the coding begin…

The post Language of the Month: Scala appeared first on ClickedyClick.