7L7W – Scala Day 1


In the Book Club, we are reading 7 Languages in 7 Weeks (for more info on the book club go to Dublin Alt.Net mailing list) so far a really awesome book, Its helping me have a quick view of not only different languages, but also different programing paradigms. Which is really refreshing, but hard. The thing that I like the most about the book so far , is that you do much more than a hello world, but of course, you can learn in depth, however, the author makes a really good job of explaining what’s at the core of each language, sometimes, just trying to really grasp that is a tiny bit hard , when  it’s a paradigm you are unfamiliar with it, but the effort is well worth it.

Anyway, since I haven’t been able to the last two meet ups, I thought I’d do a second read of the Scala chapter and put together some notes. Please note I m writing the notes as I read.

– Scala is a hybrid language (a mix of OO and functional)
– Hints that its a different kind of language
– Runs on the JVM, though given the state of Java, not sure that is any kind of insurance. Scala can use Java libraries natively, just like Iron* languages , can use .net libraries directly
– Statically typed
– type inference (like c#? –> review)
– functional concepts, like c#? it would be awesome if it added some native support for immutable types
– Support immutable types, but its got some modifier ( need to check this out more in depth)
– actors

Scala is a general purpose language, interesting that it seems to fit well many scenarios because of this OO, Functional mix
Type inference seems to be not so strong
Principles of functional programming that apply to Scala:
– programs are made of functions
– functions return a value
– given the same input, a function will return the same output
– side effect free

val is immutable var not …. Likes

There is a full page on the book dedicated to somewhat clarifying strong vs weak and static vs dynamic  languages. I mostly agree with his points there.

My first impression when seeing the language was that it reminded me more to python than to java, maybe it was def .

  • Visibility of methods, functions. Public is default
  • Support for tuples and ranges . In purely functional languages, tuples are used as objects. You can do multi value assignment with tuples
  • Constructors. I like Scala’s  syntax and default
  • Object instances are interesting, at first I was thinking they were like static classes in C#, but apparently not quite. As far as I understand, an object declaration in Scala is basically a singleton instance of a class definition.  However, in C# a static class is a class that can be accessed and used, without creating an instance. That makes me think that there is a cost associated with the instantiation, but I cant see any other difference. (comments on this would be appreciated)
  • traits. Like an interface and an implementation all in one, generally focusing on a single concern, well that’s what the book say, however I can’t see here how you do to declare a trait separetly

As Part of the exercise of Day 1 you need to find a comparison between Java and Scala(I found this), one of the interesting things I learned while checking that out is that XML is supported natively, I also liked the point on moving to a more functional style of programming slowly, but with a nicer syntax.


No Responses Yet to “7L7W – Scala Day 1”

  1. Leave a Comment

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: