CSC/ECE 517 Fall 2009/wiki2 6 hl

Hybrid Programming Languages

Hybrid Programming Languages are multi-paradigm languages that not only support basic Object Oriented features but other features of different programming paradigms. Multi-paradigm languages have been around for a while (LISP 1958, C++ 1983) but recently there has been a push to develop true Multi-paradigm languages that bridge the OO/Functional Programming gap; the push has been spurred on by the advent of the multi-core CPU. Programmers can no longer expect single threaded performance to drastically improve with each new CPU release.

The hallmark of Object Oriented Programming is the abstraction of the problem into well defined classes and objects. The Functional Programming approach is more to describe the system as mathematical/logical abstractions that limit recalculation (side effects) on a given data set.

Scala

Scala or "Scalable Language" was developed by Martin Odersky of EPFL to be a both Object Oriented and Functional language at the same time. Contrary to popular belief the "Scalable" means scalable with the programmer and their skills, ie OO programmers can move to Functional programming and Functional programmers can move to OO approaches. Scala shouldn't be considered a "pure" functional language[1], it can be thought of as an pure "OO" language since every value is an object and every function is a value[2]. It is a statically typed language that is compiled into bytecode that is run on the Java VM with comparable speeds to Java.

Language Highlights

• OO and Functional
• JVM
• Concurrent (Native Threads and Actor Model)
• Compatible with existing Java Libraries
• Statically Typed
• Mixin Model
• Mutable and Immutable types
• Tuple return support

Code Example

Fibonacci Sequence (Imperative and Functional Tail Recursive)

Imperative Example[3]:

 def fib( n: Int) = {
   // initial values
   var a = 0    // inferred type: Int
   var b = 1    // inferred type: Int
   
   // function next
   // inferred result type: Pair[Int, Int]
   
   def next( a: Int, b: Int) = Pair( b, a + b) ;    
 
   var i = 0
   while( i < n) {
     
     // get result pair members by pattern matching
     val Pair( c, d) = next( a, b) ;
     
     // assign result
     a = c
     b = d
     
     //iterate
     i = i +1
   }
   // return 'a'
   a
 }

Functional Programming Tail Recursive[4]:

 def fib( n:Int) = fib_tr( n, 1, 0) 
 def fib_tr( n: Int, b: Int, a: Int): Int = n match {
   case 0 => a 
   case _ => fib_tr( n -1, a + b, b)
 }

Fan

Fan supports Object Oriented and Functional Programming paradigms. Fan and Scala are often compared and contrasted since they both run on the Java VM. Fan isn't just tied to the JVM though it also supports the .NET CLR (Common Language Run-time) and Javascript. Fan is a "loosely" typed language : method/function responses are statically typed but inner scoped variables are allowed to be dynamically typed. It's an interesting approach since a method's type contract should always be adhered to but within a method, forced typing can reduce programming efficiency.

Language Highlights

• OO and Functional
• Portable: JVM, .NET CLR and Javascript
• Mixin Model
• REST namespace
• Concurrent (Native Threads and Actor Model)
• Mutable and Immutable Types

Code Example

Fibonacci in Fan[5]

  static Float fib(Float x)
  {
    if ( x < 2.0)
      return 1.0
    else
      return (fib(x - 1.0) + fib(x - 2.0))
  }

Reia

Reia is an Object Oriented and Functional Programming that incorporates Ruby/Python-like syntax to the the Erlang BEAM VM. Reia is based upon Erlang's concurrent Actor model. Objects don't share a heap which requires communication between objects to be implemented through message passing. Unlike Erlang the Reia compiler allows for variables to be assigned multiple times with in one code block (a = 1; a = 2;).

Language Highlights

• Functional and OO
• Brings Python/Ruby syntax to the BEAM VM
• Concurrent (Actor Model)
• Objects don't share memory
• Variables can be assigned multiple times
• Hooks to access/write Erlang
• Tail Recursion

Code Example

Reia's Fibonaacci[6]

module Fibonacci
  def calc(0)
    0
  end
  def calc(1)
    1
  end
  def calc(n)
    calc(n - 1) + calc(n - 2)
  end
end

F#/OCaml

F# is the officially supported Functional Programming language for .NET with Objected Oriented features. Its a variant of the popular OCaml functional/object oriented language that was developed in 1996. OCaml itself is a variant the CAML language that added Objects, hence the name of Objective-Caml or OCaml. F# has extended OCaml by adding .NET support with improvements to the Garbage Collector (GC) that allows for Symmetric Multiprocessing (SMP) threading. OCaml's GC doesn't allow for SMP threading[7].

Language Highlights

• Functional and OO
• Improved GC
• Comparable speeds with C or C++
• Scripting language
• Allows for Immutable Types
• Concurrent (Threads, Actor Model)

Code Example

Fibonacci in F#[8]

 let fib n =
   let rec fib_aux (n, a, b) =
       match (n, a, b) with
         | (0, a, b) -> a
         | _ -> fib_aux (n - 1, a + b, a)
   fib_aux (n, 0, 1)

F# Objects and usage [9]

 type Shape() =
   abstract Perimeter : float
 type Circle(r, x: int, y: int) =
   inherit Shape()
   override self.Perimeter =
       Convert.ToDouble (2*r) * System.Math.PI
 type Rectangle(x1, y1, x2, y2) =
   inherit Shape()
   static member Square(x, y, a) = DerivedRectangle(x, y, x+a, y+a)
   override self.Perimeter =
       2*(x2-x1)+2*(y2-y1) |> Convert.ToDouble
 let d = seq { for i in 1 .. 20
             -> if i % 3 = 0 then
                     Circle (i, i, i) :> Shape
                elif i % 3 = 1 then
                     Rectangle (20, 20, 20+i*2, 20+i) :> Shape
                else
                     Rectangle.Square (20, 20, i) :> Shape } |> Drawing

Language Creation and Simularities

When analyzing the creation of modern Hybrid Programming Languages the following criteria should be looked at:

• Base Paradigm - Language Genesis
• Expressiveness - How verbose must the programmer be
• Concurrency - How hard is it to get performance
• Portability - Where can I run the program

Base Paradigm

When the Hybrid Languages are created typically one paradigm is the base and the other paradigms are folded in. Scala and Fan used the OO paradigm as their base and removed Java's primitive types; Functions are values which are handled as Object methods/values. Reia and F# approach the problem from the Functional Paradigm and move towards OO as a data abstraction. With the exclusion of F#, each of the languages core behaviors can be tied back to the VMs that they are running on (F# is excluded since it is part of the .NET framework).

Scala and Fan primarily use the Java VM which has certain limitations and features. The JVM instruction set only supports statically typed objects with the exception of some allowances for dynamic classes and methods[10] (ie Fan's inner scoping can be dynamic). The Reia sits on top of the Erlang BEAM VM which doesn't support lightweight threads; which is why only the Actor model is supported for concurrency.

Expressiveness

All of the above languages have Functional Programming components that allow for compact and succinct methods/functions to be created. One of the benefits of implementing some code in functions is that the user can condense the code down to the math. (See Scala Fibonacci example). The degree of Functional Programming is dependent on language implementation. Scala, F#, and Reia support tail recursion; while Fan doesn't. Pure Functional Programming languages feature tail recursion.

Concurrency

To get the best performance out of modern multicore CPUs the language must address how multiple threads, processes should be run and handled by the language/VM.

All of the discussed languages allow for concurrency to be achieved via the Actor Model. The Actor Model is a form of message passing where each process/object communicates with each other via messages and the Actors don't share state (memory addresses). Other languages (C/C++/Fortran) have similar models via Message Passing Interface (MPI) packages.

F#, Fan and Scala support concurrency via threads as well. Reia doesn't support threads since the BEAM VM doesn't. When thread support is incorporated it is import to allow for immutable types so that side effect free programming can safely be achieved. If immutable data types are not used then thread synchronization is important to prevent one thread from affecting another threads memory space.

Portability

As the definition of the Personal Computer becomes broader a language's portability becomes more important. Reia is bound to the Erlang BEAM VM which is bound to traditional PCs/Servers. F# is compatible with the .NET CLR which opens it up to PCs/Servers and the G1 Android via Mono[11]. Scala and Fan are supported via the JVM which is on 4.5 billion devices[12]. Fan also supports Javascript and .NET implementations which allows for it to be extremely portable.

References

1. http://enfranchisedmind.com/blog/posts/scala-not-functional
2. http://www.scala-lang.org/node/2
3. http://en.literateprograms.org/Fibonacci_numbers_%28Scala%29
4. http://en.literateprograms.org/Fibonacci_numbers_%28Scala%29
5. http://www.fandev.org/sidewalk/topic/193
6. http://github.com/tarcieri/reia/blob/master/examples/fibonacci.re
7. http://caml.inria.fr/pub/ml-archives/caml-list/2002/11/64c14acb90cb14bedb2cacb73338fb15.en.html
8. http://mbishop.esoteriq.org/weblog/?p=7
9. http://www.devx.com/enterprise/Article/39223
10. http://en.wikipedia.org/wiki/JVM#Support_for_dynamic_languages
11. http://tirania.org/blog/archive/2009/Feb-16.html
12. http://en.wikipedia.org/wiki/Java_Virtual_Machine

External Links

Reia Homepage - http://wiki.reia-lang.org/wiki/Reia_Programming_Language
F# Research Page - http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/about.aspx
Scala Homepage - http://www.scala-lang.org/
Fan Homepage - http://www.fandev.org/
Scala Article - http://www.infoq.com/news/Scala--combing-the-best-of-Ruby-
Reia Blog - http://www.unlimitednovelty.com/
Scala Concurrent Programming - http://blog.objectmentor.com/articles/2008/08/14/the-seductions-of-scala-part-iii-concurrent-programming
Dr. Dobb's Article on Fan - http://www.ddj.com/architect/218600690
F# Concurrent Programming Article - http://strangelights.com/blog/archive/2007/09/29/1597.aspx
F# Working with Objects - http://www.devx.com/enterprise/Article/39223
F# Inheritance - http://msdn.microsoft.com/en-us/library/dd233225%28VS.100%29.aspx