Tuesday, March 16, 2004

KO/Pi for the Zaurus is a great PIM application. A pdaxrom compiled version is available at the pdaxrom feed. A version for Linux and Windows is also available. 7:11:42 PM

The continuation based web framework I'm working on in Scheme is very page based in its lowest level. The low level look of the code is entirely based around display pages. As an example, if I want to display two pages in a row it would look something like:   (define (make-page text)     (lambda (url)       `(html         (head (title ,text))         (body (p (b ,text))               (a (@ (href ,url)) "Next")))))   (define (run-many-pages)     (show (make-page "One"))     (show (make-page "Two"))) And 'run-many-pages' will be registered with the system, assigned a URL, and accessing it will show the two pages in sequence. The standard 'counter' application example is:   (define (run-counter)     (let ((count 0))       (show        (lambda (url)          `(html            (head (title ,(format "Counter: ~a" count)))            (body             (p ,(format "~a" count))             (table              (tr               (td ,(function-href "++" (lambda () (set! count (+ 1 count)))))               (td ,(function-href "--" (lambda () (set! count (- count 1))))))))))))) It has a higher level for non-programmers that uses XML and other tools to allow plugging an application together relatively easily and quickly. This is built on the lower level shown above. What I'd like to do though is have a more component oriented layer that allows re-use of components and the ability to nest easily next components within each other. Seaside and UnCommon Web both have this type of framework I think. Component based frameworks tend to require more 'boilerplate' code to present a page so I'll be supporting both the low level approach above, the component approach, and the high level system. Another improvement I'm planning on is to move to 'streaming' data to the client rather than the current build up a page as a string and send it all at once approach. Streaming has the advantage of being able to provide immediate feedback to the user. This is especially useful for progress indicators when running a long operation, uploading files, etc. It would also provide the ability to do streaming Javascript notification servers. 7:09:19 PM

In a later comment, Avi explains about the 'continuation threads' idea: Although each individual page in a WebObjects app can be broken into components, I believe the control flow is still at the whole-page level. When you return a new component from a WebObjects action method, what you return becomes the root component of the next page. In Seaside, a component deep within the page can "call" another component and *only it* gets replaced by the new component. That's what makes these "panes" truly independent: you can literally embed an entire application within another and it will work perfectly, oblivious that it's only getting a small part of the total real estate of the browser window. That sounds like a pretty nice feature. The framework I'm developing in Scheme has always worked at the page level and I've recently started experimenting with using components within a page, making those components re-usable, etc. I'll have to have a play with trying to implement this. 6:57:58 PM

Avi also has a post on continuation based web frameworks and the 'threads of continuations' that Seaside has. The continuation based framework I work on doesn't have this feature and I'd love to hear more from Avi about it. What benefits does it give and how is it used? 6:54:01 PM

Avi Bryant has a post about some new features he is adding to Seaside. It sounds great being able to that sort of direct manipulation from within the application itself. 6:51:20 PM

Note to self, get some time to play with Scala, Nice and Groovy to compare to using Sisc in the JVM. 6:49:22 PM

Ted also mentioned that Groovy may head towards some Dylan-like features. Groovy looks like an interesting language and something worth investigating. I'm interested in what it gains over using something like Sisc Scheme which also runs on the JVM. I have to say that Sisc is a fantastic implementation. It's pretty snappy in terms of speed and it is very easy to call into Java and be called by Java. Its continuation implementation is fast and being fully serializable is a great feature. Sisc's object system is based on CLOS and is very Dylan-like as a result. The type system is extensible and it is easy to create new types that plug-in to the system and can be used in generic functions, etc. 6:47:56 PM

Ted Leung posted about Dylan, and in his post he mentions that the Functional Objects technology may go silently into the night. A lot of their technology is actually already open source. Much of the source for their libraries ships with Functional Objects under an open source licence. In fact, you'll find this source in the Gwydion Dylan CVS tree. Their Win32 implementation of DUIM (Dylan User Interface Manager), the Dylan GUI library, has recently been open sourced and is also available at the GD site I believe. I would love to see either Functional Developer, their Dylan IDE, continue to be developed or the source released though. Maybe one day. 6:43:57 PM