Clojure

Clojure is a dynmanic programming language which run on the JVM.  It is also a functional language which offers nice tools for concurrency handling. Since it doesn't give you the imperative fallback like scala it can be hard certain times to express a problem as your used to it. It is also a LISP which means it is essentially build upon a few primitives.

Counting lines in a file


(ns tokenize
(:import (java.io BufferedReader FileReader)))

;# This is a comment?
(defn process-file [file-name line-function counter]
(println " starting from imperative "
 (with-open [rdr (BufferedReader. (FileReader. file-name))]
  (reduce line-function counter (line-seq rdr) ))))

 (defn process-line [acc line]
  (+ acc 1))

(process-file "../../<filepath>" process-line 0)

Simple sum

(defn mysum [base arg1]
 (+ base arg1))

(println " works "(mysum (mysum 1 2) 4))
(time (dotimes [i 5] (println "woha!")))

line counting shorter


(ns tokenize
(:import (java.io BufferedReader FileReader)))
  (defn process-file [file-name]
   (with-open [rdr (BufferedReader. (FileReader. file-name))]
   (doseq [line (line-seq rdr)] (println line))))
(process-file "<filepath>")

Hello Clojure

(println "Hello, world!" (.. System (getProperties) (get "os.name")))

Since Clojure is a functional language and don't offer imperative constructs like loops it takes a bit to get used to but it is definitely  worth a first look. Evaluation concerning how it works out, building bigger systems and what performance issue possibly arise is of course a matter of further investigaion.

functional vs. imperative

Today I came across this post[1]. It discusses about readability, comparing functional and imperative code snippets. I think its quite hard to tell which reads better because it depends on you think it should work. I guess this shows how important code style guides are when it comes to big scala code basis, involving possibly many different team members.


[1]http://www.drmaciver.com/2008/08/functional-code-not-equal-good-code/

Scala functions

Scala offers so many different concepts that it sometimes can be quite overwhelming. Scala blends object orientated and functional programming. The very basic block of functional programming is of course a function. Now a functions seem similar to a method but a function in scala can be a value. Today I found another usefull resource from the blogsphere[1]. The essential points discussed:

• the apply method
• Closures
• Partial Functions
• apply (ied) in many places

[1]http://creativekarma.com/ee.php/weblog/comments/scala_function_objects_from_a_java_perspective/

ECF Team Editor

Today I found[1] out about a very nice tool for cooperative programming. It is based on eclipse and I used the following to get started:

• eclipse 3.5
• ECF 3.0 through update
• google mail account
• open communications perspective
• login with google mail 
• add contact
• project with same: name, package and files
• share workspace to collaboration
• host: share editor with

This enables two computers running eclipse to share a common code editor. It even offers simultaneously coding in the same file! That's pretty amazing. I don't know exactly how this could be used in a professional environment but for a quick hack session this seems ideal.

[1]http://live.eclipse.org/node/543
Some further references on the topic:
http://wiki.eclipse.org/DocShare_Plugin
skype provider
skype provider documentation

more on Scala

What is interesting about Scala that it offers a lot of powerful features.

Context Operations
Since Methods can be used in infix notation and you can use symbols as method names (like *,/,+,-) , it is important to view them always in context or to be specific in scope of the current code.

Many of those features derive from functional programming. Which seems a vast space to explore. But for now I may start with closures.


No Statics
Scala is in fact more OO than Java, it removes statics completely and introduces another construct the 'Object'. By defining an object in scala you define an single instance module or singleton, which can be referred to without using an constructor.


Closures and Functional Programming
So I stumbled about this blog post[1].  While it only started with the title Closures, it offers quite more than just that. The post discusses concepts which define algebraic structures, e.g.: associativity. The MyClass example seems simple and compelling. In quite a different manner (than so far for me) the author describes functional programming and how it can be useful. I really like that. Functional programming is a broad topic and this particular spot on helped me to get started.

Some more advanced topics from functional programming would include topics like: Monads, Applicative, Arrows and Zipper. Some useful links:

[1]http://aabs.wordpress.com/2008/05/29/functional-programming-lessons-from-high-school-arithmetic/
[2]http://debasishg.blogspot.com/2008/03/monads-another-way-to-abstract.html
[3]http://james-iry.blogspot.com/2007/09/monads-are-elephants-part-1.html

A closer look at Scala

So I have been reading more about Scala recently and it has been interesting reads so far.  As I consider myself a "Java-Refugee" I  was surprised to find this [1]. Scala surely has some different concepts some of them I want to write down here.

Methods
A few examples of method declarations:

//this method does nothingdef firstName() = {
 var back:String ="empty"
}

//this method doesn't do eitherdef firstName() = {
 var back:String ="empty"
 back = "still nothing"
}

//finally return the back variable
def firstName() = {
 var back:String ="empty"
 back
}

//declare the return type explicitly 
def firstName():String = {
 var back:String ="empty"
 back 
}

Note here in the last example that the last statement in the method is returned. It is also possible to use "return back" instead of just "back". The second example fails to return a value because the last line contains an assignment.
If you wanted to override a method in a subclass you have to declare it explicit via the override modifier.


Closures

Lastly a short example of Closures (=>), which offer a very nice alternative to anonymous inner classes in java:

val arr = Array(1, 2, 3, 4, 5)
val sum = arr.reduceRight((a:Int, b:Int) => a + b)


println(sum)

So reduceRight is a method which takes two values as parametes from the array(arr) and awaits a result originating from an operation involving these two parameters. So simply in this case, our result value sum will contain a sum over all elements of the value arr. 


Statics in Scala
There is no static keyword in Scala. Instead the concept of a Singleton is applied through the object keyword. If a class and an object have the same name the latter is described as companion object. 
Pattern matching
Pattern matching seems at a very first glance related to the switch statement in java, but there are so many differences and it turn out to be much more useful.   
Java:

int number= ..
String res="";

  switch (number) {
   case 1: res="ONE"; break;
   case 2: res="TWO"; break;
   case 3: res="THREE";  break;
   default: res=" i don't know";
 }

Scala:


val number=..
val res=""


res = i match{
   case 1 => "ONE"

   case 2 => "TWO"

   case 3 => "THREE"

   case _ => " i don't know"

}


Scala's case statement can't fall through, you don't have to use a break statement like in Java. The pattern matching is not restricted to primitives (int in java) you may use any type or object. 
Case classes
Note here that the underscore "_" has different meanings, so it should be used carefully and depending on the context in its.
Some Random thoughts pending:


Exceptions
Scala does not have the concept of checked exceptions. While this makes method declarations cleaner (IMHO), you have to take care of it either way. Since pattern matching works on types you can do nice things like this:


try {
..
} catch {
case e:SQLException => println(”Database error”)
case e:MalformedURLException => println(”Bad URL”)
case e:_ => println(”any other Error”)
}
Traits
Traits provide a mix-in mechanism which is similar to multiple inheritance but avoids some pitfalls like the diamond problem through a linearization mechanism. But still traits seem like a heavy topic since you have to think about initialization order. What I really like about traits is that you can attach or mix-in traits dynamically into an class:
trait funny { def saySome() = "hoho"}
class silent{}


val s= new silent() with funny
s.saySome //prints "hoho"


So you can put in Code in existing classes with extending them. I find this very interesting.
Left random Notes:

• class names don't have to match filenames
• While in Java you have only interfaces and classes in Scala you have 3 basic entities: classes, traits and objects
• the constructor concept seems a little awkward since you write it directly in the class definition
• imports can be scoped, this is pretty nice e.g. if you want to limit an important to an inner method 

[1] http://www.codecommit.com/blog/scala/roundup-scala-for-java-refugees

First Steps in scala

Today I just met Scala. Scala is a programming language which runs on the JVM.
A first glance on the syntax via "Hello world":


object HelloWorld extends Application {
  println("Hello, world!")
}


object HelloWorld {
  def main(args: Array[String]) =
  println("Hello, world!")
}