InfoWorld Review of Backbase Ajax Framework

Jouk Pleiter points me to the InfoWorld Review of the Backbase Rich Internet App framework.

From the InfoWorld reivew:

This impressive toolkit provides a mature, sophisticated collection of widgets for adding features normally expected in native applications to Web pages. The system uses its own extension of HTML and XML known as BXML, sure to please methodical coders looking for a clear replacement to the cross-browser complexity of modern JavaScript.

Still haven’t played around with their framework yet, but this caught my eye:

Backbase rich clients can be easily combined with Java & J2EE, .NET & ASP.NET, XML, XSLT and XPath. The .NET Server Edition offers drag-and-drop RIA development with Visual Studio.NET. Plug-ins for Eclipse and DreamWeaver are also available. The XML Server Edition can be installed on both Java platforms and on Microsoft Windows (Native .NET Application).

I’ve been playing around with Ajax support in Ruby on Rails. Even though things are drastically simplified, you still have to be somewhat of a JavaScript / app framework maven to really nail an Ajax app like Backpack has done, not to mention Gmail.

So … like, don’t expect to make GMail in a long weekend in your dorm room.

Unless you’re Paul Graham … or write your app in Lisp. In that case, it’ll take a few hours. Just use a few lexical closures and a macro. (* I kid because I love!)

More Links:
ZapNote: Ajax-based rich internet app

Interesting Apple Ajax job posting

Title: Sr. Web Apps Engineer/Mac OS X Server
Req. ID: 2371350
Location: Santa Clara Valley, California

Country: United States

Req Date: 11-Jul-2005

Is Ajax more than just a household cleaner? Are you the DOM? Do you do it with finesse -and- CSS?

We are looking for a exceptional senior engineer capable of helping us to build the next set of great collaborative features into Mac OS X Server.

A qualified candidate will have several years of experience developing truly dynamic, web-based applications. Experience with the following protocols and technologies is a must - DHTML (XHTML, JavaScript, CSS), DOM , XSL. This role also requires a strong understanding of Internet communication protocols such as SMTP, IMAP/POP, WebDAV, LDAP,

The successful candidate will be capable of owning large features, have a passion for delivering high quality software and must possess a high degree of creativity and enthusiasm. Team work, communication, and collaboration are all important attributes of the candidate. No prima donnas allowed.

Demonstrable examples of impressive past projects a must.

Additional success factors:
- Deep Unix skills
- Mac OS X Cocoa application programming experience
- Strong Python and/or Objective-C skills
- Collaborative software products development

Please send resumes to acy@apple.com and note the requisition number on your subject line.
 

AJAX Proxy 0.2

Version 0.2 of of AJAX Proxy is out - available here. This one actually passes on the POST body (duh).

The basic instructions on setting up Python are the same, as described earlier.

Configuration of the script has now changed - at the end of the script you would modify;

[code lang=”python”]
if name == ‘main’:
REAL_TIMEOUT = 10 # Timeout between AjaxProxy the remote host
# If you’re behind a proxy server yourself, use these
#PROXY_HOST = ‘proxy.server.com:8080′
#PROXY_USER = ‘yourusername’ # Not required
#PROXY_PASS = ‘yourpassword’ # Required if PROXY_USER is set
LOG_DOMAIN = ‘localhost’ # Restrict logging to this domain
LOG_FAVICON = 0 # Log requests for favicon.ico
PI.load(’proxy.instructions’) # Load the instructions file
[/code]

The instructions file allows you to tell the proxy how it should delay requests. An example;

[code lang=”python”]
# On each line, enter two instructions seperated by whitespace
# The first is executed after a request has been received by the proxy but before it forwards it
# The second is executed after the response has been fetched by the proxy but before it returns it to the browser

# The available instructions are;
# wait < creates a delay
# - the delay can be specified a colon then an integer (seconds up to 10)
# - or the word "random" for a random delay of 0 - 10 secs
# fail < the request or response fails - nothing delivered
# end < just outputs a message saying it’s the last instruction without interfering with the request for info only
# - use of this is optional

wait:0 wait:1
wait:random wait:random
wait:10 wait:10
wait:0 wait:0
fail # no need to define a response instruction
end
[/code]

Each line of instructions is used to apply to a single request / response lifecycle. The next request will use the instructions on the next line.

Otherwise, it now dumps the complete request and response (HTTP headers and body) which can be handy for debugging.

A friendly explaination some other time. Meanwhile it’s interesting to try some of the AJAX applications out there - there’s some tails or madness, rage and data loss waiting to be told ( and JPSpan is not entirely innocent either) …

AJAX Proxy 0.1

If you’ve read any of the posts I’ve been dumping here, you’ll know I’m critical of the way AJAX is frequently being used on the grounds that the network / server (and their inherant instability) aren’t being considered. Specifically have the feeling alot of AJAX development is happening @localhost so these problems simply aren’t showing up.

Enter AJAX Proxy, which is meant as a tool to simulate network / server delays by sitting between your browser and your web server and delaying things.

The first version is up here and currently in very hacky form. It’s based on HTTP Debugging Proxy which in turn was based on TinyHTTPProxy. To get it to run on Windows, got some help from rgutils.async, which I used to replace the signal calls. Also, with a little hacking, got it to support a proxy itself (if you’re behind one) - see globals at start of ajaxproxy.py.

To run it, unzip the source somewhere, make sure you have Python installed then from the command line;

[code]
$ ajaxproxy.py 8080
[/code]

The argument is the port number it should run on (defaults to port 8000).

You then need to reconfigure your browser to use it as a proxy server (Firefox > Tools > Options > Connection Settings > Manual Configuration: http proxy = localhost, port = whatever port you used). Also make sure localhost (if that’s where you server is) is not listed in the “No Proxy For” field.

If you now make a request to localhost, you should see the request and response headers logged to your command prompt (TODO: extend this logging to include the payloads)

By default it won’t interrupt anything. To get it to delay / interrupt the request or response, right now you need to hack the source code (TODO: mini language to make this easier). In ajaxproxy.py, check out the following functions;

[code lang=”python”]
def beforeRequest():
“”"This function is executed before the request happens”"”

#Constant sleep
#time.sleep(2)

# Random sleep
# r = random.Random(time.time())
# time.sleep(r.choice((0,5)))”"”

# return 0 # Request never happens
return 1

def afterResponse():
“”"This function is executed after response is received
but before it’s given to the browser”"”

#Constant sleep
#time.sleep(2)

# Random sleep
# r = random.Random(time.time())
# time.sleep(r.choice((0,5)))”"”

# return 0 # Response not sent to browser
return 1
[/code]

It doesn’t support HTTPS (or FTP or anything but plain old HTTP) but if you’re confident to hack a little python, it’s hopefully good enough to get a feeling for what your AJAX app is like when delays start happening.

More as it evolves…