JavaScript is pretty much everywhere you look these days, reaching far beyond your desktop browser. Adobe AIR lets you use JavaScript to create desktop installed HTML and Ajax apps. Apple uses it in its gadgets and in the iPhone's browser. And Nokia recently announced support for installed, local JavaScript apps on its phones with APIs to the camera, GPS, etc... (Anyone spotting a WebKit trend here?) You can even use JavaScript to create extensions for Aptana Studio and Dreamweaver too! Anyways, with all this JavaScript out there powering so many things we use every day, having great JavaScript debugging capabilities is paramount to development.

That's why today we're pleased to announce a huge step forward in the ease of creating Ajax and HTML apps for Adobe AIR: Today's release of the Adobe AIR Development Plug-in for Aptana Studio (beta) features, you guessed it — JavaScript debugging for Adobe AIR apps along with support for Adobe AIR 1.5 which Adobe announced earlier this week.

We previewed the JavaScript debugger for Adobe AIR apps yesterday to a group at Adobe MAX in San Francisco and got applauded for providing this critical utility to the AIR community. Like with other debugging environments you’re familiar with, just click to set a break point in the gutter, then step through, into and out of lines of code while viewing variables and introspecting objects. We think you'll find it quite useful. Did I mention it was free too?

   Check out this short screencast for a preview.

Or, if you can't wait here's how to get your hands on it now:

1. Get Aptana Studio 1.2.0
• New to Aptana Studio? Download and install Aptana Studio 1.2.0.
• Already have Aptana Studio? Open it and select Help > Check for Aptana Updates Now...
2. With Studio 1.2.0 and open, select Window > Preferences, then > Install / Update.
3. Set the Policy URL field to: http://update.aptana.com/update/studio/1.2.1beta/3.2/policy.xml
4. Apply the changes and Close the preferences screen.
5. Next, select Help > Check for Aptana Updates Now...
6. Download and install Aptana Studio 1.2.1 Beta, and restart Studio.
7. Select Help > My Aptana and click on the Plug-ins area.
8. Select the Adobe AIR Development Plug-in from the list and follow the steps.

As I mentioned it's a beta, so we're eager to get feedback now so that we can make final changes as well as start to add enhancement requests for future functionality.

Visit www.aptana.com/air for more info, links to forums, bug reporting, enhancement requests, docs and more resources.

"I discovered Aptana Cloud and to say I’m impressed is an understatement," says John Beynon in his blog post regarding Aptana Cloud. "Without any code changes, I right clicked the project containing my blogs WordPress installation and choose to deploy it to the cloud. After a brief sign up for a 21 day trial (no credit card required) and selection of my required service I was good to go and was presented with a synchronise view to send my project up to their servers and a few minutes later my code was all in the ‘cloud’."

Aptana Cloud: Learn More | Watch Screencast

I am excited to announce that the 1.0 version of Jaxer, the free, open source Ajax server, has been released. If you like working with JavaScript and Ajax, you're going to love Jaxer! This 1.0 release of Jaxer is the culmination of three years of work to deliver this first-of-a-kind Ajax server that embeds the Mozilla Firefox browser engine within a server and full JavaScript application framework so that you can use your JavaScript and Ajax skills not just to create web pages but also to create full web applications on the server as well.

If you can't wait, download it now or learn more.

While Jaxer is the brainchild of members of the Aptana team who have been advancing it since Aptana was founded, kudos must also go to the developer community who has actively participated in Jaxer betas since early 2008 and provided much feedback that's guided Jaxer development. Thus in many ways Jaxer is an Ajax server built by web developers for web developers. Jaxer was also created with guidance from members of our technical advisory board including Brendan Eich, creator of JavaScript and Mozilla CTO, who helped us with insights to tune things and deliver initial performance benchmarks for Jaxer in the range of PHP and Ruby on Rails.

If you've already been using Jaxer you're likely familiar with its database, file system and socket APIs and its ability to not only run JavaScript and process the HTML DOM at the server, but also to expose server-side functions to the Web such that a HTML page can call back to those functions directly from the Web page. Thus Ajax communications could not be any easier with Jaxer: You just write a server-side function, "proxy it" with one line of code, then call it from the Web browser as if that function were part of the web page. Jaxer handles the client/server communications, data transformations, and provides the client-side function with its return value (either synchronously or asynchronously).

Recently we've added even more capabilities based on community feedback. These including support for RESTful APIs as well as native support for JSON to supplement the E4X (XML for JavaScript) support that's been there all along (thank you Mozilla!). The combination of these means you can easily create RESTful services that can be consumed by a wide array of Ajax applications, Web gadgets, Facebook or OpenSocial apps, and even Adobe Flash or Microsoft Silverlight based apps since those support JavaScript too. Plus mobile devices like the Apple iPhone and phones from other manufacturers are nearly all supporting JavaScript and Ajax. As you can imagine we're excited to see JavaScript become more and more the lingua franca of Web applications. It's already ubiquitous on the client side and now you can use it confidently on the server side.

This introduction to Jaxer screencast shows you the Jaxer basics with some examples of using Jaxer's
<script runat="server | both | server-proxy" > settings.

Here are more examples of Jaxer in action:

• Integrating with a database and calling server-side JS functions from the browser
• Using Jaxer to securely communicate across domains and mashup information
• Creating RESTful data services with Jaxer
• Using Ajax libraries server-side to mutate HTML pages before they are served
• Using Jaxer to interact with the server operating system
• Easy file uploading
• Creating Server-Side images with Jaxer

Jaxer 1.0 is dual licensed. It's available to all for free under an open source license or in its Jaxer Pro edition under a commercial license and support agreement from Aptana. Jaxer is available to try in various ways: It is included in Aptana Studio 1.2, can be downloaded standalone, and can be tried for free via Aptana Cloud, our elastically scalable hosting and application lifecycle management service. See http://www.aptana.com/cloud for details.

Jaxer, the Ajax server, can do a lot more than "just" serve pages and handle callbacks (function calls from your browser back to Jaxer). With Jaxer 1.0, you can easily create a variety of web services: RESTful, RPC-based, and almost anything else you can imagine. Hooks are already in place for a generic web service and for automatic RPC-based services. Here I'll demonstrate a simple RESTful service based on the generic web service hook.

You'll need the latest Jaxer (currently release 1.0) and the local_jaxer/conf folder contents that ship with it. If you've upgraded from a previous version of Jaxer or Aptana Studio (which has Jaxer built in) take a look at the Guide page for instructions on updating your local_jaxer configuration to 1.0.

To offer a service through Jaxer, rather than a page, you'll need to put your code where the web server + Jaxer will recognize it as a service. By default, that means somewhere in your docroot where the path to it will contain "jaxer-service" or "jaxer-rpc". In a Studio project, create a folder with one of those names, and put your code in that folder or in a subfolder. For this example, I've created a very simple folder structure, one folder with two files:

This does two things: identifies the JavaScript code to Jaxer as a service, and prevents direct serving of your JavaScript file to a browser.

The service itself is just a JavaScript file that gets loaded (from disk or from cache) and executed every time the service is called. Your code has full access to the information in the request, and needs to set the response as you wish. Here I created a service that simply shows you much of the data available:

// pretty-print an object's properties: function printObj(obj, indent) { indent = indent || ''; var lines = []; for (var p in obj) { if (typeof obj[p] == "function") continue; lines.push(indent + p + ": " + obj[p]); } return lines.join('\n'); } // in this sample, the HTTP status code to return is passed in the request: var statusCodeToReturn = Jaxer.request.data.statusCode; // set the response contents to reflect the request information available: Jaxer.response.setContents( printObj({ 'action (method)': '\n\t' + Jaxer.request.action, 'resource': '\n\t' + Jaxer.request.parsedUrl.pathParts.slice(1).join("/"), 'request headers': '\n' + printObj(Jaxer.request.headers, '\t'), 'request body': '\n\t' + Jaxer.request.body, 'data': '\n' + printObj(Jaxer.request.data, '\t'), 'request': '\n' + printObj(Jaxer.request, '\t'), 'environment variables': '\n' + printObj(Jaxer.request.env, '\t') }), statusCodeToReturn); // the Content-Type can be anything appropriate for your service: Jaxer.response.headers['Content-Type'] = 'text/plain';

The service itself is done. (Of course you can now build an entire services layer, loading other files with Jaxer.load(...).) Now how do we call it? If e.g. the jaxer-service folder is directly under your docroot, just send a request to /jaxer-service/tests (and you can append whatever extra path or query items to this path).

How does this work? Jaxer ships with two default dispatchers, both in the extensions folder of the framework: serviceDispatcher.js and rpcDispatcher.js. The first one is what we'll use here (implicitly): it handles requests of the form /path/to/jaxer-service/path/to/myservice/any/additional/data that have jaxer-service in their path, and tries to find the corresponding file on disk. So it looks in your document root for /path.js, then for /path/to.js, then for /path/to/jaxer-service.js, and so on. In our case it will find /path/to/jaxer-service/path/to/myservice.js (or rather /jaxer-service/tests.js) and load it. How does the dispatcher get invoked? That's set in your configApps.js file, or in one of your other configApps-like peer files. By default Jaxer ships with services.configApps.js and that adds an app entry to Jaxer.Config.apps which knows to look for "jaxer-service" in the path and call Jaxer.Extensions.ServiceDispatcher.findFile(...); if it succeeds, the app entry has a "handler" property that returns the path to the file, which Jaxer then loads and executes. Note that this is all handled for you by the default configuration: all you have to do is follow the folder naming conventions. Of course, you can now modify this to suit your needs.

To test this service, I created a simple front-end page called index.html. The source is shown below. Here's what it looks like, including the output from the service:

You can change the method, see which ones support having a body and which do not, etc. Note that the calls are made using your browser's XHR (XMLHttpRequest) capabilities, wrapped in this simple example by the Jaxer client-side framework for convenience.

Note: if you're trying the above in Aptana Studio, it'll work out of the box. If you're trying it with the standalone Jaxer, remove the leading "/" in the URL of the service: use "jaxer-service/tests" instead. That's because Studio needs to do some "magic" remapping between the effective document root and the filesystem.

Here's the source for the front-end page:

<html> <head> <title>RESTful Jaxer</title> </head> <body> <h1>RESTful Jaxer</h1> <script runat="server">//Nothing - just embeds the Jaxer client framework</script> <h3>What to send:</h3> <form> <table> <tr><td>url:</td><td><input type="text" id="url" value="/jaxer-service/tests" size=30></td></tr> <tr><td>query params:</td><td><input type="text" id="queryParams" value="a=12&b=banana" size=30></td></tr> <tr><td>HTTP action (method):</td> <td> <input type="radio" name="httpAction" value="GET" checked="true">GET <input type="radio" name="httpAction" value="POST">POST <input type="radio" name="httpAction" value="PUT">PUT <input type="radio" name="httpAction" value="DELETE">DELETE <input type="radio" name="httpAction" value="HEAD">HEAD <input type="radio" name="httpAction" value="OPTIONS">OPTIONS </td> </tr> <tr><td>content type:</td><td><input type="text" id="contentType" value="application/x-www-form-urlencoded" size=30></td></tr> <tr><td>request body:</td><td><input type="text" id="body" value="c=42&d=plum" size=30></td></tr> <tr><td>return code:</td><td><input type="text" id="statusCode" value="200" size=5> (the response code Jaxer should return) </td> </tr> </table> </form> <tr><td colspan=2><input type="button" value="send" onclick="send()"></td></tr> <hr> <h3>Response:</h3> <pre id="result" style="margin: 0pt"></pre> <script> function $(id) { return document.getElementById(id); } function $$(id) { return $(id).value; } function getRadio(form, name) { var elts = form.elements[name]; for (var i=0; i<elts.length; i++) { if (elts[i].checked) return elts[i].value; } } function send() { var result = Jaxer.XHR.send($$('body'), { url: $$('url') + '?' + $$('queryParams') + "&statusCode=" + $$('statusCode'), method: getRadio(document.forms[0], 'httpAction'), cacheBuster: false, async: false, contentType: $$('contentType') }); $('result').innerHTML = result; } </script> </body> </html>

To summarize, all we needed to do to create the service was to create a JavaScript file somewhere in the document root where its path would contain "jaxer-service". The file will be loaded and executed whenever a request is received for that path (without the ".js" extension). You can add other special paths by adding them to your web server configuration — see the *.httpd.conf files that ship by default with the standalone Jaxer, and to configApps.js and its peers.

In a future blog I'll also show an example of an RPC (Remote Procedure Call) service. Jaxer can also easily consume RESTful services server-side, using e.g. Jaxer.Web.get(...), Jaxer.Web.post(...), Jaxer.Web.put(...), Jaxer.Web.del(...), and Jaxer.Web.head(...) — note that the DELETE action is not invoked via delete(...) because "delete" is a reserved identifier in JavaScript.

The Yahoo! User Interface Library, better known as YUI, version 2.6.0 was released earlier this month, and is now supported by Aptana Studio. YUI 2.6.0 includes numerous fixes, enhancements, and optimizations; introduces a new Carousel Control; breaks the Paginator Control out from DataTable; and makes final eight components that were previously designated beta.

In addition, YUI 2.6.0 also includes a huge number of functional examples—all of which are available, along with code assist, code completion, built-in API documentation, and more, when you install the YUI 2.6.0 plugin for Aptana Studio.

To get the YUI 2.6.0 plugin for Aptana Studio:

1. First, if you do not have it already, get Aptana Studio. It's free, open source software.
2. In Aptana Studio, open the Plugins Manager by choosing Window > Show View > Other... > Aptana Standard Views > Plugins Manager.
   
3. In the Plugins Manager, select Yahoo! User Interface (YUI) 2.6.0 and click the green + icon ( ) to install.
   
4. In the Updates dialog box, expand the tree until you see the available "Aptana Support for YUI" plugins. Select Aptana Support for YUI 2.6.0.00002 and click Next.
   
5. In the Install dialog box, accept the terms of the license agreement and then click Next.
6. In the Verification dialog box, click Install.
7. In the next Install dialog box, click Finish.
8. Aptana Studio will begin downloading the YUI 2.6.0 plugin. Click Yes when you're prompted to restart.

To get started using YUI 2.6.0 in Aptana Studio, do one of the following:

• Click the New Project button ( ) on the toolbar.
  1. Choose Default Web Project in the dialog that appears and click Next.
     
  2. Give your project a name and click Next.
  3. Check the Yahoo! User Interface (YUI) 2.6 box and continue clicking Next until you see a Finish button.
• Expand the YUI 2.6 Samples node in the Samples view, right-click on one of the folders, and choose Import sample as project.
  All of the samples for that category, as well as the library and asset files they depend on, will appear in your project. For example, if you right-click on carousel, you'll get a sample file that shows how to use a selection spotlight with the Carousel control, one that shows how to use a circular Carousel control, one that demonstrates partially revealing previous and next items in a Carousel, and so on.

I'm pleased to announce the release of a major new online service: Aptana Cloud.

Aptana Cloud is the ultimate in ease and efficiency — a suite of online services integrated right into Aptana Studio 1.2 that puts the power of cloud computing to work for you. Cloud's integrated production, staging, source control, application monitoring, threshold and key event notifications systems, stats, logs, server tail views, team management, and tons of other features, streamlines your deployment and development processes and costs far less than doing it yourself.

Users who experienced Aptana Cloud through this summer's early access program have remarked as to how incredibly easy Aptana has made deploying, scaling, developing, and collaborating on hosted sites and applications. It's radically more efficient than anything you've seen or used before (and you can still use SSH and SFTP too). Aptana Cloud currently supports both Jaxer deployments as well as PHP deployments. The short screencast below gives you a good sense of the ease, and you can learn more at http://www.aptana.com/cloud.

Aptana Studio 1.2 also includes new capabilities beyond Aptana Cloud including faster performance, database explorer, bug fixes and UI enhancements all around.

Watch Cloud Screencast

Watch Studio Screencast

Aptana Jaxer, the open-source Ajax server that embeds the Mozilla browser engine server-side, is nearing its first release. There's been lots of work on Jaxer with significant community feedback and ideas coming from the Jaxer betas over the summer. This latest (and probably last before 1.0) release candidate packs in some great performance enhancements like native JSON as well as a brand new built-in capability for easily dispatching RESTful and RPC service requests. And like before we're looking for feedback before we finalize and ship 1.0. So please grab a copy of the latest...

If you've not yet tried Jaxer, now is a great time. Aptana Studio provides extensive integrated tooling and samples for Jaxer, and Aptana Cloud now lets you deploy instantly to Jaxer servers running on elastic cloud computing infrastructure. Of course you can also download Jaxer and put it on your server for free too. It's free and open source.

If you are already using Jaxer, you'll love all the enhancements.

Here a synopsis of all the new features and improvements that have gone into this latest release candidate:

• Jaxer.Sandbox: HTTP-level control; support readyState, toHTML, waitForCompletion
• Built-in, extensible dispatching for RESTful and RPC service requests
• Fast, native JSON support
• Improved APIs for HTTP Request and Response
• More flexible handling of application configuration
• Many bug fixes, smaller improvements, and cleanups

More specifics on these below...

Sandbox enhancements

• return headers and other properties about the request and the response
• new method: waitForCompletion(maxMillis)
• new method: toHTML
• query the readyState

Better HTTP request handling

• More control over how to receive the body, useful for binary data or long posts
• Automatic handling of the body based on Content-Type
• Implement RFC-compliant parsing of the URL
• Offer SSL certificate error handling on requests

Better app management

• Automatically load configApps-like files
• Cleaned up the default local version of configApps.js

Support for web services

• Added default sample-level dispatchers for web service requests and RPC requests
• Allow specifying a handler explicitly for your app
• Support for RESTful calls (including GET, POST, PUT, DELETE, OPTIONS, HEAD)
• Default Apache and Studio configs route URLs containing jaxer-service and jaxer-rpc to Jaxer

JSON improvements

• Use native JSON when available
• Use "standard" JSON serialization by default
• More explicit error message when cycles encountered

DB improvements

• MySQL: Allow specifying a socket when defining connection parameters
• MySQL: Correct handling of booleans
• Resultset: cleaned up the data structure to make it more efficient and easily serializable

Better HTTP Response handling

• Allow setContents to take a DOM node, a document, or an object, and "do the right thing"

Misc improvements

• Much faster start/stop/restart and more robust Jaxer process management

Dojo 1.2 was just released over at www.dojotoolkit.org, and it's also available in Aptana Studio! The Dojo 1.2 plugin for Aptana Studio provides code completion; code assist for Dojo Core, Dijit, and DojoX; sample code; project wizards; and more to support your Dojo development efforts.

The Dojo team is calling this their "sliced bread" release because each change or enhancement felt like the best thing since sliced bread. See for yourself what they've been up to in the release notes, and then get started using Dojo 1.2 in Studio!

To get the Dojo 1.2 plugin for Aptana Studio:

1. In Aptana Studio, open the Plugins Manager by choosing Window > Show View > Other... > Aptana Standard Views > Plugins Manager.
2. In the Plugins Manager, select Dojo version 1.2.0 and click the green +icon to install.
   
3. In the Updates dialog box, expand the tree until you see the five Dojo plugins. Select Aptana Support for Dojo Toolkit 1.2.0.00001 and click Next.
   
4. In the Install dialog box, accept the terms of the license agreement and then click Next.
5. In the Verification dialog box, click Install. (The provider of this feature is Aptana.)
6. In the next Install dialog box, click Finish.
7. Aptana Studio will begin downloading the Dojo 1.2 plugin. Click Yes when you're prompted to restart, and the features of the new plugin will be available in Studio.

As of today you can download or update to the latest release candidates of Aptana Studio, Jaxer and Cloud. These are major releases for our company: we're updating Studio to a new version, we're releasing an incredible new service, Aptana Cloud, and we've reached our 1.0 milestone of one of the world's most unique offerings, the first Ajax Server, Aptana Jaxer.

Cloud 1.0 RC makes web app deployment and management almost too easy!

Aptana Cloud is a new service from Aptana that is completely integrated into Aptana Studio enabling you to more easily develop, deploy, and manage your web applications. With PHP, Apache, MySQL and Jaxer servers already running on top of an elastic computing infrastructure, Aptana Cloud is the fastest way to deploy and scale your sites and apps. Even before you go live, Cloud's hosted SVN, SFTP and staging servers combined with the remote file editing, database management, and Cloud configuration tools make site development and management a breeze.

You can see all the features or watch this screencast to check out just how seamless Aptana has made deploying and scaling your apps in the "Cloud".

We wanted to push out a RC (Release Candidate) version prior to final release so that you could give it a try. It's absolutely free right now, so we'd love for you to try it out. Let us know what you think. Let us know if we missed anything or if you'd like to see something done differently. You can get started by downloading Aptana Studio 1.2 RC (which comes bundled with Jaxer 1.0 RC as well as our Cloud RC support), or if you are an existing Studio user, follow these update instructions.

Studio 1.2 RC adds new capabilities and improves upon many core features.

Enhancements include: Updated smart synchronization utility and a brand new set of visual database tools plus numerous bug fixes and UI enhancements with performance improvements throughout. A new Aptana ID system provides single-sign for the bug database (ASAP), Aptana Cloud, and soon the discussion forums and more. And there's a new 'My Aptana' start page with quick links to your recent files and core features.

Jaxer 1.0 RC adds and refines more features for server-side JavaScript and Ajax.

Since Jaxer is the world's first Ajax server, this release candidate is a huge milestone. This next-to-final release of Jaxer has some great performance improvements that make it comparable to Ruby on Rails and PHP, plus includes new APIs for JSON and REST style data services.
If you are not yet familiar, Jaxer lets you use your JavaScript and Ajax skills server-side to create entire apps, or optimized presentation tiers that can complement other back-ends. Aptana Studio 1.2 RC includes the Jaxer 1.0 RC.

As we get ready to release Jaxer 1.0, we put together a few simple benchmarks to see how it performs relative to a couple of other web platforms: PHP and Rails. We wanted to answer a simple question: how does Jaxer, with its server-side DOM and JavaScript, perform relative to these other popular alternatives?

This was not designed to be an all-encompassing shoot-out, or a detailed study of everything you might want to do in a web app. Instead, we took a few common tasks — making database requests, using JSON, etc. — and implemented them as you might expect in the three platforms. We made enough DB requests and JSON calls and so on to give us a reasonable number of milliseconds to measure. But we also wanted to make the repetitions representative of what you might find on somewhat intensive real-world page, so we're not making a million DB requests, just a hundred, for instance. And we included one benchmark of serving an almost-static page: the "almost" was to make sure we were measuring the time the platform took to really read through the page, in case it had dynamic content in it. (Otherwise, if the page were truly static, you could always arrange for the web server to serve it without involving the platform.)

The first chart shows how long each platform took to perform the task. For the "static" page, we measured the total time taken to serve the request, as measured by the external web client making the request (over the local network). For the other benchmarks, we measured the time taken to perform the specific task itself, excluding the overhead of setting up and tearing down the benchmark, serving the test page, etc. That allowed us to combine these tests and assess what an entire page would take to serve, if it had static content and database requests and some JSON manipulation and so on. Of course your mileage may vary: your app may have less DB requests, more JSON, less IO, whatever. But remember the question we're trying to answer: how does Jaxer perform relative to other accepted platforms for several common tasks? We believe these benchmarks answer that: Jaxer performance is very much comparable to PHP and Rails.

Of course, significant boosts to JavaScript performance are around the corner for Firefox (see Brendan's TraceMonkey article). Since Jaxer is built on the same engine as Firefox, those same improvements will soon be in Jaxer too... With the imminent and massive improvements to JavaScript performance coming to the Mozilla engine.

Now let's take a closer look at these tests below. All were run multiple times on a Macbook Pro (2.5 GHz Intel Core 2 Duo) with 4 GB of RAM.

---

The "Static" Page

We grabbed a copy of one of our blog pages (Aptana Acquires Pydev) and saved it locally. We turned it into a .php file with a smidgen of PHP in it; we threw in a short <script runat="server">...<script> for Jaxer; and created a simple view out of it for Rails. Jaxer was the slowest to serve this page, and not surprisingly: it needs to parse and create the entire DOM of the page to allow server-side manipulation. Still, under 20 ms is pretty good, and is usually dwarfed by weightier tasks such as DB queries.

---

Loops

To measure raw iteration speed we created some very simple loops with and without a bit of variable manipulation. This time Jaxer was far faster than PHP or Rails: at least for simple, common for loops, Mozilla's SpiderMonkey JavaScript engine is no slouch.

PHP	Jaxer	Rails
for($a = 0; $a < 10000; ++$a) { // do nothing } for($a = 0; $a < 10000; ++$a) { $b = $a; } for($a = 0; $a < 10000; ++$a) { $b = $a; for($c = 0; $c < 10; ++$c) { $d = $c; } } $a = 0; while($a < 10000) { ++$a; }	for(var a = 0; a < 10000; ++a) { // do nothing } for(var a = 0; a < 10000; ++a) { var b = a; } for(var a = 0; a < 10000; ++a) { var b = a; for(var c = 0; c < 10; ++c) { var d = c; } } var a = 0; while(a < 10000) { ++a; }	10000.times do |a| # do nothing end 10000.times do |a| b = a end 10000.times do |a| b = a 10.times do |c| d = c end end a = 0 while a < 10000 a += 1 end

---

JSON

Using JavaScript literals as a serialization format predates Ajax, and has become an incredibly prevalent cross-platform data format. We created a simple JSON structure and a more complex one, and measured a variety of encoding and decoding tasks. All three platforms now have native JSON support, so all three performed very well in this benchmark.

$json_string = '{"c": "c", "a": "a", "d": {"three": "3", "one": "1", "two": "2"}, "b": [1, 2, 3, 4, 5, 6, 7, 8, 9]}'; $json_data = array( 'a' => 'a', 'b' => array(1,2,3,4,5,6,7,8,9), 'c' => 'c', 'd' => array( 'one' => '1', 'two' => '2', 'three' => '3' ) ); $complex_json_string = '[{"id": "0001","type": "donut","name": "Cake","ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" },{ "id": "1002", "type": "Chocolate" },{ "id": "1003", "type": "Blueberry" },{ "id": "1004", "type": "Devil\'s Food" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5005", "type": "Sugar" },{ "id": "5007", "type": "Powdered Sugar" },{ "id": "5006", "type": "Chocolate with Sprinkles" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]},{"id": "0002","type": "donut","name": "Raised","ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5005", "type": "Sugar" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]},{"id": "0003","type": "donut","name": "Old Fashioned","ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" },{ "id": "1002", "type": "Chocolate" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]}]'; for($i = 0; $i < 10; ++$i) { $decoded_a = json_decode($json_string,true); $decoded_b = json_decode($complex_json_string,true); json_encode($json_data); json_encode($decoded_b); } $output = ''; for($i = 0; $i < 10; ++$i) { $decoded = json_decode($complex_json_string,true); foreach($decoded as $x => $item) { if($item['id'] == '0001') { $decoded[$x]['type'] = 'fancy donut'; break; } } $output .= json_encode($decoded); } var json_string = '{"c": "c", "a": "a", "d": {"three": "3", "one": "1", "two": "2"}, "b": [1, 2, 3, 4, 5, 6, 7, 8, 9]}'; var json_data = { a: 'a', b: [1,2,3,4,5,6,7,8,9], c: 'c', d: { one: '1', two: '2', three: '3' } }; var complex_json_string = '[{"id": "0001","type": "donut","name": "Cake","ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" },{ "id": "1002", "type": "Chocolate" },{ "id": "1003", "type": "Blueberry" },{ "id": "1004", "type": "Devil\'s Food" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5005", "type": "Sugar" },{ "id": "5007", "type": "Powdered Sugar" },{ "id": "5006", "type": "Chocolate with Sprinkles" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]},{"id": "0002","type": "donut","name": "Raised","ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5005", "type": "Sugar" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]},{"id": "0003","type": "donut","name": "Old Fashioned","ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" },{ "id": "1002", "type": "Chocolate" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]}]'; for(var i = 0; i < 10; ++i) { var decoded_a = Jaxer.Serialization.fromJSONString(json_string); var decoded_b = Jaxer.Serialization.fromJSONString(complex_json_string); Jaxer.Serialization.toJSONString(decoded_a); Jaxer.Serialization.toJSONString(decoded_b); } var output = ''; for(var i = 0; i < 10; ++i) { var decoded = Jaxer.Serialization.fromJSONString(complex_json_string); for(var x = 0; x < decoded.length; ++x) { if(decoded[x]['id'] == '0001') { decoded[x]['type'] = 'fancy donut'; } } output += Jaxer.Serialization.toJSONString(decoded); } json_string = '{"c": "c", "a": "a", "d": {"three": "3", "one": "1", "two": "2"}, "b": [1, 2, 3, 4, 5, 6, 7, 8, 9]}' json_data = { :a => 'a', :b => [1,2,3,4,5,6,7,8,9], :c => 'c', :d => { :one => '1', :two => '2', :three => '3' } } complex_json_string = '[{"id": "0001","type": "donut","name": "Cake","ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" },{ "id": "1002", "type": "Chocolate" },{ "id": "1003", "type": "Blueberry" },{ "id": "1004", "type": "Devil\'s Food" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5005", "type": "Sugar" },{ "id": "5007", "type": "Powdered Sugar" },{ "id": "5006", "type": "Chocolate with Sprinkles" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]},{"id": "0002","type": "donut","name": "Raised","ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5005", "type": "Sugar" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]},{"id": "0003","type": "donut","name": "Old Fashioned","ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" },{ "id": "1002", "type": "Chocolate" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]}]'; 10.times do decoded_a = JSON.parse(json_string) decoded_b = JSON.parse(complex_json_string) decoded_a.to_json decoded_b.to_json end 10.times do decoded = JSON.parse(complex_json_string) decoded.each_with_index do |item,x| if(item['id'] == '0001') decoded[x]['type'] = 'fancy donut' end end output += decoded.to_json end

---

IO

To measure typical file I/O performance, we created a 1 KB string and wrote it to a file, then appended a 100 KB string, and read the whole thing back, and repeated it a few times. Jaxer came out somewhat slower than the other platforms: some of this may be due to the extra conversions between JavaScript's native utf8 encoding and the filesystem, but we'll need to go back and dig deeper.

//write 1kb for($i = 0; $i < 5; ++$i) { $handle = fopen($path.'/test_'.$i.'.txt','w'); fwrite($handle,$chars); fclose($handle); } //append 100kb for($i = 0; $i < 5; ++$i) { $handle = fopen($path.'/test_'.$i.'.txt','a'); fwrite($handle,$chars_repeated); fclose($handle); } //read them all back multiple times for($i = 0; $i < 5; ++$i) { $contents = file_get_contents($path.'/test_'.$i.'.txt'); } //write 1kb for (var i = 0; i < 5; ++i) { Jaxer.File.write(path + '/test_' + i + '.txt', chars); } //append 100kb for (var i = 0; i < 5; ++i) { Jaxer.File.append(path + '/test_' + i + '.txt', chars_repeated); } //read them all back multiple times for (var i = 0; i < 5; ++i) { var contents = path + Jaxer.File.read(path + '/test_' + i + '.txt'); } #write 1kb 5.times do |i| handle = File.open(path + '/test_' + i.to_s + '.txt','w') handle.write chars handle.close end #write 100kb 5.times do |i| handle = File.open(path + '/test_' + i.to_s + '.txt','a') handle.write chars_repeated handle.close end 5.times do |i| contents = File.read(path + '/test_' + i.to_s + '.txt') end

---

DB

To measure database performance, we tried to level the playing field as much as possible by coding straight SQL statements. We also emphasized SELECTs over DML queries because most apps read much more than they write. Jaxer came out somewhere between PHP and Rails, with half its time spent wrapping the raw MySQL data in easier-to-manipulate JavaScript structures. Of course in real-world apps you're likely to use prepared statements, and very often (esp. in Rails, and soon in Jaxer too) an Object-Relational Mapping such as ActiveRecord to abstract out the SQL calls.

for($i = 0; $i < 10; ++$i) { mysql_query('INSERT INTO aptana_benchmark_test (a,b,c) VALUES("'.$chars.'","'.$chars.'","'.$chars_repeated.'")',$connection); } for($i = 0; $i < 100; ++$i) { mysql_query('SELECT * FROM aptana_benchmark_test WHERE id = '.($i + 1),$connection); } for($i = 0; $i < 10; ++$i) { mysql_query('UPDATE aptana_benchmark_test SET a="'.$chars2.'",b ="'.$chars2.'",c="'.$chars2_repeated.'" WHERE id = '.($i + 1),$connection); } for($i = 0; $i < 10; ++$i) { mysql_query('DELETE FROM aptana_benchmark_test WHERE id = '.($i + 1),$connection); } for (var i=0; i<10; i++) { conn.execute('INSERT INTO aptana_benchmark_test (a,b,c) VALUES("' + chars + '","' + chars + '","' + chars_repeated + '")'); } for (var i=0; i<100; ++i) { conn.execute('SELECT * FROM aptana_benchmark_test WHERE id = ' + (i + 1)); } for (var i = 0; i < 10; ++i) { conn.execute('UPDATE aptana_benchmark_test SET a="' + chars2 + '",b ="' + chars2 + '",c="' + chars2_repeated + '" WHERE id = ' + (i + 1)); } for (var i = 0; i < 10; ++i) { conn.execute('DELETE FROM aptana_benchmark_test WHERE id = ' + (i + 1)); } 10.times do |i| ActiveRecord::Base.connection.execute('INSERT INTO aptana_benchmark_test (a,b,c) VALUES("' + chars + '","' + chars + '","' + chars_repeated + '")') end 100.times do |i| ActiveRecord::Base.connection.execute('SELECT * FROM aptana_benchmark_test WHERE id = ' + (i + 1).to_s); end 10.times do |i| ActiveRecord::Base.connection.execute('UPDATE aptana_benchmark_test SET a="' + chars2 + '",b ="' + chars2 + '",c="' + chars2_repeated + '" WHERE id = ' + (i + 1).to_s); end 10.times do |i| ActiveRecord::Base.connection.execute('DELETE FROM aptana_benchmark_test WHERE id = ' + (i + 1).to_s); end

---

Scrape

Finally, we included some page scraping tests. Many web apps mash up other content, repurpose it, or extract data from remote sources. In our case we read in the same blog page as in the static example, and navigated it in a variety of ways. PHP was fastest here, with Jaxer slightly behind and Rails a distant third. Looking for a moment beyond performance, Jaxer is the only platform that would allow scraping of true Ajax web pages, for example pages that created their content "client-side" via Ajax calls.

//find search input box for($i = 0; $i < 5; ++$i) { $contents = file_get_contents('./static.html'); $dom = new DOMDocument(); @$dom->loadHTML($contents); //find by xpath $xpath = new DOMXPath($dom); $inputs = $xpath->evaluate("/html/body//form//input"); $node = false; foreach($inputs as $input) { if($input->getAttribute('id') == 'edit-search-block-form-keys') { $node = $input; } } $divs = $xpath->evaluate('/html/div[@id="gbar"]'); //find by DOM $inputs = $dom->getElementsByTagName('input'); foreach($inputs as $input) { if($input->getAttribute('id') == 'edit-search-block-form-keys') { $node = $input; } } $bar = $dom->getElementById('edit-search-block-form-keys'); } var sandbox = new Jaxer.Sandbox(null,null,{ allowJavaScript: false, allowMetaRedirects: false, allowSubFrames: false }); for(var i = 0; i < 5; ++i) { sandbox.setContents(Jaxer.File.read(Jaxer.Dir.combine(Jaxer.request.currentFolder,'static.html'))); //find by xpath var inputs = sandbox.document.evaluate("/html/body//form//input",sandbox.document,null,XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,null); var search_input = null; for(var x = 0; x < inputs.snapshotLength; ++x) { if(inputs.snapshotItem(x).id == 'edit-search-block-form-keys') { search_input = inputs.snapshotItem(x); } } var divs = sandbox.document.evaluate('/html/div[@id="edit-search-block-form-keys"]',sandbox.document,null,XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,null); //find by DOM var inputs = sandbox.document.getElementsByTagName('input'); for(var x = 0; x < inputs.length; ++x) { if(inputs[x].id == 'edit-search-block-form-keys') { search_input = inputs[x]; } } var bar = sandbox.document.getElementById('edit-search-block-form-keys'); } 5.times do #typical blog page queries doc = Hpricot(open(RAILS_ROOT + '/public/static.html')) inputs = doc/"/html/body//form//input" node = inputs.find{|input| input.attributes['id'] && input.attributes['id'] == 'edit-search-block-form-keys'} divs = doc/'/html/div[@id="edit-search-block-form-keys"]' inputs = doc/'input' divs = doc/'#edit-search-block-form-keys' end

---

Try it yourself

You can download the complete source we used to generate and display these results, and try them yourself. The README file should have the instructions you need. You can grab Apache+Jaxer from the Aptana download site, Apache+PHP+MySQL from several places such as XAMPP, and Ruby and Rails from RubyOnRails.org (if it isn't already on your platform — you'll need Rails 2.1.0, the json Ruby gem, and to run the tests in production mode).

---

Feedback

If you'd like to discuss these, I've started a forum thread for this.

The latest update to jQuery, version 1.2.6, includes faster event handling, faster CSS selectors, an overhaul of attr(), improvements to toggle(), support for all the Dimensions plugin methods (the plugin is now part of the core code), and more... and now it's available in Aptana Studio as well!

If your copy of Studio is set to automatically check for updates, you'll be prompted to install the jQuery 1.2.6 plugin with the next check. If you check manually, follow the steps below to get the updated library files, code assist, and local, searchable documentation that come with the jQuery 1.2.6 plugin:

1. In Aptana Studio, choose Help > Software Updates > Find and Install...
2. Select the "Search for new features to install" option and click Next.
3. Click the New Remote Site... button (top right).
4. In the dialog box that appears, enter Aptana jQuery Update Site as the name and http://update.aptana.com/update/frameworks/jquery/ as the URL and click OK.
5. Aptana jQuery Update Site will now appear in the list of update sites and be checked automatically. Click Finish.
6. In the next dialog box that appears, expand the nodes until you see Aptana Support for jQuery 1.2.6.00002, select that option, and click Next.
7. Accept the terms of the license agreement and click Next.
8. In the next dialog box, click Finish.
9. In the Feature Verification dialog box, click Install.
10. Click Yes when prompted to restart.

We're happy to announce that we've updated our support for the Ext JS library to the latest version, 2.2. Ext JS 2.2 contains numerous bug fixes and feature enhancements, including full Firefox 3 support, improved checkbox and radio groups, a history component, and a GMapPanel extension that packages Google Maps functionality into an Ext component. It's also fully backwards-compatible, so you should be able to move to this version from 2.0 without difficulty (though you can also install 2.2 into Studio alongside 2.0 if you want).

The Ext JS 2.2 plugin for Aptana Studio provides code completion, code assist, Ext JS 2.2 examples, project wizards and more atop solid javascript coding and Ajax debugging utilities so that you can be as productive as possible with Ext JS.

To get the Ext JS 2.2 plugin for Aptana Studio:

1. In Aptana Studio, open the Plugins Manager.
   
2. In the Plugins Manager, select Ext Support version 2.2.0 and click the green +icon to install.
   
3. In the Updates dialog box, expand the tree until you see the three available Ext JS plugins. Select Aptana Support for EXT 2.2.0.00002 and click Next.
   
4. In the Install dialog box, accept the terms of the license agreement and then click Next.
5. In the Verification dialog box, click Install. (The provider of this feature is Aptana.)
6. In the next Install dialog box, click Finish.
7. Aptana Studio will begin downloading the Ext JS 2.2 plugin. Click Yes when you're prompted to restart, and you'll have all the features of the new plugin at your fingertips.

We are very excited to announce that Pydev, the popular Python and Jython IDE, is now part of the Aptana product family and that Pydev creator, Fabio Zadronzy, will head up continued efforts to advance Pydev as part of the Aptana team. Like our products for Ruby on Rails, Ajax, and PHP, Pydev offers code completion, refactoring, code analysis, debugging support, and lots lots more. Pydev's popularity in the Python community and Eclipse ecosystem made it the clear choice for Aptana. The acquisition sets the stage for a full Python suite of products and services ranging from local development to cloud deployment.

Interest in Python has been steadily growing and earlier this year got a big boost when Google announced that Python was the language for Google App Engine.

Dion Almaer, Open Web Advocate for Google recently commented "This has been a great year for the Python developer community with the advent of great frameworks such as Django and deployment solutions such as Google App Engine. Now the tooling is getting better all the time. One of the great tools is Pydev, especially if you are Eclipse-minded. Having Aptana take on Pydev only means progress for that project and Python developers."

Google is also a worldwide licensee of the commercial version of Pydev, Pydev Extensions, which includes even more high-productivity features for Python developers.

Today you can use the products side by side, installing Pydev into Aptana Studio, or plugging both into Eclipse. The combination gives Python developers access to all of Aptana's great tooling for Ajax and current Aptana Studio users access to one of the best Python IDEs out there, and the ease of using both together should increase as we integrate the products more closely over the coming months.

You can learn more about Pydev and Aptana's support for Python at http://www.aptana.com/python, or just go straight to the Pydev and Pydev Extensions sites for downloads and more details.

Please start submitting your ideas for future feature enhancements and how you'd like to see these products come together.

Mozilla CTO Brendan Eich, the creator of JavaScript, in this article by Ryan Paul of Ars Technica, discusses how Mozilla is "'getting ready to take JavaScript performance into the next tier' with a radically innovative optimization tactic called tracing that has already produced performance improvements ranging between 20 and 40 times faster in some cases."

The Mozilla JavaScript engine (SpiderMonkey) is what's inside the Firefox browser and the Aptana Jaxer, Ajax server.

"Eich says that Mozilla wants to 'get people thinking about JavaScript as a more general-purpose language' and show them that 'it really is a platform for writing full applications.'"

Read the full article >

Tom Kirkpatrick of codegobbler.com has told us he's writing a series of articles on some of the great features in Aptana Jaxer. His most recent article is on the new Jaxer.Process APIs that lets Jaxer interact with the operating system on the server to achieve all kinds of things. (Yes you heard right. That's JavaScript interacting with the operating system).

Tom's simple example, complete with full source calls usr/bin/uptime to get the uptime, then display it in the webpage. There's a full working demo to if you want to see the uptime of codegobbler.com's server too.

<script runat="server-proxy"> function runUptime() { // run the uptime and return the output from STDOUT return Jaxer.Process.exec("/usr/bin/uptime"); } </script>

Good work Tom! We look forward to more great stuff from codegobbler.com

Mark Perkins, a Senior Web Developer at VGroup has summarized in this blog post the ubuiquity of JavaScript on the Web and how this dynamic language is empowering all kinds of new possibilities in applications. From ECMAScript to ActionScript, Flash to W3C, Google and Yahoo Maps, Apple's Mobile Me, Aptana Jaxer, Rhino, Firefox, Apple Gadgets, Google Gadgets, Yahoo Gadgets, and even Vista Gadgets, and Adobe AIR, (and more), Mark highlights how JavaScript is at the core of the future of the Web not just online, but on the desktop and on mobile devices as well.

Only thing I'd add to Mark's comments is that JavaScript is set to get even faster than the already blazing improvements delivered by Mozilla Firefox and the Webkit engine that powers iPhones and Sarafi. Projects like Tamarin and its convergence with Mozilla's SpiderMonkey (which Aptana Jaxer, the open source Ajax server uses) are slated to provide the equivalent of Just-In-Time (JIT) compliation of JavaScript and open even greater possibilities for greater JavaScript use.

Jaxer 1.0 is packed full of new, exciting stuff and we are proud to announce Jaxer 1.0 Release Candidate B. This is our first pre-release of Jaxer 1.0 to the general public and we are looking forward to more feedback from the Ajax community. Jaxer 1.0 RC B has more features and capabilities than the prior Jaxer betas, and we're calling this a release candidate because the APIs are now pretty much set for what we'll have in the final 1.0 release. So it's a great time to get started with Jaxer 1.0. Aptana Cloud users and nightly build users are still on Jaxer RC A until updates for those are released (soon).

Jaxer 1.0 RC B is available both within Aptana Studio 1.2 (also just released) and as a standalone server. All are open source. The Studio download is suggested if you are new to Jaxer since Studio includes many helpful features to getting started with Jaxer including a fresh batch of Jaxer 1.0 samples.

Download Aptana Studio with Jaxer 1.0 RC B — or — Download Jaxer 1.0 RC B server.

This release contains many new and enhanced features including:

• Application context settings that allowing for easier app configuration, app properties, database settings, etc...
• Database API enhancements with richer APIs for working with result sets.
• Server-side image manipulation including server-side canvas support and ability to convert to other image types.
• Native command execution API so that you can run system commands and handle the output from those.
• Asynchronous server-side JavaScript processing lets you implement callbacks in your server-side code too.
• Ability to return custom content types (e.g. json, xml, gif, html, etc...)
• Full control of the request/response lifecycle including setting redirects, headers, content, etc...
• Secure sandbox supporting cross domain calls, sandboxed JavaScript execution, META refreshes, ...
• Serialization support for JavaScript objects to and from XML, E4X and JSON

I'm really excited about the ability to return custom content types (json, gif, xml, html, etc...), particularly the JSON type since the server-side is natively JavaScript. What could be easier — especially with the enhanced serialization support for JSON. And with the E4X (native XML for JavaScript) capabilities in Jaxer, returning XML types is now a piece of cake too. This means that you can now easily use Jaxer as a JSON or XML service provider not just to Ajax clients, but also to things like Adobe Flash, Adobe Flex and Microsoft Silverlight which can consume JSON or XML and support JavaScript and XML on the client as well, a technique useful in mashups and all types of social and mobile apps.

The new secure sandbox lets you load, on the server, pages from other domains and allow their JavaScript to execute without giving them access to the Jaxer API or your own server-side code, but still giving your code access to their window objects and anything inside them. While you can't see these windows (they're on the server) you can use them programmatically whether you're consuming web pages in mashups or generating them to be sent to the browser. Uri Sarid's blog has a nice example using these to do "DOM Scraping" where you actually can execute the JS functions of the page you're consuming on the server, access its DOM and get what you need for your mashup or app. Since Ajax is so prevalent today in web pages, being able to trigger the Ajax events server-side such that the content added via the Ajax calls is available in a server-side DOM is very handy in this case and could be applied for things like search engine optimization and accessible modes for web apps as well.

Get all the details of what's new and what's improved in the Migrating Jaxer Beta to Jaxer 1.0 doc.

Jaxer 1.0 docs are in process, links to which can be found at the Jaxer Developer Center.

We'd love your feedback on this release and your thoughts on where Jaxer should go next via the Jaxer forums.

We're finalizing our Jaxer 1.0 release, and I thought I'd go back to Paul's 'DOM Scraping' example and see what Jaxer 1.0 has to offer.

A main new feature is Jaxer.Sandbox, which lets you open new server-side sandboxed 'windows' and load pages into them. You can GET a page from any url, or even POST some content and load back the response. You can control whether JavaScript is executed in the window, whether it honors meta refreshes, whether it loads synchronously or asynchronously, etc. And, most important, the window and its contents have no access to Jaxer and its APIs nor to your app — but your app has full access to it.

There's a lot of other new goodness in Jaxer 1.0, as well as the official released version of the Mozilla engine found in Firefox 3. So for example getElementsByClassName is natively implemented (see John Resig's speed comparison), in addition to the other Mozilla features such as built-in XPath functionality and a very robust DOM feature set — just what you need for some serious 'screen scraping', mashups, and content repurposing.

Let's see it in action. First, let's grab the same three pages Paul used and extract some choice content elements into our page before sending it to the browser. We'll reuse the same Jaxer.Sandbox instance three times, each time loading a different page into it and grabbing some content by id or by classname. The page is basically a single script block: <html> <head> <title>DOM Scraping 1.0</title> </head> <body> <script runat="server"> ...all code here... </script> </body> </html> containing the following server-side JavaScript: var sandbox = new Jaxer.Sandbox(); var item, contents; sandbox.open("http://www.news.com/"); contents = sandbox.document.getElementById("mostPopStories"); addToPage("News.com Popular Stories", contents); sandbox.open("http://www.washingtonpost.com/"); contents = sandbox.document.getElementsByClassName("top-box-in"); addToPage("Washington Post", contents); sandbox.open("http://ajaxian.com"); contents = sandbox.document.getElementsByClassName("activitystream"); addToPage("Ajaxian", contents); and a single helper function that adds the given contents from the sandbox to the current page: function addToPage(title, contents) { var div = document.createElement('div'); var h2 = document.createElement('h2'); h2.innerHTML = title; div.appendChild(h2); if (!(contents instanceof HTMLElement)) contents = contents[0]; div.appendChild(document.importNode(contents, true)); document.body.appendChild(div); }

Here's the resulting page:

That's not too bad, but the timestamps on the News.com section don't look good, and there are a bunch of JavaScript errors on the browser from left-over JavaScript content that was in the original WashingtonPost.com page. We can quickly clean that up with another, tiny DOM helper function that removes any DOM NodeList you pass to it. And while we're at it we'll also remove the reference to the client-side Jaxer framework since we won't be needing it here. The script block becomes: var sandbox = new Jaxer.Sandbox(); var item, contents, container; sandbox.open("http://www.news.com/"); contents = sandbox.document.getElementById("mostPopStories"); container = addToPage("News.com Popular Stories", contents); // Remove the timestamps on each item removeNodeList(container.getElementsByClassName("datestamp")); sandbox.open("http://www.washingtonpost.com/"); contents = sandbox.document.getElementsByClassName("top-box-in"); container = addToPage("Washington Post", contents); // Remove the script tags so they don't appear on the client removeNodeList(container.getElementsByTagName("script")); sandbox.open("http://ajaxian.com"); contents = sandbox.document.getElementsByClassName("activitystream"); addToPage("Ajaxian", contents); function addToPage(title, contents) { var div = document.createElement('div'); var h2 = document.createElement('h2'); h2.innerHTML = title; div.appendChild(h2); if (!(contents instanceof HTMLElement)) contents = contents[0]; div.appendChild(document.importNode(contents, true)); document.body.appendChild(div); return div; // return the container so it can be further manipulated } function removeNodeList(nodeList) { while (nodeList.length > 0) nodeList[0].parentNode.removeChild(nodeList[0]); } // We won't need Jaxer client-side: Jaxer.response.setClientFramework(null);

Now that's much better:

But if you run this example yourself, you'll see it's slow: each of the original servers is a bit slow to load its entire page, and you have to load all three server-side before your page is ready to be sent to the browser. We could load all three in parallel, using the Jaxer.Sandbox's async capabilities and the Jaxer.Thread.waitFor() method to wait for them to load. But even then the user would see nothing in the browser until the slowest one was done loading server-side. So let's load them asynchronously client-side, by creating a server-side function called getFragment that loads a url and returns some of its contents, and setting getFragment.proxy = true so we can call it asynchronously from the client. The page now has two script blocks, one that runs on the browser and one on the server: <html> <head> <title>DOM Scraping 1.0</title> </head> <body> <script> ...all client-side code here... </script> <script runat="server"> ...all server-side code here... </script> </body> </html> The client-side code is: // On callback, append the results to this page function appendHTML(html) { document.body.innerHTML += html; } // onload is used to make sure getFragment is defined before it's called: window.onload = function() { Jaxer.Callback.TIMEOUT = 30 * 1000; getFragment.async(appendHTML, "Ajaxian Activity Stream", "http://ajaxian.com", true, "activitystream"); getFragment.async(appendHTML, "News.com Popular Stories", "http://www.news.com/", false, "mostPopStories", "datestamp"); getFragment.async(appendHTML, "Washington Post", "http://www.washingtonpost.com/", true, "top-box-in"); } and the server-side code is: // Gets a fragment of the remote page's HTML, after some cleanup function getFragment(title, url, isClassName, identifier, classesToRemove) { var sandbox = new Jaxer.Sandbox(url); var contents = sandbox.document[isClassName ? 'getElementsByClassName' : 'getElementById'](identifier); var container = addToPage(title, contents); if (classesToRemove) { if (typeof classesToRemove == "string") classesToRemove = [classesToRemove]; classesToRemove.forEach(function(className) { removeNodeList(container.getElementsByClassName(className)); }); } return container.innerHTML; } getFragment.proxy = true; function addToPage(title, contents) { var div = document.createElement('div'); var h2 = document.createElement('h2'); h2.innerHTML = title; div.appendChild(h2); if (!(contents instanceof HTMLElement)) contents = contents[0]; div.appendChild(document.importNode(contents, true)); document.body.appendChild(div); return div; } function removeNodeList(nodeList) { while (nodeList.length > 0) nodeList[0].parentNode.removeChild(nodeList[0]); } The result looks the same as the previous screenshot, but the order in which the sections are displayed may vary, depending on which remote server responds first.

We are pleased to announce that Greg Murray (creator of the jMaki Ajax framework, former Ajax architect for Sun Microsystems, Sun NetBeans IDE team member and lead on the Java Servlet 2.5 specification) and Ryan Johnson (creator of the livepipe and object.event Ajax libraries) have joined the Aptana Jaxer team!

Greg's primary role will be creating increasingly robust application frameworks for Jaxer, Aptana's open source Ajax server product. Ryan has already been working on MVC concepts for Jaxer and will be collaborating with Greg and the rest of the Jaxer team to drive that and other great concepts for Jaxer forward.

The timing could not be better. Greg and Ryan have joined up just before we get the Jaxer 1.0 release candidate out the door to the whole community (it's just a matter of days now). This puts us in a great position to start working on some of the next things that'll be in store for Jaxer in the coming months -- and there are some great ideas brewing. For example, Greg and Ryan have already been collaborating with the Jaxer team to create an ActiveRecord-like JavaScript ORM for Jaxer that promises to make working with JavaScript data a pleasure -- since it'll all be native JavaScript! Dion Almaer and others in the community have been championing this idea as well. Now we're doing it! Of course Greg and Ryan are both deeply involved in the Ajax community in their own ways as well: Greg with the jMaki project and Ryan with Dynamic Reach and his active role in the Prototype community. So be on the lookout for blog posts from Greg and Ryan to keep abreast of all the stuff they'll be up to here at Aptana.

This beta is for two groups: People who want to try Jaxer RC 1.0, and, People using Eclipse 3.4 who want to test updated Studio compatibility.

Existing Studio users:
Use policy file http://beta.aptana.com/php/3.2/policy.xml, then perform a normal update.

Eclipse 3.4 users:
Follow the instructions at Plugging Aptana into an existing Eclipse configuration and use http://beta.aptana.com/php/studio/3.2/ as the update site.

Related: Changing the update type of your Aptana Studio and Specifying a Policy URL

New in Studio

• New version of Jaxer
• Eclipse 3.4 compatibility

New in Jaxer

(For more complete list, see Migrating from Jaxer beta.)

• Server-side image loading
• JaxerManager/Logging through a single central process
• App management through a new apps subsystem along with more convenient defaults
• Support for native (operating system) process execution
• Simplified state (session-like) containers

One of our users asked about extending Jaxer to do some image processing. He wanted to extend Jaxer using a language he had been already using for some of his back-end work, in this case, Microsoft's C# language which is part of .NET.

I quickly launched my VMWare Fusion into Vista, gulp, and proceeded to run Microsoft's Visual Studio 2008. This posting won't be a tutorial on how to write C#, but i'll just go over some of the basics of setting up a simple C#-based COM object that can be used from within Jaxer.

The first thing to note is that to register COM objects in Vista, you need to be Administrator, so just launch Visual Studio as Administrator using the right-click menu 'Run as Administrator'. Once you have Visual Studio running, start by creating a new 'Class Library' project.

Once you've created the project, right-click on the project and go to the Properties menu, we'll want to make this object a COM-visible one.

In the 'Build' section of the properties, scroll to the bottom and check the 'Register for COM Interop' checkbox. This will make your object visible to other languages as a COM object.

The next thing you'll need to do is open your 'AssemblyInfo.cs' file, which is usually in your Properties folder of your project. Be sure to change the 'false' value to 'true' for the 'ComVisible' setting:

Now that you've done that, you can just create a COM object the 'usual' way. The complete project is attached, so you can take a look there. The image processing code was borrowed from the following online tutorial: http://blog.paranoidferret.com/index.php/2007/06/13/csharp-tutorial-image-editing-rotate/

Once you've got your object compiled, using it from within Jaxer is super-easy! You can just use the COMObject function to create a wrapped instance of the native object and then just use functions and properties on it just as if it were native JavaScript.

So here is the very short HTML file and JavaScript code running server-side via Jaxer that creates the COM object, loads our image, rotates it via the input field in the HTML form, and then saves it back as a new image. The communications from JS to .NET happens very quickly and as you can see, was super-simple to set up.

<html> <body> <script runat="server-proxy"> function rotate(angle) { var img = COMObject("ImageProcessor.ImageProcessing"); img.LoadImage(Jaxer.request.documentRoot + "/photo.jpg"); img.RotateImage(angle); img.SaveImage(Jaxer.request.documentRoot + "/new.jpg"); } </script> <input id="angle"> <input type="button" value="Rotate" onclick="rotate(document.getElementById('angle').value); document.getElementById('img').src = document.getElementById('img').src + '?' + new Date()"> <br/> <img id='img' src="new.jpg"> </body> </html>

Here's a screenshot of the image being rotated:

What's really cool is that you can write anything you like in C#/VB.NET and easily access it via JavaScript in Jaxer. Note how in my sample, the onclick event for the button calls the server-side JavaScript function directly, which in turn calls the .NET COM object. That is, you can bind browser-side buttons directly to back-end .NET COM objects, all in JavaScript through Jaxer!

Attachment	Size
MyCOMObject.zip	15.16 KB

There are some interesting threads going on in the Aptana Forums about using Aptana Studio with Adobe Flex and Flex Builder. The idea of using Ajax and Flex or Flash together is not new. Google Finance did a great job a few years ago blending the two to provide a very nice user experience with Flash-based interactive charts within an otherwise Ajax UI.

It seems that the Aptana community is uncovering increasing efficiencies in using Aptana Studio and Adobe's Flex Builder together. We've also known that many Adobe AIR users are building their Ajax apps for AIR using Aptana Studio, and have heard from others that using Aptana Jaxer to create JSON data services (written natively in JavaScript) consumable by Flash and Flex apps makes a lot of sense as well. Flash and Flex each have an "Ajax bridge" to expose JavaScript APIs for the embedded objects.

Anyways... It seems Adobe is now actively taking a deeper look at this trend in the hybridization of Ajax and Flash and Flex. I saw that they are offering $75 bucks for an hour phone call to discuss your experience with and thoughts on using these together.

Here's the link if you're interested: http://www.adobe.com/go/RIAintegration_study/. $75 bucks... That's almost the cost of a tank of gas in San Francisco.

This week Aptana shipped the 2 millionth copy of Aptana Studio! This is a huge milestone for Aptana for which we owe a big thank you to the community -- not just for downloading Studio, but more importantly for helping make Aptana Studio the leading open source IDE in its category through your feedback, ideas, and suggestions (and for reporting bugs when they happen).

For Open Source Developers by Open Source Developers

We really see the success of Aptana products stemming from the philosophy that it's "for developers by developers" and our open source model help us fulfill that through rapid release cycles, nightly builds, and overall a more fluid process that's constantly taking in feedback from the community. And what better kind of solution is there than the one the community told us to build.

We're continuing that philosophy now with our Aptana Cloud offering (currently in beta) as well as our support for Ruby on Rails, PHP and LAMP development, and of course app development with Ajax libraries on the client side and for those that want server-side Ajax, Aptana Jaxer, a first-of its kind open source Ajax server built around the Mozilla browser engine.

Help us help you. Join the Aptana Early Access Programs

Cloud, PHP and Jaxer are all in active beta stages right now and you can get your hands on them through the Aptana Cloud Early Access Program, so it's a great time to request early access and give early feedback. RadRails, for streamlined Ruby on Rails development is already 1.0 so feedback in the forums and the bug/enhancement system right now is best for that. This early feedback has direct and immediate impact on what we'll ship this year. So now is the time. Got something you want to see in Aptana's offerings? Let us know. Get involved. Help us help you.

Rich Waters of Ext JS has put up a great example of using Ext JS server-side with Aptana Jaxer. Check out the example and from there get the full source code to give it a go yourself.

"We can see that Jaxer lets developers leverage the hard work which has already been spent building client-side libraries on the server-side. These simple examples show off some of the true potential of utilizing the Ext JS framework on the server-side" says Rich.

The easy to follow example shows off a very simple wrapper around an Ext.data.Store and the corresponding Jaxer server code that returns JSON to a Ext JS datagrid.

A new Aptana RadRails book has been released. Aptana community member Javier Ramirez's "Aptana RadRails: An IDE For Rails Development" (Packt Publishing, May 2008) is now available. Find it at Amazon, or direct from Packt (where its a tad cheaper it seems), or at other fine book establishments around the world!

Here's the summary:

A comprehensive guide to using RadRails to develop your Ruby on Rails projects in a professional and productive manner

• Comprehensive guide to using RadRails during the whole development cycle
• Code Assistance, Graphical Debugger, Testing, Integrated Console
• Manage your gems, plug-ins, servers, generators, and Rake tasks
• Rails 2.0-ready
• Includes a chapter about Subversion and Database integration
• Smart Code Assistants for HTML, JavaScript, and CSS

Aptana RadRails is an Integrated Development Environment for Ruby on Rails projects. Built on top of the well-known Eclipse platform, RadRails provides all the tools you need to create a whole Rails application from a single interface, allowing you to focus on the creative part of the development as your IDE takes care of the mechanics.

What you will learn from this book

This book will show you how to use the tools RadRails provides to improve your productivity:

• Tools for writing code: Specialized Editors for Ruby, HTML, CSS, and JavaScript; >> Code Assistance; Code Completion; Refactoring; Quick Code Navigation; Outline Views
• Tools for testing and debugging: Unit Testing; Graphical Debugger; Monitoring of Log Files
• Tools for project management: Specialized views for launching your Tasks and Generators; Management of your Gems and Plug-ins; Rails Servers Control
• You will also learn how to use other Eclipse plug-ins for synchronizing your projects with Subversion and for managing your databases.

Who this book is written for

This book is for Ruby on Rails developers who want to make the most of the framework by using an Integrated Development Environment.

Even though the book explains everything you need to follow the contents, the focus is on how to use the tool and not on the Rails framework itself, so previous working knowledge of Rails is highly advisable. Previous knowledge of Eclipse is not necessary.

--------------------------------------------------------------------------------

Author: Javier Ramírez

Javier Ramírez has been developing Web Applications since before the term Web Application was coined. Born in Zaragoza, Spain, in 1974, he started programming as a hobby around the age of 11 assisted by his older sister. A few years later, he got his first modem and became a regular of BBSes and Newsgroups. His interest in developing server applications that can be accessed remotely comes from those times.

He has learned —and forgotten— many programming languages, including Basic, dBase III, Cobol, Pascal, SQL, C, C++, ASP, TCL, JavaScript, PHP, and Java, the language on which he has focused for most of his career so far. He has held the positions of programmer, analyst, consultant, team leader, post-sales engineer, project manager, and software architect, totaling over 12 years in the IT business.

Having developed projects mainly for banks and other big corporations in Spain, Italy and the US, he co-founded some years ago a small software development shop, which provided him with valuable experience about the difficulties and the joys of entrepreneurship. After two years, he left the company in pursuit of new professional challenges.

For the last two years, he has been proudly working for ASPgems, where he discovered Ruby on Rails, which soon became his framework of choice for developing Web Applications. He is one of the organizers of the Spanish Rails Conference, also participating as a Speaker in the two events held so far.

He has also been an instructor on Robotics, Java, FatWire Content Server, and Ruby on Rails, and a University Lecturer in the subjects of 'Software Engineering' and 'The Java Programming Language', which he currently teaches at Universidad Francisco de Vitoria, in Madrid.

Javier Ramírez holds a B.Sc. in Business Information Systems with First Class Honors and a degree in Ingeniería en Sistemas de Computación.

------------------------------------------------------------------------------------------------

Javier's other postings in the Aptana forums

In June, Aptana and ColdFusion enthusiast, Mark Drew will be at CFUnited presenting:

Fresh AIR: Getting to grips with Aptana and AIR apps
This session will give a nice and fresh introduction to developing AIR applications using Aptana. By using a ColdFusion developer's existing knowledge of HTML and JavaScript (and some quick introductions to JavaScript libraries such as EXT and JQuery), the whole process of developing rich desktop apps will be demystified.

Mark, who has been central to the CFEclipse project, is sure to deliver a great session, so be sure to check it out.

Aptana will build off of its IDE and AJAX success with its new technology. Read the full story.
Learn more about Aptana Cloud, an "Elastic Application Cloud" that's ideal for Web developers who use scripting languages.
Join the early access program.

One of the things I was working on recently is 'screen scraping' some data from several sites and presenting them in a single page. Of course Jaxer seems like the perfect tool for this as I can go fetch the data server-side, pull it all together, then present the final page to the browser. It was so exciting to see this work that I thought I'd make this post to share my experience with you!

We’re working now on adding support in Jaxer for being able to programmatically create 'window' objects, filling them with content from a remote URL, having that content actually execute, then being able to go into that window object and pull DOM elements out. (Update: see the Jaxer 1.0 version.)

Unfortunately for me, that work isn't ready yet, so I wanted to see if there was some workaround I could use until it was ready. Well, after some research and trial and error, a workaround was found. The only catch with this code is that if there is any JavaScript on the page(s) you are fetching, that code will not execute, that’s coming soon.

Note that all of the code below can be contained within a single script tag:

<script runat='server'>...all code here...</script>

So, the first thing I wanted to do