Posts in the “scala” category

Yesterday I shared a simple first example of using ShadajL’s NeuroSky MindWave Scala library. Today I’m taking that a little further to share some code for a simple brainwave data recorder.

The premise is this: You put on a MindWave headset, start the recorder, and then do whatever you want to do -- work, meditate, sleep, whatever -- and the recorder records your brainwaves while you do those things. It writes the data in a CSV format so you can graph it, or do anything else you want with it.

When you upgrade a Play Framework application from one version to another, such as from 2.1.x to 2.2.x, you have to update a few files. I’m currently upgrading an app from 2.1.x to 2.2.x, and had to change my project/build.properties file to this:

sbt.version=0.13.1

I also had to upgrade my project/plugins.sbt file to this:

As a quick note, import statements that used to be like this with Akka 2.0:

import akka.dispatch.Await
import akka.dispatch.Future
import akka.util.duration._

are now like this with Akka 2.1 and Scala 2.10.x:

import scala.concurrent.{Await, Future}
import scala.concurrent.duration._

The Duration object in Akka 2.0 has also been moved, and it’s now included with the scala.concurrent.duration._ import statement.

Scala FAQ: How can I dynamically generate XML from my Scala source code, such as creating output for a SOAP web service?

Solution

A great feature of Scala’s XML support is that you can interweave XML and regular Scala source code together. This lets you dynamically generate XML from your Scala code.

To create XML with dynamic, embedded data, just put your Scala code in curly braces inside the XML tags, as shown in the following example:

If you want to write “async” Play Framework controller methods, I hope the following example code will help you get started. I’ll offer it here without much description today, other than to say that the list and add methods are written to work asynchronously by invoking Action.async and using a Scala Future:

Update: July 2, 2013. At the end of this article I made a list of some of the most important points that Mr. Johnson made during his keynote. See the “Excellent points” section at the end of the post.

@SpringRod’s Scala Days keynote presentation is controversial, to say the least. See the red arrow in this image:

There’s a nice Scala Set tip in the book, Functional Programming Patterns in Scala and Clojure. The tip is this:

You can use a Scala Set as a predicate to a function.

Note that a predicate is just a function that returns a Boolean value.

At the moment it’s not easy to find instructions on how to log output to a file using Grizzled-SLF4J in a Scala application, so I’m taking a few moments to show how this is done.

Grizzled-SLF4J dependencies

First, assuming that you’re using SBT, your build.sbt file should look like this:

Problem: You want to add Java-style logging to your Scala application, and you’re comfortable with the Java SLF4J library.

Solution

Assuming you’re using SBT, include the necessary SLF4J dependencies in your build.sbt file:

I’m sorry that I haven’t written publicly about Scala recently, but Scala Days in Berlin launched today with 1,000 developers in attendance. Follow the Scala Days Twitter account for information, including tweets like “The first version of the Dotty compiler is about 2x faster than the current version,” and “There’s no agreement on what's ‘best’ so all we can do is to find a local optimum,” which I assume is a statement Martin Odersky made during his keynote address.

This is a quick example of how to use the geolocation web service at http://www.hostip.info/use.html using Scala:

/**
 * an example of how to use the geolocation web service at
 * http://www.hostip.info/use.html
 * using scala
 */
object GetRestContent extends App {

  val url = "http://api.hostip.info/get_json.php?ip=12.215.42.19"
  val result = scala.io.Source.fromURL(url).mkString
  println(result)

}

I don't show how to handle the JSON string in this example, but if you search this website you'll find other Scala JSON examples.

The classic book, Programming in Scala, states that you need to be careful about using var fields when defining equals methods. They specifically state:

Pitfall #3: Defining equals in terms of mutable fields.

Personally, I think I've always defined equals methods with mutable fields, at least in Java. They share the following source code example that demonstrates a problem when defining an equals method in a Scala class when used in a collection.

As a quick note, to use the Scala Swing library (scala.swing.*) with an SBT project, all I had to do today was add this line to my SBT build.sbt file:

libraryDependencies += "org.scala-lang" % "scala-swing" % "2.10+"

Once I did that, I was able to compile the Scala Swing project normally with the sbt compile command.

Here’s the Scala source code for an Akka Actor I use in an application where I convert PDF pages to plain text:

This is some test code I wrote. It shows how to read a text file in Scala.

This first program shows how to read the entire file into memory and print out the “byte values” of each byte/character in the file:

As a quick note today, the following Scala function is more or less the same as the Unix cat command:

Here's a snippet of Scala code I use to get a list of all files beneath a given directory:

As a quick note, I was just reminded that when you have a Scala tuple instance, you can assign the tuple fields to Scala values. This tends to be more readable than accessing the tuple elements using the underscore syntax.

For example, if you have a Scala function like this that returns a tuple:

def getUserInfo = {
    // do some stuff here, then return a tuple (a Tuple3 in this case)
    ("Al", 42, 200.0)
}

you can assign the tuple fields to Scala val fields like this:

When I get away from programming for a little while I often write some example code to get my brain warmed up again. So last night I was reading the Real World Haskell book and came across this myDrop example, which is an implementation of a Haskell drop function:

Scala FAQ: What does the use of three questions marks (???) in Scala mean?

The syntax of using three question marks in Scala lets you write a not-yet implemented method, like this:

def createWorldPeace = ???

The methods you define can also take input parameters and specify a return type, like this: