Changes for page WebObjects with Scala

Last modified by Ravi Mendis on 2011/05/10 02:10

From 509.1 to 508.1 From 514.1 to 513.1

From version 513.1

edited by Ravi Mendis
on 2010/08/12 03:17

Change comment: Bump section header

To version 509.1

edited by Ravi Mendis
on 2010/12/24 01:42

Change comment: There is no comment for this version

Raw
Rendered

Summary

Page properties (1 modified, 0 added, 0 removed)

Details

Page properties

Content

@@ -1,19 +1,15 @@
  === What is Scala? ===
--[[Scala>>http://en.wikipedia.org/wiki/Scala_(programming_language)]] is a language for concurrent computing.
--In this day and age of multi-core processors, concurrent computing can't be ignored.
++[[Scala>>http://www.scala-lang.org/]] is a modern, multi-paradigm JVM language that is most often compared to [[Groovy>>http://en.wikipedia.org/wiki/Groovy_(programming_language)]], [[Clojure>>http://en.wikipedia.org/wiki/Clojure]] or [[Erlang>>http://en.wikipedia.org/wiki/Erlang_(programming_language)]]. Its [[functional language>>http://en.wikipedia.org/wiki/Functional_programming]] foundations and built-in [[Actors>>http://en.wikipedia.org/wiki/Actor_model]] library make it especially attractive for concurrent computing. (Scala is an abbreviation for "scalable" hinting at its design goals). In this day and age of multi-core processors concurrent computing can not be ignored.
--Many of Scala's features have been designed with concurrency in mind.
--Some of these may not be unfamiliar to Objective-C or WebObjects developers.
++Many of the design features of Scala have been chosen with concurrency in mind, some of which may not be unfamiliar to Objective-C or WebObjects developers. Here's a summary:
--Here's a quick summary:
--
  |= |= Objective-C |= Java |= Scala
--|= Separation of Mutable & Immuable Datatypes | Collections //e.g: NSArray/NSMutableArray// | No | Yes
--|= Closures | Blocks (//Extension//) | No | Anonymous Functions
++|= Immutability | Partial - via collections //e.g: NSArray/NSMutableArray// | No | Yes
++|= Closures | Yes - via Blocks (//Extension//) | No | Yes - via Anonymous Functions
  |= Static variables | Yes | Yes | No
--|= Static methods or functions | Yes | Yes | No
--|= Concurrency | [[Grand Central Dispatch>>http://en.wikipedia.org/wiki/Grand_Central_Dispatch]] (//Extension//) | //Threads// | [[Actors>>http://en.wikipedia.org/wiki/Actor_model]]
++|= Static methods | Yes | Yes | No
++|= Concurrency | Yes - via&nbsp;[[Grand Central Dispatch>>http://en.wikipedia.org/wiki/Grand_Central_Dispatch]] (//Extension//) | //Yes - via Threads// | Yes - via&nbsp;[[Actors>>http://en.wikipedia.org/wiki/Actor_model]]
  |= |= Weakly Typed |= --Strongly Typed-- |= Strongly Typed
  Other notable features include:
@@ -20,20 +20,23 @@
  |= |= Objective-C |= Java |= Scala
  |= Parametered methods | Yes //e.g: addObject: to~:// | No | Yes //e.g: add(object= ,to=)//
--|= Class composition | Categories | Interfaces | Traits
++|= Class composition | Yes - via Categories | Yes - via Interfaces | Yes - via [[Traits>>http://en.wikipedia.org/wiki/Trait_(computer_science)]]
  === Why Use Scala? ===
--Scala is inherently thread-safe.
--It has concurrency that is effectively built-in to the language.
++For WebObjects developers, Scala offers itself as a powerful, safe and easy-to-use solution for [[concurrent computing>>Building Concurrent Applications with WebObjects and Scala]]. (In other words, Scala Actors can be used for problems that would have normally required threads).
--So for WebObjects developers, Scala offers itself as a powerful, safe and easy-to-use solution for [[concurrent applications>>Building Concurrent Applications with WebObjects and Scala]]. (In other words, Scala Actors can be used for problems that would have normally required threads).
--
  === Can WebObjects be Programmed In Scala? ===
  Yes. It is very simple.
--Scala compiles to java bytecode. Hence using it with WebObjects is fairly straightforward.
++By virtue of being a JVM-language, Scala compiles to java bytecode.
++Furthermore, being a multi-paradigm language grants Scala easy WebObjects-interoperability.
++
++===== Caveats =====
++
++Legacy tool support is often cited as a weak point. The [[Eclipse Scala plugin>>http://www.scala-ide.org]] has been found to be slow at times and sometimes buggy.
++
  = WebObjects In Scala =
  The following highlights some of the differences between Java and Scala in WebObjects:
@@ -44,7 +44,8 @@
  Scala doesn't have static variables or methods. Instead Scala employs the [[Singleton Pattern>>http://en.wikipedia.org/wiki/Singleton_pattern]] which is built into the language and is **thread-safe**: a class can have a //Companion Object// that will allow you to achieve something equivalent to static variables - but better.
--So you don't have to worry about synchronizing access to shared mutable fields in a concurrent application.
++You don't have to worry about synchronizing access to shared mutable fields in a concurrent application.
++(This is not however true when for example you have a ##val## declared as a ##NSMutableArray##. You will still have to synchronize when adding to or removing from this mutable field).
  The following is an example of the use of a //Companion Object// for Talent in Scala instead of Talent static fields in Java.
@@ -61,7 +61,7 @@
  {{code}}
--object Talent extends EOGenericRecord {
++object Talent {
  	val ENTITY_NAME = "Talent"
  {{/code}}
@@ -76,8 +76,6 @@
  ==== Compacted imports ====
--Two lines in Java are compacted into one in Scala.
--
  In Java:
  {{code value="java"}}
@@ -188,42 +188,25 @@
  == How to Use Scala Collections with EOF ==
--One of the benefits of Scala is its very powerful, concurrency-ready collection classes - primarily ##List##, ##Map## and ##Set##.
--Employing these instead of ##NSArray## and ##NSDictionary## in WebObjects/EOF may be challenging.
++To use the Scala Collections API with an NSArray or NSDictionary you simply need to add an import:
--But one may modify the EO templates to produce API such as:
++{{code value="java"}}
--{{code}}
--
  import scala.collection.JavaConversions._
--def movies = {
--    storedValueForKey(_Studio.Keys.MOVIES).asInstanceOf[NSArray[Movie]]
--}
--
--def moviesList = {
--    movies.asInstanceOf[java.lang.Iterable[Movie]].toList
--}
--
  {{/code}}
--This employs a feature of Scala known as **implicit conversions** to automagically convert a NSArray (a Java Iterable) into a Scala Iterable.
++After that, you may access the typical Scala collection methods directly on NSArray. &nbsp;This employs a feature of Scala known as&nbsp;implicit conversions&nbsp;to automagically cast a NSArray (a Java Iterable) into a Scala Iterable while leaving the actual object unchanged.
--== How to Add Scala to a WO Project ==
++== How to Add Scala to a WO Project (in Eclipse) ==
  {{include value="WOL:Adding Scala Support to a WOLips Project"}}{{/include}}
--{{note}}
--
--This is for Eclipse/WOLips IDE
--
--{{/note}}
--
  == WO Scala Example ==
  The following example is an almost 100% Scala WO app. In reality it is a mixed Java/Scala app:
  All the EO logic and WO components are in Scala.
--Only the Application class is Java.
++Only the Application class remains Java.
  It is based on the D2W Movies example.
@@ -234,6 +234,12 @@
 . [[Install the Scala eclipse IDE>>http://www.scala-ide.org/]]
 . Right-click on Application.java and run as a WOApplication (as usual).
++{{note}}
++
++Application can be made into a Scala class as well, but then you will have to create a launcher in Eclipse manually.
++
++{{/note}}
++
  == EO Templates ==
  When you create your ##.eogen## file, be sure to make the following changes in the EOGenerator Editor:

Changes for page WebObjects with Scala

Summary

Details

Applications

Navigation

My Recent Modifications

Need help?