Crisp Home

Tag Archives: Scala

Why should I care about Scala and Akka?

Posted on by Jan Grape.

Java is great and I have been doing it for years. Why should I care about things like Scala and Akka?

The short answer could be:

  • Scala is the future
  • Akka is the killer framework

Scala is a language that runs on top of the JVM with a better object orientation compared to Java and with functional programming as well. The OO part of the language is pretty easy to learn for a Java developer, but the functional stuff is trickier. Scala has a dedicated community and the language is predicted to become a really strong alternative to Java if Oracle continues to alienate the Java community. Since Scala interacts seamlessly with Java and Java almost seamlessly with Scala both languages can be mixed in the same application.

Akka is a library in Scala aimed at robust and scalable parallel programming. Instead of the old thread model with synchronization and shared memory you have actors (active objects) and messages. The actor model is present in core Scala, but Akka shows how it perhaps should have been done from the start. The founders of Scala and Akka have recently joined forces in a new company.

Since our computer hardware gets more and more cores (ability to do parallel processing) every year and The Cloud consist of an almost infinite number of boxes it is interesting with a programming model for parallel computing that really scales and is robust. That’s why Akka is interesting.

I for one, am looking forward to learning more about Scala and Akka and to using them in real commercial projects. What is the next thing you plan to learn?

 

Scala Code Kata Roman Numerals

Posted on by Hans Brattberg.

There’s a Scala User Group in Gothenburg that had several meetings during this summer.  In one of the meetings the group solved a Kata named KataRomanNumerals (A Kata is a small problem that you do over and over again to learn)

The KataRomanNumerals says you should write a function to convert from normal numbers to Roman Numerals: e.g.
     1 –> I
     10 –> X
     7 –> VII

Unfortunately I could not attend at this meeting, so I had to do it on my own during a few summer nights when my family finally was asleep :-) .

Here’s my solution:

  object Program extends Application {

    class RomanInt(number: Int) {

      def toRomanString() = {
        val ones = List("", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX");
        val tens = List("", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC");
        val hundreds = List("", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM");
        val thousands = List("", "M", "MM", "MMM");

        thousands(part(1000)) + hundreds(part(100)) + tens(part(10)) + ones(part(1))
      }

      def part(digit: Int) = {
        number % (digit * 10) / digit
      }

    }

    implicit def Int2RomanInt(number: Int) = new RomanInt(number)

    println(154.toRomanString()) // prints ‘CLVIII’

  }

Here’s the code with better formatting.

Please comment and correct if I didn’t write idomatic Scala or if you have suggestions for improvements.

/Hans

Lift 1.0 !!

Posted on by Mats Henricson.

Webbramverket Lift, skrivet i Scala, har precis släppts i version 1.0. Mycket spännande, tycker jag. Citat från Michael Galpin:

Lift is the only new framework in the last four years to offer fresh and innovative approaches to web development. It’s not just some incremental improvements over the status quo, it redefines the state of the art.

Actors Galore

Posted on by Mats Henricson.

När jag började lära mig Scala så stötte jag direkt på Actors, ett koncept snott från (om jag förstått det hela korrekt) Erlang. Actors är ett sätt att få till concurrency genom att skicka meddelanden, till skillnad från det vi alla under ett decennium svettats med i Java, trådbaserad concurrency. Tanken är att det ska vara ett lättare sätt att programmera inför den multi-core framtid vi står inför.

Att skriva om sin applikation så att den kan hålla ett par kärnor varma låter sig kanske göras, men hur ska en vanlig applikation rimligen få mer än en handfull kärnor att komma över rumstemperatur?

Så kom Kilim, och jag gjorde ett försök att skriva ett enkelt exempel, men min förståelse för hur Kilim fungerade var för ytlig för att jag skulle ro det hela iland. Jag försökte skriva om min primtalsberäknare från JavaSpaces till Kilim, men det visade sig att att ha en master och många workers inte är det gängse sättet att använda sig av actors.

Nå, för en dryg vecka sedan bloggade Sujit Pal om alla de Actors-ramverk som nu dykt upp som svampar ur jorden. Han har fungerande kodexempel för Kilim, Scala Actors, samt Jetlang, ActorFoundry och Actor’s Guild (hehe, fyndigt namn)! Har man en gång utvärderat ett bleeding edge ramverk av den här typen så inser man vilken herkulisk insats han har gjort för att utvärdera fem ramverk!!

Om man detaljstuderar exemplena så ser man en del eleganta detaljer, men också för varje ramverk en del som ger mig lite ont i magen och gör att jag slipar tänderna mot varandra med ett ohälsosamt ljud. Med lite tur sätter sig de olika programmerarna samman och gör en AOP, dvs mergar sina respektive ramverk på samma sätt som AspectWerkz (drivet av en av våra svenska superprogrammerare Jonas Bonér) och AspectJ slog sina påsar samman och skapade den industristandard som vi nu åtnjuter.

Dependency Injection i Scala

Posted on by Mats Henricson.

Jonas Bonér har bloggat om Dependency Injection i Scala. Han presenterar tre olika sätt att göra det på, och hans favorit är rätt elegant. Ingen XML, och helt statiskt typat, men det känns ändå som lite av ett hack. Att ha en trait innanför en annan trait? Hm… som lite av de hack jag såg när jag var djupt nere i C++ träsket.