George,

This sounds like a very exciting plan! It will be a great addition to 
Tuscany.

I have a couple of questions:

1) Are you thinking the SDO/Ruby implementation is based on SDO/Java for 
JRuby or SDO/C++ for a native environment, or something else? 
2) What features of SDO are you looking for? Is ChangeSummary used to 
drive the state transition of the REST interaction?

Thanks,
Frank


From: George Willis <[EMAIL PROTECTED]>
Date: Feb 20, 2007 5:56 PM 
Subject: Fw: JSDO for FLEX/OpenLaszlo to RoR linkage
To: [email protected]

I'ld like to open "SDO Ruby" development.  See below.


----- Forwarded Message ----
From: George Willis <[EMAIL PROTECTED]>
To: [EMAIL PROTECTED]
Cc: [EMAIL PROTECTED]
Sent: Tuesday, February 20, 2007 3:12:53 PM
Subject: Fw: JSDO for FLEX/OpenLaszlo to RoR linkage


David,

This is really a step beyond ActiveResource, where RESTful actions are 
consumed and abstracted into a multi-tiered intelligent cache, that 
updates via "push/pull" techniques. 

Imagine a world where the DOM in an RCI Browser client is actually an 
intelligent cache that is synced to a business server model.  Unbeknown to 
the RCI client, the business server does not have have any persistence, 
but is itself another intelligent cache that coordinates the various RCI 
client concurrency, and acts as an intelligent cache client backended by 
another server that provides "data mediation" to S3.  All the 
synchronization happens ubiquitously, and RESTful client can also access 
the "model".  This is my dream of JSDO for Rails -- an RCI technology to 
allow RCI developers to work with "datasets" (DOM), and for the 
synchronization of concurrency issues to be accomplished via an SDO 
pattern using javascript and Rails. 

This may be the most important email you'll read today -- if you actually 
read it :)

George Willis, ex-Fortune 500 J2EE architect turned sane
(208) 340-8246

P.S.  See the Apache Tuscany project 


----- Forwarded Message ----
From: George Willis <[EMAIL PROTECTED]>
To: [EMAIL PROTECTED] 
Cc: Sue Liu <[EMAIL PROTECTED]>; [email protected]
Sent: Friday, February 16, 2007 1:06:22 PM
Subject: JSDO for FLEX to RoR linkage 


I've looked at the various "RESTful" ways of interfacing FLEX/OpenLaszlo 
with RoR, and they all seem to be taking a step back.  Let me explain.

Whether you use WebOrb services, SOAP, or REST, you are usually still 
adhering to a CRUD design pattern.  You map four distinct actions on the 
client side into four distinct services on the server side. (The nature of 
the new ActiveResource initiative). 

Now, there is nothing wrong with this, and I'm not trying to get into a 
flame war.  But there have been some better design patterns that have come 
forth.  Before I go on, there is some homework to be done to understand 
Javascript Data Object and the SDO inititive. 

http://en.wikipedia.org/wiki/Service_Data_Objects

http://www.osoa.org/display/Main/Service+Data+Objects+Home   - Note, no 
Ruby :(

http://www-128.ibm.com/developerworks/java/library/j-sdo/

http://dl.alphaworks.ibm.com/technologies/faces4laszlo/faces4laszlo_whitepaper.pdf
 
- SDO for OpenLaszlo to Java (Section 3.4 talks about WDO4JS is synonomous 
with SDO4JS which was later renamed JSDO)

http://www.nyphp.org/content/presentations/ibm/ria-nyphp-overview.pdf - 
The best article around on this stuff

http://sourceforge.net/project/showfiles.php?group_id=173788&package_id=199079&release_id=439723
 
- Faces for Laszlo download

Now, if you are still with me, perhaps the lights are on.  Basically, some 
bright folks at BEA had an idea and implemented it in LiquidData.  IBM 
liked the design, and partnered with them to create the formal name of 
SDO.  IBM used the pattern to handle persistence in Eclipse, and then both 
of them built the pattern into their J2EE servers to enable Ajax.  It has 
since been ported to other platforms, most notibly to enable 
OpenLaszlo/Java and Ajax/PHP. 

Let me explain why we should all be interested.

Did you ever stop to think about what we were really doing to the MVC 
model with AJAX/RIA?  We are basically caching a submodel (in MVC terms) 
on the client, manipulating that cloned copy, and then merging it back. 
The only gotcha is concurrency issues -- others making updates that impact 
the submodel we are working on. 

Wouldn't it be great to have a technology to handle all this in the 
background?  That's what SDO is all about.  It's is basically the ideal of 
creating a "dataset" (in SDO and Laszlo terms, "Dataprovider" I believe in 
Flex) and making that the focus of what the client side code works on. 

The idea of focussing on datasets on the client side is very appealing. It 
allows you to substitute test datasets from files or embedded as objects 
in an RIA client and focus getting the client experience developed.  It 
creates as natural a division of labor as when JSP tags are implemented 
properly (I know, a stretch).  Basically, an RIA UI coder can develop in 
some RIA syntax (openLaszlo, Flex) using the power of a declaritive format 
with constraints to provide the interaction between components, and stay 
focus on this task.  The marshalling of the submodel from the server to 
the client and the merging of submodal changes on the issues of locking 
and concurrency are handled by standard code. 

Now, don't get confused when you read this stuff.  I'm not talking about 
trying to use some kind of JSP tag metaphor with RoR.  What I am trying to 
say is there are a lot of pieces lying around to build a truly remarkable 
architecture that leverages the beautiful ActiveRecord capabilities of RoR 
and the declaritive UI specification of modern RIA technologies and allow 
both to do their jobs well and loosely coupled.  This is the beauty of the 
SDO design pattern, and there is already a javascript implementation of it 
that IBM wrote that does the server to RIA client bridgework!!!!  Do youe 
here what I am saying? 

Imagaine developing an app in Flex or openLazslo and getting the RIA 
client done using generic datastes from xml files.  At the same time, you 
develop you database model using ActiveRecord migration techniques.  All 
that's left is to get a DOMish submodel up to the client to manipulate and 
than handle merge and excetions from concurrency.  This last part is 
exactly what SDO does. 

No calls to Create, Request, Update, or Delete -- just work on the client 
dataset, and changes are reflected back to the server.  Optimistic locking 
automatically engaged, exceptions thrown on the occasional concurrency 
issue of updating the same data.  In essence, a "smart cache" that take 
care of it's own housekeeping. 

This is what I would love to see -- Flex/OpenLaszlo on the front end, RoR 
on the backend, and JSDO as the "smart cache" to surface the model to the 
client.

The must radical part is -- all the hard work has been done. JSDO ships 
with every version of Websphere as a javascript library to handle to 
browser side dataset implementation.  The server side  has reference 
models in several other languages, including PHP. 

Does anyone else out there feel the passion?

-George Willis


---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]

Reply via email to