Changes for page WebObjects with Scala

Summary

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

Details

Page properties

Content

...	...	@@ -1,55 +1,232 @@
1	1	=== What is Scala? ===
2	2
3	3	Scala is a modern language not unlike Groovy.
4		-It is said to be more powerful (and faster) than Groovy or Rails which has been the reason for its adoption at sites like Twitter.
	4	+It is said to be more powerful (and faster) than Groovy or Ruby which has been the reason for its adoption at sites like Twitter.
5	5
6		-|= |= Objective-C |= Java |= Scala
7		-|= Mutable/Immuable Datatypes |Collections (e.g: //NSArray/NSMutableArray//) | No | //All datatypes//
8		-|= Closures | (//extensions//) | No | //Built-in//
9		-|= Static variables | Yes | Yes | No
10		-|= Static methods/functions | Yes | Yes | No
11		-|= Concurrency | Grand Central Dispatch (//extensions//) | //Threads// | Actors
	6	+Many of its features and paradigms favor multi-threading and concurrency. Some of these may not be unfamiliar to Objective-C and WebObjects developers. Here's a summary:
12	12
	8	+|= |= Objective-C |= Java |= Scala
	9	+|= Mutable/Immuable Datatypes | Collections //e.g: NSArray/NSMutableArray// | No | Yes
	10	+|= Closures | Blocks (//Extension//) | No | Anonymous Functions
	11	+|= Static variables | Yes | Yes | No
	12	+|= Static methods/functions | Yes | Yes | No
	13	+|= Concurrency | [[Grand Central Dispatch>>http://en.wikipedia.org/wiki/Grand_Central_Dispatch]] (//Extension//)| //Threads// |[[Actors>>http://en.wikipedia.org/wiki/Actor_model]]
	14	+|= |= Weakly Typed |=--Strongly Typed--|= Strongly Typed
	15	+
	16	+Other notable features include:
	17	+
	18	+|= |= Objective-C |= Java |= Scala
	19	+|= Parametered methods | Yes //e.g: addObject: to~:// | No | Yes //e.g: add(object= ,to=)//
	20	+|= Class composition | Categories | Interfaces | Traits
	21	+
	22	+A fuller description of Scala can be found [[here>>http://en.wikipedia.org/wiki/Scala_(programming_language)]].
	23	+
13	13	=== Why Use Scala? ===
14	14
15	15	With Web 2.0, building concurrent WebObjects applications is a must.
16	16	Developing and maintaining a concurrent or multi-threaded WebObjects application can be challenging.
17	17
18		-Scala offers concurrency built into the language.
19		-So it may offer new solutions to allowing concurrency in WebObjects.
	29	+Scala offers concurrency that is (effectively) built-in to the language and is inherently thread-safe.
	30	+In other words, developing Ajax (i.e asynchronous communication) with WO will require concurrent request handling and thread-safe code, for which Scala is a better choice than Java.
20	20
21		-=== Can WebObjects be Programmed With Scala? ===
	32	+In addition it may offer new solutions for concurrency in WebObjects and EOF.
22	22
	34	+=== Can WebObjects be Programmed In Scala? ===
	35	+
23	23	Yes. It is very simple.
24	24	Scala compiles to java bytecode. Hence using it with WebObjects is fairly straightforward.
25	25
26		-== How to Develop WebObjects With Scala ==
	39	+= WebObjects In Scala =
27	27
28		-1. [[Install the Scala eclipse IDE>>http://www.scala-lang.org/node/94]]
29		-1. Add Scala support to your project
30		-11. Right-click your project in the WO Explorer
31		-11. In the context menu select Scala -> Add Scala Nature
32		-1. Convert or use ##.scala## instead of ##.java## source
	41	+The following highlights some of the differences between Java and Scala in WebObjects:
33	33
	43	+== EOs in Scala ==
	44	+
	45	+=== Thread-Safe Shared Vars ===
	46	+
	47	+Scala doesn't have static variables or methods. However, a class can have a //Companion Object// that will allow you to achieve something equivalent to static variables.
	48	+One of the advantages of this approach is that it is **thread-safe**, so you don't have to worry about synchronizing access to these fields in a concurrent application.
	49	+
	50	+The following is an example of the use of a //Companion Object// for Talent in Scala instead of Talent static fields in Java.
	51	+
	52	+Java:
	53	+
	54	+{{code}}
	55	+
	56	+public class _Talent extends EOGenericRecord {
	57	+ public static final String ENTITY_NAME = "Talent";
	58	+
	59	+{{/code}}
	60	+
	61	+Scala:
	62	+
	63	+{{code}}
	64	+
	65	+object Talent extends EOGenericRecord {
	66	+ val ENTITY_NAME = "Talent"
	67	+
	68	+{{/code}}
	69	+
	70	+==== Compacted imports ====
	71	+
	72	+Two lines in Java are compacted into one in Scala.
	73	+
	74	+In Java:
	75	+
	76	+{{code}}
	77	+
	78	+import com.webobjects.eocontrol.EOGenericRecord;
	79	+import com.webobjects.eocontrol.EORelationshipManipulation;
	80	+
	81	+{{/code}}
	82	+
	83	+In Scala:
	84	+
	85	+{{code}}
	86	+
	87	+import com.webobjects.eocontrol.{EOGenericRecord, EORelationshipManipulation}
	88	+
	89	+{{/code}}
	90	+
	91	+== WOComponents in Scala ==
	92	+
	93	+==== Compact Constructors ====
	94	+
	95	+Scala allows for simpler use of multi-valued constructors than Java.
	96	+
	97	+In Java:
	98	+
	99	+{{code}}
	100	+
	101	+public class MenuHeader extends WOComponent {
	102	+
	103	+ public MenuHeader(WOContext aContext) {
	104	+ super(aContext);
	105	+ }
	106	+
	107	+{{/code}}
	108	+
	109	+In Scala:
	110	+
	111	+{{code}}
	112	+
	113	+class MenuHeader(context: WOContext) extends WOComponent(context: WOContext) {
	114	+
	115	+{{/code}}
	116	+
	117	+==== Simplified Exception Handling ====
	118	+
	119	+Scala doesn't force you to catch exceptions unlike in Java.
	120	+In addition, the syntax employs Scala's very powerful pattern matching to handle different exceptions.
	121	+
	122	+In Java:
	123	+
	124	+{{code}}
	125	+
	126	+try {
	127	+ EditPageInterface epi = D2W.factory().editPageForNewObjectWithEntityNamed(_manipulatedEntityName, session());
	128	+ epi.setNextPage(context().page());
	129	+ nextPage = (WOComponent) epi;
	130	+} catch (IllegalArgumentException e) {
	131	+ ErrorPageInterface epf = D2W.factory().errorPage(session());
	132	+ epf.setMessage(e.toString());
	133	+ epf.setNextPage(context().page());
	134	+ nextPage = (WOComponent) epf;
	135	+}
	136	+
	137	+{{/code}}
	138	+
	139	+In Scala:
	140	+
	141	+{{code}}
	142	+
	143	+try {
	144	+ var epi: EditPageInterface = D2W.factory.editPageForNewObjectWithEntityNamed(_manipulatedEntityName, session)
	145	+ epi.setNextPage(context.page)
	146	+ nextPage = epi.asInstanceOf[WOComponent]
	147	+} catch {
	148	+ case e: IllegalArgumentException => {
	149	+ var epf: ErrorPageInterface = D2W.factory.errorPage(session)
	150	+ epf.setMessage(e.toString)
	151	+ epf.setNextPage(context.page)
	152	+ nextPage = epf.asInstanceOf[WOComponent]
	153	+ }
	154	+}
	155	+
	156	+{{/code}}
	157	+
	158	+==== Scala Annotations vs. Generic Accessors ====
	159	+
	160	+An example of accessing variables in WebObjects with the following languages:
	161	+
	162	+|= |= Objective-C |= Java |= Scala
	163	+|= getter | ##object name## | ##object.name()## | ##object.name##
	164	+|= setter | ##object setName:aName## | ##object.setName(aName)## | ##object.name = aName##
	165	+
	166	+Of course in Java, we may generate WebObjects classes with "get" methods as well in order to stick to convention.
	167	+In scala there is an additional convenience we may use to produce "get" and "set" methods in addition to the default Scala accessors - Scala Annotations.
	168	+
	169	+E.g, in Main.scala we annotate our component keys with ##@BeanProperty## to automatically create public "set" and "get" methods.
	170	+These variables can then be accessed via //KVC//.
	171	+
	172	+{{code}}
	173	+
	174	+@BeanProperty var username = new String()
	175	+@BeanProperty var password = new String()
	176	+@BeanProperty var isAssistantCheckboxVisible = false
	177	+
	178	+{{/code}}
	179	+
	180	+== How to Use Scala Collections with EOF ==
	181	+
	182	+One of the benefits of Scala is its very powerful, concurrency-ready collection classes - primarily ##List##, ##Map##, ##Seq## and ##Set##.
	183	+Employing these instead of ##NSArray## and ##NSDictionary## in WebObjects/EOF may be challenging.
	184	+
	185	+But one may modify the EO templates to produce API such as:
	186	+
	187	+{{code}}
	188	+
	189	+def movies: NSArray[EOGenericRecord] = {
	190	+ storedValueForKey(_Studio.Keys.MOVIES).asInstanceOf[NSArray[EOGenericRecord]]
	191	+}
	192	+
	193	+def moviesList: List[EOGenericRecord] = {
	194	+ movies.objects.toList
	195	+}
	196	+
	197	+{{/code}}
	198	+
	199	+== How to Add Scala to a WO Project ==
	200	+
	201	+{{include value="WOL:Adding Scala Support to a WOLips Project"}}{{/include}}
	202	+
34	34	{{note title="Note"}}
35	35
36		-This is for Eclipse/WOLips developers
	205	+This is for Eclipse/WOLips IDE
37	37
38	38	{{/note}}
39	39
40	40	== WO Scala Example ==
41	41
42		-The following is a mixed Java/Scala version of the WO Movies D2W app.
	211	+The following example is an almost 100% Scala WO app. In reality it is a mixed Java/Scala app:
43	43	All the EO logic and WO components are in Scala.
44	44	Only the Application class is Java.
45	45
	215	+It is based on the D2W Movies example.
	216	+
46	46	{{attachments patterns=".*zip"}}{{/attachments}}
47	47
48	48	=== Setup ===
49	49
50		-1. Install and run the OpenBase OBMovies database.
	221	+1. [[Install the Scala eclipse IDE>>http://www.scala-lang.org/node/94]]
	222	+1. Install and start the OpenBase OBMovies database.
51	51	1. Right-click on Application.java and run as a WOApplication (as usual).
52	52
53	53	==== EO Templates ====
54	54
55		-See: [[Scala templates>>http://wiki.objectstyle.org/confluence/display/WOL/EOGenerator+Templates+and+Additions]]
	227	+When you create your ##.eogen## file, be sure to make the following changes in the EOGenerator Editor:
	228	+
	229	+1. Point to the local [[Scala versions>>http://wiki.objectstyle.org/confluence/display/WOL/EOGenerator+Templates+and+Additions]] of the .eotemplate files for ##Entity## and ##//Entity//##
	230	+1. Change the File Names Extension to "scala"
	231	+1. In Destination Paths set the Superclass Package (e.g: base)
	232	+1. Uncheck Java under Options