Aptana Blog

When will Aptana Studio go from 3,999,999 to 4,000,000?

khakman — Mon, 15 Jun 2009 12:30:44 -0500

Let's play a game:

If you've been to the www.aptana.com homepage recently, you've probably noticed that Aptana Studio is on the verge of its 4 millionth download! It a huge milestone and we're pleased so many people have loved working with Aptana Studio. (And it's just going to get even better with some releases this Summer). But before the download ticker rolls form 3,999,999 to 4,000,000, let's have some fun...

Match your skills to others in the Aptana community to predict when Aptana Studio will get it's 4 millions download ... more precisely... exactly when the download ticker on the Aptana homepage will display 4,000,000? It's likely to happen sometime between June 15th and June 25th. So stake your claim and announce your answer now.

How to publish and lay claim to your answer:

Use Twitter.com to tweet your answer.
Use the Pacific Time Zone please. You can specify down to the milliseconds if you like.
Do not forget the AM or PM! (We'll assume AM if you do.)
In your tweet you must include @Aptana and #apt4mil to that we can find your prediction on Twitter.

For example:

Who wins?

This is just for fun to see who gets it right and earns bragging rights for their predictive skills. We'll announce the winner on our blog and Tweet it too and kick in an Aptana t-shirt and a year's license to Aptana Studio Pro as well. The Aptana staff who maintains the ticker will run their own calculation for the 4 millionth download event and who ever is the closest without going over will be the winner. In the event of a tie, the first person who tweeted will be the winner. So announce your prediction soon.

Hint

The download ticker on the Aptana homepage is driven by an algorithm that's kicked off by the startCount() javascript function in the www.aptana.com homepage source (use the view source in your browser to see it). When the page loads it gets the number of actual downloads from the day before and then uses that as the basis for the current day's rate of downloads, assumed to be evenly spread throughout the day. So... we may not really know exactly when the 4 millionth download happens. This is more about calculating when the ticker will roll form 3,999,999 to 4,000,000.

New Web Runtime and Tools for Web Apps on Nokia Phones

khakman — Mon, 27 Apr 2009 16:35:44 -0500

Today at the Nokia Developer Conference in Monaco, Nokia showed off a slick new version of the Nokia WRT and it's tooling: The Nokia WRT Plugin for Aptana Studio. The Nokia WRT is the web runtime on Nokia's current generation of phones that lets you use your HTML and JavaScript skills to create instantly installable mobile apps that run on Nokia phones. Like so many mobile runtimes today, Nokia WRT uses WebKit as its core, but it also does more. This latest version packs in a new set of powerful JavaScript APIs that let you incorporate the mobile device's contact list and calendar data, geographical location, SMS messaging, and device sensors, such as an accelerometer, right into your mobile web apps. This is a great step forward enabling millions upon millions of web developers to do the kinds of things that historically only C or Java developers could do.

What's new?

JavaScript API's for Contacts, Calendar, Location, Landmarks, Sensors (e.g. Accelerometer)
Homescreen widget development, preview and debugging
Support for Touch during development and debugging
Support for both Macintosh and Windows platforms
New Device Previews during development

The latest Nokia WRT on Nokia N97 platform also lets users personalize their device's homescreen by adding "mini-apps" to them. Imagine being able to track stock positions through Bloomberg, keep up to date on Facebook chatter or tweets on Twitter, or get sports scores and highlights -- all in real-time on the device home screen. With this the device owner can keep current with the information they want and then launch the "parent" applications for more details if desired.

Nokia also has announced it's Ovi Store -- a mobile device accessible service to which software developers can publish their applications and on which mobile devices owners can find, download and purchase mobile apps for Nokia devices.

Download and Resources

You can download the beta versions of the latest Nokia WRT and Nokia WRT Plugin by following these instructions at Forum Nokia. You'll also find a Quick Start Guide and Release Notes there as well. (If you want the non-beta 1.0 release without this latest set of features, install Aptana Studio, then install the Nokia WRT Plugin form the My Aptana > Plugins area.

Aptana RadRails 1.2 has been released!

cwilliams — Fri, 03 Apr 2009 11:59:02 -0500

Aptana RadRails 1.2 is now available. In addition to making it even easier to get your Rails environment set up and configured, for new and expert users alike this release makes deploying and updating your Rails apps to scalable servers via Aptana Cloud Connect as easy as a few clicks. Watch this 4 minute screencast.

What's new in Aptana RadRails 1.2?

Easier to get Rails set up and configured (especially on Windows).
Since setting up Rails can be confusing to new users (and time consuming even for the most experienced), we’ve added a wizard that helps you get standard Ruby installed as well as RubyGems. For Windows users, the wizard will even get and run the Standard Ruby One-Click installer for Windows for you.

Streamlined Rails app deployment and updates via Aptana Cloud Connect.
Pick a Rails project, then choose Deploy to a New Site, Deploy to Staging, or Deploy to Public. Then RadRails and Aptana Cloud Connect do the rest for you. RadRails 1.2 automates setting up all the integration points, installs the necessary gems, and executes the proper deployment commands for you. And as always shows you in the console all the commands so that you can do them manually or use them in your scripts. Checkout the screencast to see for yourself:

Preparing for Eclipse 3.4 compatibility.
The release also lays some plumbing that will be useful as we move towards using Eclipse 3.4 as the platform for future releases. This primarily means that some debugging functionality that only worked in Studio 1.2 (based on Eclipse 3.2) will now work in Eclipse 3.3+ and in the next major release of Studio when that comes out.

And more...
To view the full changelog for the release, go to http://support.aptana.com/asap/browse/ROR/fixforversion/10082. Note that this is for 1.2.0. In fact, we just pushed a 1.2.1 bugfix release which fixed one major and two minor bugs introduced in 1.2.0.

Enjoy!

-- Chris

Java support added to Aptana Cloud

jlam — Tue, 24 Mar 2009 17:12:49 -0500

As of today, March 24, 2009, anyone using Aptana Studio as a plugin to Eclipse can deploy Java apps to the Cloud via Aptana Cloud Connect. Aptana Cloud Connect integrates Aptana Studio/Eclipse with your cloud hosted Java apps. It lets you instantly put Java projects and apps into to the Cloud, then manage those apps though development, staging/testing and production cycles. Right now, you can also try the Java service for free.

Java developers and teams can easily get started with new new projects without the headaches of setting up hardware, installing software, or configuring networks (or waiting in line for the IT department to get around to your request). As this short screencast shows, you just click the "Deploy to Cloud..." button and in about 2 minutes you've got resources provisioned, complete with Tomcat, mySQL, source control and more all ready to use and integrated right into the IDE. This makes Aptana Cloud Connect ideal for web projects that use Servlets, JSP, JSF, Spring, or other Java web technologies that can be packaged as .war files. And once an app is deployed, allocating more RAM or storage to scale the app is as easy as dragging and dropping a slider. For apps architected to run across multiple machines, private IP addresses in the data center provide for speedy network connections.

The combination of Aptana Studio's popular HTML, JavaScript, CSS and Ajax development capabilities, Eclipse for JavaEE development, and Aptana Cloud Connect for integration with application hosting and life-cycle management services accelerates time to use for new application, reduces costs, and makes the development process much more efficient. Since we released Aptana Studio several years ago we've seen more and more Eclipse users adding Aptana as a plugin to their IDE and using Aptana Studio's HTML, CSS, JavaScript and Ajax capabilities in concert with their Java projects. Now those same Java web projects can go right into a cloud data center and be managed through the development, staging/testing and production life-cycle via Aptana Cloud Connect.

In addition to Java, Aptana Cloud Connect provides application hosting and life-cycle integration for Ruby on Rails, PHP, and Jaxer (the open source Ajax and JavaScript server based on the Mozilla Firefox browser engine).

How to get started?

There's a free trial so that you can check it out at no cost. All you need is Aptana Studio 1.2.5 (free, open source software) or later plugged into Eclipse.

Highlights

Here's a few of the key features of Aptana Studio and Aptana Cloud Connect for Java Developers

Instantly provision servers running Tomcat and MySQL
Work with their remote environments directly from their Aptana Studio perspective in Eclipse
Get full root access, SSH and SFTP
Collaborate with other team members on projects
Tap into integrated Subversion or Git source control
Migrate projects from development, to staging to production contexts
Scale computational and storage resources up and down at will

What does it cost?

Pricing starts at $20 per month -- which includes all your hosting fees and bandwidth (unless you exceed 10 terabytes -- yeah...that's terabytes!). You can upgrade, downgrade or cancel at any time. Fees are prorated to the hour so that you only pay for what you use. Aptana Studio is free, open source software.

Adobe AIR Development Update for Aptana Studio

khakman — Fri, 13 Mar 2009 15:17:03 -0500

A new version of the Adobe AIR Development Plugin for Aptana Studio has been released. Use this plugin to create HTML and Ajax apps for Adobe AIR. There's lots of great new things, but the highlight is the JavaScript Debugger integration with the Adobe AIR runtime. Now you can set breakpoints, step through code, watch variables, and simplify the whole debug process for the JavaScript apps you create for AIR using Aptana Studio. Check out the Debugging JavaScript for Adobe AIR screencast and the related article at the Adobe Developer Center.

What's new in this release?

Support for Adobe AIR 1.5
Integrated JavaScript Debugger
Additional frameworks, JavaScript APIs and code assist for those
Automated badge generation

Of course there's lots of very useful capabilities from the prior releases as well. We also want to say thank you to all the beta testers for this release. We've incorporated much of your feedback into this release and look forward to doing more in the future.

How to get it?

After you download Aptana Studio 1.2.4 (or update to it), follow these instructions to add the Adobe AIR Development Plugin for Aptana Studio.

More resources

Ruby on Rails now supported in Aptana Cloud

krasmussen — Thu, 05 Mar 2009 19:03:17 -0600

We are excited to announce that you can now deploy your Ruby on Rails apps to Aptana Cloud's scalable servers using the latest version of Aptana Studio (version 1.2.3 or later). It takes just a few minutes to go live on Aptana Cloud. There's a free trial to help you get started or just check it out.

This Rails on the Cloud video shows just how easy it is to get a complete database driven application running on your desktop and deployed to Aptana Cloud's scalable servers.

Because we wanted the deployment processes to be scriptable, we based our solution on the popular Ruby deployment tool Capistrano. We wrapped Capistrano with our own Aptana Cloud gem to simplify the process of configuring Capistrano to work with your site, and plan on integrating the process more closely with the Rails utilities in Aptana RadRails soon.

We're here to help. If you need assistance or have feedback for us, visit our new Rails in the Cloud forum. We are especially looking forward to talking with new users about their experience and how we can continue to improve the service for their needs.

How to get started?

(1) Download or update to Aptana Studio 1.2.3 or later, and install the RadRails plugin.
(2) While you're doing that watch the intro video for Rails on the Cloud for an overview of the set up and configuration process.
(3) Next, create a new Rails site to Aptana Cloud via Studio. To do this right-click on your Rails project and select "Deploy to Aptana Cloud ...". The deployment wizard will lead you through the steps to set up your new hosted server.
(4) Set up your Rails environment using this guide.
(5) Deploy your Rails project to your new server.

Mobile Web: Nokia WRT Plugin for Aptana Studio now in 1.0 release

iselby — Mon, 16 Feb 2009 00:05:01 -0600

We are excited to announce that the Nokia WRT Plugin for Aptana Studio is available in its 1.0 release. If you've not seen the Nokia WRT and the new Aptana Studio development tools for this environment, they are very cool indeed. They let you use your HTML, JavaScript, CSS, and Ajax skills to create installable apps for mobile devices and thus tap into GPS, accelerometer, contact list, dialing and other native device capabilities (securely managed through user-granted permissions).

Nokia WRT has been out for a while and is today running on millions upon millions of Nokia S60 phones. The apps can be distributed through simple web download, bluetooth sharing, or even as email attachments making them ideal for both public and private use.

What's New?

What's new is the 1.0 release of the Nokia WRT Plugin for Aptana Studio. This plugin lets you create, test, preview and package feature rich mobile apps and widgets for Nokia S60 devices in the context of Aptana Studio's great code editing, code assist, Ajax library support, debugging and more. Whether you've been creating mobile apps already or are just starting out, the Nokia WRT plugin for Aptana Studio gets you productive fast.

Nokia WRT also lets you access network data when the device is online. Aptana Studio makes it easy to create such data services in a range of languages and even host them on leading providers via Aptana Cloud.

The Nokia WRT plugin for Aptana Studio adds:

Library of ready to use Ajax controls (and you can use other Ajax libraries as well)
Support for Adobe Flash lite
One click app previews in context of various device profiles and aspect ratios
Automated deployment packaging into .wgz files
Deployment to devices for testing (via bluetooth) or Nokia's S60 device emulator for Windows.
Sample applications with full source
Code assist and docs for the Nokia WRT JavaScript APIs

This 8 minute screencast gives you the grand tour.

More information and resources can be found at http://www.aptana.com/nokia.

Download or update to Aptana Studio 1.2.1 or later, then open Aptana > My Aptana > Plugins, find the Nokia WRT Plugin in the list and click "Get It"

jQuery 1.3.1 Support Arrives in Aptana Studio

lorihc — Fri, 23 Jan 2009 10:22:08 -0600

jQuery 1.3 is out, with a brand new selector engine (Sizzle), Live Events, simplified event handling, faster appending of HTML and calculation of position, and a switch from browser sniffing to feature detection. All that goodness—plus the 30 bug fixes that went into jQuery 1.3.1—is now available in Aptana Studio. For developers using jQuery this means code assist, completion and inline reference for jQuery APIs plus searchable docs right there in the IDE (and of course JavaScript debugging and all the other capabilities of Aptana Studio).

To get the jQuery 1.3.1 plugin for Aptana Studio:

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

ActiveRecord.js Released as Beta: Adds Object Relational Mapping to JavaScript

rjohnson — Tue, 13 Jan 2009 13:40:00 -0600

I am pleased to announce ActiveRecord.js, an open source object relational mapper (ORM) that supports multiple JavaScript environments:

Google Gears (client-side persistence)
In Memory (if no SQL server is available on the client)
Adobe AIR (client-side persistence)
SQLite and MySQL (via Aptana Jaxer, the open source Ajax server)
additional environments (like HTML5) expected to come through working with the community on the project

ActiveRecord.js abstracts away underlying SQL commands so that JavaScript developers can have a unified API for storing, finding, selecting and retrieving objects and their data using the ActiveRecord pattern popularized by the Ruby on Rails community.

Whereas other projects have sought to directly port Rails' implementation of ActiveRecord to JavaScript, the approach here is different. Existing ActiveRecord aficionados who are used to the ultra succinct vocabulary of Rails' ActiveRecord implementation will instead find something well suited for JavaScript developers adapting the patterns refined by the Rails community (and some influences from Django) into powerful, easy to use APIs.

Example:

The library ships in a single file, has no external dependencies, and runs client side in all major browsers with or without access to a SQL database and can be used server side with mySQL and SQLite databases via Aptana Jaxer, the open source Ajax server with support for server-side JavaScript. All of the basic features you'd expect are present in this beta release: data validations, life-cycle callbacks, schema creation / migrations and relationships between models. As a beta it's quite stable, and we look forward to your use and feedback to make refinements before calling it 1.0. We're also working with some folks at Google, Mozilla, and Adobe to best achieve the support for JavaScript environments in the browser, on mobile devices, on the desktop and on the server.

Since one target use of this library is for client side stateful applications (using HTML, HTML5, Gears, Adobe AIR, etc...) we have some features that server side only libraries (Aptana Jaxer) don't need to support. One of the features I am most excited about is data synchronization. Although it is nascent, using the current implementation, you can find records or entire result sets and have those found objects automatically receive updates if the data they contain is changed by other queries, or records that should be contained in the result set are created or destroyed. This is marginally useful on its own, but when building user interfaces that depend on data being up to date, I've found it quickly becomes hard to imagine life without it. Synchronization between the client and server is not in the scope of this library yet, but it is on the radar.

If you look in GitHub you will see there is more than just ActiveRecord on the way. ActiveRecord.js is the first part of ActiveJS, a robust MVC framework that's being created explicitly for JavaScript and Ajax apps (and works with other Ajax libraries). I'll be blogging again on these other parts of ActiveJS when they are ready for a public beta, but for those who can't wait, you can find sneak peeks of them in the repo.

For now, enjoy the simplicity of ActiveRecord.js:

I'd also like to make a couple of notes that might preempt a FAQ:

Not all unit tests pass in IE right now (yes we all complain about IE but MAN do they make it hard!)
Some sort of IE friendly persistence hack will be built in soon (cookies / form / etc)
Many to many relationships have yet to be implemented
All of the built in validations that ship with Rails will be ported (as will ActsAsList and ActsAsTree)
Synchronization of data between the client and server is still an open question. Send us your ideas and problems!
We are actively advocating that the HTML 5 spec change to support synchronous SQL queries inside of asynchronous Web Workers, we will not support asynchronous SQL queries unless that part of the spec is ratified. We have experimental support for the current HTML 5 SQL spec as implemented by Safari, but it is currently very difficult to use.

Feel free to ask questions in the ActiveJS Google group. We also welcome pull requests in our GitHub repository if you have forked the project.

Enjoy!

-- Ryan Johnson and Aptana

MooTools 1.2.1 Support Now Available in Aptana Studio

lorihc — Wed, 07 Jan 2009 14:31:53 -0600

One of the things we noticed as we started reviewing preliminary data from our 2009 User Survey is that the popularity of the MooTools JavaScript framework appears to be growing. Many of you say you're using it now or plan to in the future, and some of you even called out MooTools 1.2 support as the feature you most need right now.

Luckily, getting support for MooTools 1.2.1 into Aptana Studio was already in the works, and it went live at the end of December. The new MooTools 1.2.1 plugin includes both the mootools-core and mootools-more library files in all the various compression formats; updated documentation; updated samples; and more.

To get the MooTools 1.2.1 plugin for Aptana Studio:

If you don't already have the latest version of Aptana Studio, get it! It's free, open-source software.
As an added bonus, if you're updating to the latest version from a version prior to 1.2, you may be done after this step. If you see MooTools 1.2 Samples in the Samples view after relaunching Studio, you're all set.
If you already have version 1.2 or later of Aptana Studio, open the Plugins Manager by choosing Aptana > View > Plugins Manager.
In the Plugins Manager, select MooTools 1.2.1 and click the green + icon ( ) to install.
In the Updates dialog box, expand the tree until you see the available "Aptana Support for MooTools" plugins. Select Aptana Support for MooTools 1.2.1.00001 and click Next.
In the Install dialog box, accept the terms of the license agreement and then click Next.
In the Verification dialog box, click Install.
In the next Install dialog box, click Finish.
Aptana Studio will begin downloading the MooTools 1.2.1 plugin. Click Yes when you're prompted to restart.

To get started using MooTools 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 MooTools 1.2 box and continue clicking Next until you see a Finish button.
4. In the Project view, expand the lib folder in your MooTools project and drag one of the -core or -more .js files to the Default Profile folder in the File References view. This will turn code completion on for MooTools by default. (NB: "jm" stands for JSMin, "nc" stands for no compression, and "yc" stands for YUI Compressor.)
Expand the MooTools 1.2 Samples node in the Samples view, right-click on one of the folders, and choose Import sample as project.
The samples files, as well as the library files they depend on, will appear in your project, and the index.html file will open in the HTML editor. The -core and/or -more .js files, as well as any .js files specific to the sample, will automatically appear under the index.html folder in the File References panel, and code completion will be available for all the functions defined in those files.

Announcing Team Aptana and the Forums Upgrade

blazar — Mon, 05 Jan 2009 13:53:39 -0600

I'm very happy to announce Team Aptana, a new initiative from Aptana. Team Aptana is a group of highly engaged members of the Aptana community who will be providing assistance to other customers and partners in the forums as well as providing constructive input to our engineering team. You'll be able to identify them through the badge on their posts:

Charter members of Team Aptana:

As time goes on we will definitely be looking to add new participants, so if you want to be considered feel free to let me know (blazar at aptana.com).

Forum Upgrade

The other big change today is that the forums have been integrated with the Aptana ID system, restructured to fit current needs and updated to phpBB3 (3.0.4, to be precise).

And it runs on Aptana Cloud!

Integration with the Aptana ID system means that you can now sign in to the Forums with the same username and password you use for Cloud, ASAP and Studio. This also means that usernames must meet the Aptana ID username criteria.

If you used the same email address when registering for your forum and Aptana ID/ASAP accounts but a different username, the username on your forum account and posts will change to your Aptana ID username.
If you used the same username but a different email address when registering for your forum and Aptana ID/ASAP accounts, a new Aptana ID account has been created for you.
If you have not had an Aptana ID/ASAP account before one has been created for you.
For the latter two cases: If your current forums username doesn't meet the new criteria, the username on your forum posts has changed to your newly created Aptana ID.

We've restructured the set of forums on the board to better reflect the current requirements of our community and our growing list of products and plugins.

phpBB has been updated to version 3.0.4 and there are now RSS feeds available for each forum, the entire board and individual threads. If you don't see the orange RSS icon on a page, just look for the icon in the URL bar and click it to see the RSS options for the page.

Overall we hope Team Aptana and the forum upgrade give you a big improvement in your Aptana community experience. If you have more ideas for enhancements, please send them in.

Bill Lazar
Manager, Customer Success

Aptana RadRails 1.1.0 and 1.1.1 Released

cwilliams — Mon, 05 Jan 2009 13:27:40 -0600

Whether or not you got the Aptana RadRails 1.1 release last month, Aptana RadRails 1.1.1 is now available too. Here's the highlights for both:

RadRails 1.1 included a few new features, a host of bug fixes, and provided compatiaiblity for Aptana Studio 1.2+:

fixes broken compatibility between the YML/ERB editors and Studio 1.2+
provides compatibility with RubyGems 1.2 and 1.3+
includes the HAML and SASS editor plugins from Brad Wilson of http://blog.lucky-dip.net/. Thanks Brad!
bundles newer versions of JRuby, which brings with it its own list of bugfixes

RadRails 1.1.1 became available last week. This is a bugfix release that contains a handful of high priority bugfixes. See the full changelog for full details.

For the best experience with RadRails, we recommend updating to, or download, Aptana RadRails 1.1.1 now.

Nokia Web Development Plugin for Aptana Studio Released

khakman — Mon, 22 Dec 2008 16:01:51 -0600

Nokia and Aptana this week started shipping the beta release of Nokia WRT Plugin for Aptana Studio. Nokia WRT (Web Runtime) lets you build native apps and widgets for Nokia S60 phones using your JavaScript, Ajax, HTML, and CSS skills -- the stuff standard web pages are made from, but installable on the phone for increased performance, less bandwidth consumption, and more capabilities. We are pleased to be expanding Aptana's support for mobile devices adding Nokia to the growing list of tools for mobile web development using Aptana Studio.

Watch Screencast

Open Standards

The Nokia WRT is based on WebKit. So there's lots of sound, open web technology there as a foundation upon which to build. Despite the "duh factor" of this, it's kind of revolutionary since mobile devices historically have required specialized runtimes, libraries and tools resulting in a highly fractious eco-system for mobile app development. WebKit's adoption by many leading mobile device manufacturers, including Apple for its iPhone, lays a great foundation at last for a mobile standard: JavaScript, HTML, & CSS -- Duh!

Extending Aptana Studio and Eclipse

The Nokia WRT Plugin for Aptana Studio is free software built on the Eclipse Plugin model. Nokia WRT Plugin for Aptana Studio extends Aptana Studio's core support for Ajax libraries, HTML, CSS and JavaScript and leverages its JavaScript debugging and other features. Aptana Studio can run standalone, or you can also plug Aptana Studio into Eclipse, or other Eclipse-based IDEs.

Nokia WRT Component Library

To get you started fast, Nokia WRT SDK (and its development plugin for Aptana Studio) include a library of Ajax components, optimized for the Nokia WRT. These controls include form elements, navigational controls, and other goodies that are pre-integrated with the capabilities of the Nokia WRT. There's also support for Flash .swf in Nokia WRT.

Nokia Preview and Nokia WRT API Emulation

A Nokia device preview is added to the generic Firefox, Safari and IE previews that are standard in Studio. One click lets you see what your app will look like on a phone at different screen dimensions for different devices. In addition, the preview supports the emulation of the Nokia WRT 1.0 APIs so that you can actually click on stuff and make it work.

Automated Project Creation and Test Deployment

The Nokia WRT Plugin for Aptana Studio helps you create ,test, and deploy projects too. The project creation wizard includes and sets up all the resource files you need, including the Nokia WRT components if you want them. Add other Ajax library support via Aptana Studio. The *.wgz packages needed for deployment can be generated by the plugin, and deployed via Bluetooth connections for testing. On Windows operating systems you can also download and install Nokia’s in the S60 3rd Edition, Feature Pack 2 and S60 5th Edition SDKs and deploy widgets to the emulator for testing. The plugin is also supported for MacOS, but without the Emulator deployment.

How to get it?

The Nokia WRT Plugin for Aptana Studio was developed by Nokia, but is being shipped by Aptana. If you already have Aptana Studio, update to Aptana Studio 1.2.1, then go to Aptana > My Aptana > Plugins > Nokia WRT Plugin > Get It. Otherwise download and install Aptana Studio, then do the above.

It's a BETA so, give us and Nokia your feedback!

Aptana's Nokia mobile device support page has links to the discussion forums for feedback during this beta period. Let us know what you think, where we can improve, likes, dislikes, and new ideas so that we can continue to refine it for you.

Aptana PHP Development Environment Released

pcolton — Thu, 11 Dec 2008 17:00:12 -0600

PHP development and deployment just got way easier. Today, we're pleased to announce the 1.0 availability of the Aptana PHP development environment. It's got all the things you'd expect from a PHP IDE, plus all the Ajax tooling and other power tools from Aptana Studio. Combine that with the integrated PHP app hosting, staging and management features in Aptana Cloud and you've got an end-to-end PHP development and deployment environment with unprecedented ease of use.

Learn more at our updated PHP section on aptana.com, or get the Aptana PHP plugin for Aptana Studio now and start using the full 1.0 release.

Thank you to all who participated in the betas for both Aptana PHP and Aptana Cloud. Your feedback helps us make the best possible solutions for you. Keep that feedback coming because we're gearing up for the next versions of these already.

We've also started a PHP screencast library. Get insights to working with Aptana PHP and PHP in Aptana Cloud from the engineers who created the software. As of today, you'll find a collection of these screencasts at the new www.aptana.com/php page along with other resources to rapidly get up to speed with Aptana PHP. We'll also be adding to that screencast library over-time with more insights and tips from our team. Just subscribe to this RSS feed to get notified of when new screencasts are available.

I thought you'd also be interested in what some people are saying about Aptana's PHP support in Studio and in Cloud:

"My team and I have used Zend, PHPEdit, and Aptana Studio, all for extended periods of time. All packages 'do the job', but Aptana’s tools actually help you to code more efficiently, and in many different arenas. Today's web developer needs to understand more than one language, and Aptana understands that, with tools for PHP, MySQL, CSS, JavaScript, Ajax, AIR, and others."
-- Greg Ervin, IT director for Aurora WDC, a competitive intelligence research firm.

"[IntelliJ] was my editor of choice … But Aptana Studio has delivered a game-changer: the IDE provides integrated deployment to cloud servers."
-- Benjamin Shine, Web developer

"If you're looking to host a PHP application with minimum fuss and the option of scaling up/down then Aptana Cloud is a great choice and certainly by far the easiest way I’ve ever seen to getting an app up and running in the cloud."
-- John Beynon, Web developer with the firm Monochrome

Even with all that's in this release, we want to make Aptana PHP even better for you. So, please be vocal in the forums with your likes or dislikes and report bugs or request feature enhancements through http://support.aptana.com.

Thanks!

-Paul

Aptana Studio 1.2.1 Update Now Available

schitale — Fri, 05 Dec 2008 18:25:58 -0600

Aptana Studio 1.2.1 is now available. This update contains several new features and improvements...

Aptana Menu. Find all the Aptana tools and views in a single menu.
SSH (Secure Shell). SSH (Secure Shell) into your Cloud sites using your OS's SSH client (putty in case of Windows)
SmartSync Dialog. The SmartSync has several GUI improvements. It is now possible to sync only parts (selected files and/or folder) of your project and to specify the file permissions for newly uploaded remote files.
Bundled Subclipse Client. The bundled Subclipse client has been updated to 1.4.2.
Adobe AIR 1.5 Support. Add the Adobe AIR 1.5 Development Plug-In to Studio 1.2.1.
Numerous bug fixes as described in the release notes.

Update to or download Aptana Studio 1.2.1 now.

Debug JavaScript in Adobe AIR apps using Aptana Studio 1.2.1

pcolton — Tue, 18 Nov 2008 12:48:45 -0600

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:

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...

With Studio 1.2.0 and open, select Window > Preferences, then > Install / Update.
Set the Policy URL field to: http://update.aptana.com/update/studio/1.2.1beta/3.2/policy.xml
Apply the changes and Close the preferences screen.
Next, select Help > Check for Aptana Updates Now...
Download and install Aptana Studio 1.2.1 Beta, and restart Studio.
Select Help > My Aptana and click on the Plug-ins area.
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.

Digging deeper into Aptana Cloud

khakman — Thu, 13 Nov 2008 17:33:39 -0600

"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 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

Jaxer 1.0 released. Jaxer Pro 1.0 also available.

pcolton — Thu, 30 Oct 2008 08:15:39 -0500

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:

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.

RESTful Jaxer

uri — Wed, 29 Oct 2008 10:14:37 -0500

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.

Here's a synopsis of all it takes to create a service (RESTful or otherwise):

create a folder called "jaxer-service"
put your code file in that folder (or anywhere under that folder if you need more hierarchy)

Your code is automatically loaded and executed whenever someone calls it. So now let's see how that works.

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:

tests.js:

// 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:

index.html:

<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.

YUI 2.6 now available for Aptana Studio

lorihc — Thu, 23 Oct 2008 10:55:53 -0500

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:

First, if you do not have it already, get Aptana Studio. It's free, open source software.
In Aptana Studio, open the Plugins Manager by choosing Window > Show View > Other... > Aptana Standard Views > Plugins Manager.
In the Plugins Manager, select Yahoo! User Interface (YUI) 2.6.0 and click the green + icon ( ) to install.
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.
In the Install dialog box, accept the terms of the license agreement and then click Next.
In the Verification dialog box, click Install.
In the next Install dialog box, click Finish.
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.

Aptana Cloud 1.0 Released! Studio Updated to 1.2

pcolton — Tue, 21 Oct 2008 12:53:08 -0500

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

Jaxer 1.0 Release Candidate now available.

khakman — Tue, 07 Oct 2008 16:46:54 -0500

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 is here!

lorihc — Tue, 07 Oct 2008 07:54:43 -0500

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:

In Aptana Studio, open the Plugins Manager by choosing Window > Show View > Other... > Aptana Standard Views > Plugins Manager.
In the Plugins Manager, select Dojo version 1.2.0 and click the green +icon to install.
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.
In the Install dialog box, accept the terms of the license agreement and then click Next.
In the Verification dialog box, click Install. (The provider of this feature is Aptana.)
In the next Install dialog box, click Finish.
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.

Release Candidates of Aptana Studio, Jaxer, and Cloud Now Available

pcolton — Mon, 06 Oct 2008 16:38:03 -0500

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.

First Jaxer Benchmarks

uri — Sat, 13 Sep 2008 10:19:14 -0500

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.

PHP

$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);
	}

Jaxer

Rails

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.

PHP

Jaxer

Rails

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.

PHP

Jaxer

Rails

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.

PHP

Jaxer

Rails

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.

jQuery 1.2.6 support now available in Aptana Studio

lorihc — Fri, 29 Aug 2008 20:08:59 -0500

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:

In Aptana Studio, choose Help > Software Updates > Find and Install...
Select the "Search for new features to install" option and click Next.
Click the New Remote Site... button (top right).
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.
Aptana jQuery Update Site will now appear in the list of update sites and be checked automatically. Click Finish.
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.
Accept the terms of the license agreement and click Next.
In the next dialog box, click Finish.
In the Feature Verification dialog box, click Install.
Click Yes when prompted to restart.

Ext JS 2.2 support now available in Aptana Studio

lorihc — Fri, 29 Aug 2008 07:29:22 -0500

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:

In Aptana Studio, open the Plugins Manager.
In the Plugins Manager, select Ext Support version 2.2.0 and click the green +icon to install.
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.
In the Install dialog box, accept the terms of the license agreement and then click Next.
In the Verification dialog box, click Install. (The provider of this feature is Aptana.)
In the next Install dialog box, click Finish.
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.

Aptana Acquires Pydev to add Python Support to Studio

pcolton — Mon, 25 Aug 2008 17:02:06 -0500

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.

JavaScript getting 20 to 40 times faster? How?

khakman — Fri, 22 Aug 2008 18:01:57 -0500

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 >

codegobbler.com Jaxer Blog series: Jaxer.Process

davey — Wed, 20 Aug 2008 12:57:06 -0500

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.

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

How JavaScript is quietly taking over the world

khakman — Thu, 14 Aug 2008 18:21:39 -0500

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 now available in Release Candidate B

gmurray — Fri, 01 Aug 2008 12:23:16 -0500

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.

DOM Scraping Part 2: Now with Jaxer 1.0

uri — Wed, 30 Jul 2008 01:52:07 -0500

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.

Ajax gurus Greg Murray, Ryan Johnson join Aptana

pcolton — Sun, 27 Jul 2008 17:38:40 -0500

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.

New Beta: Aptana Studio v.1.1.7

blazar — Thu, 24 Jul 2008 18:01:07 -0500

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.

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

Jaxer and .NET: Image Rotation Example using C# and JS

pcolton — Thu, 03 Jul 2008 17:02:03 -0500

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/> </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!

Hybrid Ajax / Flex Apps. Are You Getting Better Fuel Efficiency?

khakman — Mon, 30 Jun 2008 15:17:51 -0500

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.

Aptana surpasses 2 million Studio downloads...and we're just getting started!

khakman — Thu, 12 Jun 2008 17:19:19 -0500

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.

Fun with Ext JS and Aptana Jaxer

khakman — Wed, 11 Jun 2008 14:02:34 -0500

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.

Aptana Ruby on Rails book by Javier Ramirez released

khakman — Thu, 05 Jun 2008 17:08:17 -0500

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

Aptana-At-Large in June 2008

khakman — Wed, 14 May 2008 18:03:47 -0500

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 to Launch Cloud Platform (eWeek)

khakman — Mon, 28 Apr 2008 14:03:18 -0500

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.

'DOM Scraping' and Cross Domain Mashups with Aptana Jaxer

pcolton — Tue, 15 Apr 2008 12:40:11 -0500

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:

So, the first thing I wanted to do is make it really easy to fetch a remote document and grab out some content. I didn't want to use string matching or regular expressions of any kind, I wanted to use my trusted 'getElementById' to fetch named elements directly. (Of course I ran into sites that don't name their elements, but fortunately many use named classes, so I had to fetch them that way, but I get ahead of myself.)

Let's get started. The following two lines is all that is required to fetch a remote URL synchronously on the server and then pull out a named element:

Now that we have 'item' as the element we were trying to fetch, we just have to add that element to our current blank page. I created a simple function called 'addElementToPage(title, element)' that takes care of this for me. Here's the next line:

That's it. Now I do that 2 more times to fetch content from 2 other sites.

You'll notice that I didn't use getElementById() as those elements were not named, but fortunately they had class names associated with them. I found a convenient function called getElementsByClass() that I used in this case. Since it returns an array of elements, I use the [0] index to retrieve the first item in the list, which in my case, is probably the only item.

Believe it or not, that's basically it. At this point, your three 'DOM fragments' have been fetched and inserted into your new document. Here's the result:

Following are the convenience functions that help make the magic happen. The first function is addElementToPage(). It very simply just creates an H2 tag and sets the title and a DIV tag which contains the contents of the fetched element:

This next function, getDocumentFromURL(), is the one that does most of the work. (I found some good info on the subject of HTML to DOM here: http://jszen.blogspot.com/2007/02/how-to-parse-html-strings-into-dom.html) It first goes and retrieves the remote page. Then it creates a 'document fragment' from the contents of the fetched site. That fragment is then added to a dynamically created IFRAME. Finally, the Document object from the IFRAME is fetched and returned. In short, we can pass in a URL, get the string value, place it into an IFRAME, then pull out the resulting Document object so that we can work on it.

This final function was found at http://www.dustindiaz.com/getelementsbyclass/ and walks a node looking for an element with a specific class name. It was used in the case where elements don't have ID's, so a class name is used instead.

What's exciting about this sample is that it is relatively simple, uses the full power of server-side JavaScript and more importantly, Jaxer's cool server-side DOM capability to enable real 'DOM scraping'. Once window object creation is finished in Jaxer (real soon now), then you'll be able to fetch remote pages, execute their integrated code, then proceed to fetch out items from the resulting DOM.

Update: see the Jaxer 1.0 version.

Server-side jQuery and more cool tricks with Aptana Jaxer

davey — Thu, 03 Apr 2008 17:00:15 -0500

In this example, (the first in a series) we're going to build a simple voting tool, using a single page of DHTML. The implementation is quite basic but covers a good few examples of how to use Aptana Jaxer in real world situations, such as :

Using Ajax libraries on the server (jQuery in this example)
Server-side DOM manipulation (using jQuery)
Storing and retrieving Session data
Creating and accessing a database
E4X as a templating mechanism (E4X provides native XML support in JavaScript)
Handling form data

Let's Vote...

This example was written as a single page webapp. You could remove the Javascript to another file and make it all unobtrusive if that is what gets you excited, but I'm just using an inline script tag, as the code is only about 30 or so lines long. Also in Jaxer we could have easily implemented this using Jaxer's seamless ajax callback mechanism but for the purpose of this example we'll stick with a traditional form post.

Let's get started. Most folks reading this should be familiar with the standard blog/portal poll, where you are presented with a set of choices.

and once you have voted you get to see the current results of the voting.

In our example we allow multiple votes per user but you can easily change that by just commenting out a single line of code.

One of the interesting features of this application is that, by using server-side DOM manipulation in Jaxer, you can remove any unwanted content before it is sent to the client browser. We use this to hide the vote results until the user has voted

This is a useful technique for permission based forms where, for example, you may want remove the credit card details unless the user has established the correct permissions and been validated by the server.

A very basic web page

So let's jump in and have a look at the code used to make this work. The code in this article has been updated to use the API of Jaxer 0.9.8 or later, for The full source listing below contains comments to indicate where the code was changed to work with the later API.

Above is the contents of the HEAD element. Just the usual suspects, setting the title and some simple CSS stuff. The only interesting part is at line #3, where we load the jQuery library on the server, because we intend to do some serverside DOM manipulation before the page is sent to the client.

The runat='server' attribute tells Jaxer to load this javascript library on the server.

The autoload attribute is a recent addition to Jaxer, and it instructs Jaxer to load that page and keep it cached as preparsed bytecode (for faster library loadtime) for any future calls to this page, including callbacks.

In the body of the document we have a simple form which we will dynamically populate on the server. The form will post the vote to itself on the server.

We are marking up the DOM content with the classnames 'voter' and 'nonvoter' to identify content that is specific to a user's status, and make it easily accessible using jQuery on the server.

Server Side Javascript

Now we get to the Javascript. The app has a single script tag in the body which is designated to run on the server.

The first dozen or so lines are simply creating a DB and preparing a schema for use.

So we've connected to the database (which was automatically created if needed, how convenient!) and set up the schema and initial content we expect. We also setup an Array (questions) containing the questions for the voting poll

Next we need to check the session value we are storing (status) to determine whether this user has already voted, and then check to see if the form data for the vote is being posted. Then, if we are actually voting, we write the vote to the database and set the user status to 'voter'.

When we write the vote to the database, we grab the sessionID and the remote IP address and write those out with the vote data, this will let us enforce single voting later if we need it.

Finally query the database to get the current vote counts, remembering to subtract 1 from the total to account for the dummy rows we inserted to seed database and prevent any nulls from appearing in the results totals.

Now we build the DOM, to do this we issue a query to the DB to get the current vote tally.

Using E4X - ECMAScript For XML as a simple templating tool we create the DOM with the nodes populated according to our dataset.

One of the nice features of server-side javascript with Jaxer is that you have access to all neat things built into Mozilla without the worry of client side browser support, which enables reliable use of the advanced features of the Javascript language.

If you look closely at the code below you'll notice we use a simple syntax for variable substitution using curly braces containing javascript code inside the E4X assigments. This allows us to use this for templating as long as we are creating valid XML nodes.

So the document now has a DOM that has been populated with the content for BOTH voters and non-voters. We use a little jQuery magic to remove the elements we don't want presented to the user.

In this way the user will EITHER see the form with the question and the submit button

OR the current voting results data.

Now we set the session variable status to be the current status of the user as they have either voted or not.

Finally as the page that is served has no further dependency on Jaxer once it leaves the server, we tell Jaxer to not bother injecting the client framework. Normally the client framework would be automatically inserted as a script tag in the outgoing HTML, but our simple example doesn't need to communicate back to the Jaxer server, as it contains no server callbacks.

So there you have it, a simple poll on a single page, using many of Jaxer's cool features.

Supporting Files

The full code and supporting files for this article are available here

Full Source Listing

<html>
  <head>
    <title>Jaxer Poll</title>
    <script runat='server' src='jquery-compressed.js' autoload='true'>
    </script>
    <style>
      #pollContainer {
        width: 600px;
        background: #eee;
        border: 3px solid #555;
        padding: 5px;
        font-size: 1em;
        font-family: Tahoma, Verdana, Helvetica, Arial;
        font-weight: 900;
      }
      
      #display {
        background: #ccc;
        font-size: 0.75em;
        font-weight: 200;
        color: #2E3540;
        margin: 5px 0 5px 0;
      }
      
      TD {
        padding-left: 10px;
      }
      
      TD IMG {
        margin-left: -6px;
      }
    </style>
  </head>
  <body>
    <form id='pollContainer' method='POST' accept-charset='utf-8'>
      <div id='question'>
        What do you think is the coolest feature of Jaxer?
      </div>
      <div id='display'>
      </div>
      <div class='nonvoter'>
        <input type='submit' value='vote'/>
      </div>
      <div id='voteTotals' class='voter'>
      </div>
    </form>
    <script runat='server'>  
      // for the beta version of Jaxer, change it to the following
      //var db = Jaxer.DB.SQLite.createDB({PATH:Jaxer.Dir.resolvePath('poll.sqlite')});  
      var db = Jaxer.DB.SQLite.createDB({PATH:Jaxer.Dir.resolve('poll.sqlite')});  
      db.execute("CREATE TABLE IF NOT EXISTS votes (id, ip, vote)");   
        
      var questions = 
      [ 
        "Server-Side DOM"
      , "Server-Side Javascript"
      , "Seamless Ajax"
      , "I already know it!"
      ];  
        
      var totalVotes = db.execute('SELECT count(*) FROM votes').singleResult - 
        questions.length;  
      if (totalVotes < 0)  
      {
        // seed the table with 1 row per question to avoid nulls
        questions.map(function(item, index)   
        {  
          db.execute("INSERT INTO votes (id ,ip,vote) VALUES (?,?,?)", 
            ""+index, '127.0.0.1', ""+index);  
        });  
        totalVotes = 0;  
      }
      // remove the following line to limit to 1 vote per user session
      // for the beta version of Jaxer, change it to the following
      //Jaxer.session.remove('status');
      delete Jaxer.session.status;
      
      // for the beta version of Jaxer, change the following line to
      //var status = Jaxer.session.get('status') || 'nonvoter';  
      var status = Jaxer.session.status || 'nonvoter'; 
        
      // look for request data and save vote if present  
      if ('radioBtns' in Jaxer.request.data && 
          (status == 'nonvoter'))   
      {  
        db.execute("INSERT INTO votes (id,ip,vote) VALUES (?,?,?) "   
        ,   Jaxer.SessionManager.keyFromRequest()   // session ID  
        ,   Jaxer.request.remoteAddr        // remote IP address  
        ,   Jaxer.request.data.radioBtns      // posted data  
        );  
        status = 'voter';   
        totalVotes ++ ;  
      }  
      rs = db.execute('SELECT count(*)-1 AS tot FROM votes GROUP BY vote');  
        
      var output = <table></table>;  
      for (var question in questions)  
      {  
        var percent = parseInt((rs.rows[question].tot / totalVotes) * 100);  
        output.appendChild(
          <tr>  
            <td class='nonvoter'>
              <input type='radio' name='radioBtns' value={question}/>
            </td>  
            <td>{questions[question]}</td>  
            <td class='voter'>  
                
                
              </td>  
            <td class='voter'>{rs.rows[question].tot}</td>  
            <td class='voter'>({percent}%)</td>  
          </tr>);   
      }  
      $('#display').html(output.toString());  
      $('#voteTotals').html(totalVotes + " votes");  
        
      // remove DOM elements based on whether user has already voted  
      $((status == 'voter') ? '.nonvoter' : '.voter').remove();   
        
      // for the beta version of Jaxer, change the following line to
      //Jaxer.session.set('status', status);  
      Jaxer.session.status = status;
        
      // no need for the client Framework to be injected into the page.  
      Jaxer.response.setClientFramework();   
    </script>
  </body>
</html>

Dojo / Dijit markup and templates via Aptana Jaxer

khakman — Mon, 24 Mar 2008 14:29:31 -0500

Tony Issakov has written up a nice conceptual article on how Aptana Jaxer can simplify certain tasks of dojo and dijit development. He starts with a simple case of how Jaxer can enable simplified server-side dijit markup, then expands the ideas to JSF, JSTL, and templates. Tony explains: "Once upon a time dojo had markup ability using custom tags. This was pulled because as it turns out, some browsers just scrap tags they don't understand. One browser that did support tags of a non HTML nature though was Mozilla and in turn we get this freedom back via Jaxer." For example: can become...

Aptana Jaxer 0.9.5 Now Available with Faster Performance, New Features

khakman — Mon, 24 Mar 2008 12:33:09 -0500

Aptana Jaxer has been updated to 0.9.5 providing increased performance for server-side JavaScript and a host of other enhancements to make End-to-End Ajax development easier.

Aptana Studio users can get the latest via Help > Software Updates. Otherwise, download the latest now.

Increased Performance
- Aptana Jaxer's core is now based on Mozilla FireFox Beta3 and thus delivers improved JS performance and memory management.
- Jaxer now pre-parses scripts to bytecode for faster execution during callbacks.
More Natural JS Environment
- Window and document objects on the server-side now parallel more closely how you work with them on the client-side. This means a more natural coding style with server-side JavaScript in Jaxer and a more browser compatible experience.
- Jaxer no longer inlines external scripts to the page, this allows for correct use of browser cache on client side content and makes 'view source' a much more pleasant experience. This also applies to Jaxer's ClientFramework (the client-side JavaScript Jaxer puts in pages to facilitate callbacks and remote method invocation). Instead such external scripts are cachebusted with the buildnumber so that upgrading the server will automatically expire any old client side cache copies.
- A new autoload feature has been added to allow for an entire script file to be cached server-side and reloaded on every regular and callback request. This is ideal for loading JavaScript libraries server-side. A configuration option is provided to expire the script every time the containing page is accessed, to ease development cycles -- this is the default config setting. See http://www.aptana.com/node/202 for a full example.
Improved Platform Support
- Significantly improved Unix support. Jaxer now builds and runs on Solaris too!
- mySQL support is now also provided for Mac OSX
- A number of Windows Vista security/UAC related problems have been addressed
API Enhancements
- Jaxer's file system API has been updated -- mostly around the 'quick' static method. For example: Jaxer.File.chmod('myfile.tx',0400)
- A simple Stopwatch timer API now allows for timing measurements in code.

Easy File Uploading using Aptana Jaxer

davey — Tue, 18 Mar 2008 14:39:06 -0500

One of the common web tasks that always seems to involve a lot of arcane knowledge of backend systems, is how to upload files. Like most systems, Aptana Jaxer uses the post/receive model, where a web form is posted to the server, and the target of that form will receive and process the content. Where Jaxer makes this really easy is that it is all done with regular JavaScript and HTML. No special enviroment vars, excessive string processing, or finding handles to oddly named temp files is required.

All you need is a form to present to the user, which contains an input element of type upload, and an HTML page to receive the submitted form containing a "runat=server" script block that retrieves the data from the request. You could have the form and the recipient be the same page, however in this example I'll use two files for clarity. As an aside in Jaxer you can actually send the form directly to a JavaScript function living on the server but we'll look at that configuration in a future blog entry.

Example HTML Upload Form

This example upload form simply allows you to select up to 2 files for upload from the local filesystem. Pressing 'upload' posts the contents of that form to an HTML page containing the JavaScript shown later.

The form will look like the following when viewed in a browser. Pressing the browse button will present you with a file selection dialog, or you can type the path into the input box directly. I've used 2 file slots in this example to demostrate that the files passed in are available as part of an files array contained in the request object (a JavaScript representation of the HTTP request) and are accessed like any other JavaScript array.

'upload' sends the selected file(s) to the server.

Example Aptana Jaxer code to receive file uploads

To receive the data from the form when submitted we put some Jaxer code into the page the form will be submitted to. The code below should be in script block with a runat = 'server' attribute, which makes the code run serverside and doesn't present it to the client so you don't expose any serverside filenames or folder structures.

The data posted by the form is available within the Jaxer.request object.

For the purposes of this example we are specifically interested in the Jaxer.request.files array which contains an array of Jaxer.Request.FileInfo objects, one for each file posted with the form.

The Jaxer.Request.FileInfo object contains some useful properties describing the file, such as fileName, contentType, etc.

Uploading two files from my filesystem from the form in this example would return a page of output like below. We have uploaded the file to same location as the submission.html file used as the form action in the originating HTML.

Saved to : C:\aptana\JaxerDev\public\work\bar.txt
original filename : bar.txt
temp filename : C:\aptana\JaxerDev\tmp\tmp
contentType : text/plain
size : 15754
Saved to : C:\aptana\JaxerDev\public\work\foo.txt
original filename : foo.txt
temp filename : C:\aptana\JaxerDev\tmp\tmp-1
contentType : text/plain
size : 816

Well that's really all there is to it. It's simple and easy and you never have to think about anything other than HTML and Javascript.

API docs for the FileInfo object and the Jaxer.Request object are available online.

Aptana-At-Large in March 2008

khakman — Thu, 13 Mar 2008 15:45:56 -0500

Next week Aptana will be at AjaxWorld (NYC), iPhone Developer Summit (NYC), and EclipseCon (Silicon Valley). Join us. We want to meet you, answer your questions, and get your feedback and ideas to make Aptana Studio and Aptana Jaxer even better for you. (Of course you can do that anytime via our ASAP enhancement request system too).

AjaxWorld, March 18-20, New York, NY
Kevin Hakman presents Aptana Studio: Your Unfair Advantage for AJAX, iPhone, Adobe AIR, PHP and Rails Development and Rapid Development of Enterprise Ajax Apps both on Wednesday, March 19.

iPhone Developer Summit, March 18-20, New York, NY
Also on Wednesday March 19, Kevin Hakman presents Developing AJAX Applications for iPhone and iPod Touch.

EclipseCon, March 17-19, Santa Clara, CA
Eclipse Monkey committer and Aptana engineer Ingo Muschenetz shares Building Eclipse-based Products: A View From the Trenches on March 18, and Aptana engineer Kevin Sawicki delivers Pimp My Editor with insights for extending and customizing features in Eclipse.

We'll also be at the EclipseCon Ajax focused Birds of a Feather meeting -- check the schedule for details.

RadRails 1.0 Release

cwilliams — Tue, 11 Mar 2008 18:45:25 -0500

I'm happy to announce that RadRails 1.0 has been released today. This release has been a long time coming and includes a lot of new features and polish. We're especially proud of the progress we've made here at Aptana since we took over the project. RadRails 0.7.2 users will definitely want to check out this new release - it offers a more stable environment, full Rails 2.0 support, support for JRuby, and a boatload of new features. For those who want the comprehensive list of changes since the 0.9.3 release, you can find the changelist in ASAP.

The highlights include:

A new Rails Shell console - A screencast dedicated to this feature is available at aptana.tv.
Bundled auto-installing gems for rails development
A Ruby profiler for Pro users
An RDoc preview view
Extended RHTML/ERb color preferences
Code completion for ActiveRecord model fields and finders
Code completion suggesting method call arguments
Significant expansion of code warnings and analysis, including syntax changes from Ruby 1.8 to 1.9
An improved look and feel

These new features join an already impressive set of functionality:

A Fast Ruby debugger
RHTML, YML, HTML, JS, and CSS editors with code assist.
Unit testing integration and GUI
Refactoring
Code analysis and warnings
IDE Scriptable via Ruby
Much, much more!

Please note that unless you've been using 1.0.0 nightlies Aptana/Eclipse will not automatically update you to 1.0. You'll need to force an install of RadRails 1.0 via the Start Page, Plugins Manager, or Software update mechanism that you used to initially install RadRails. For those who prefer to use the Software Update route, the update site URL for RadRails is: http://update.aptana.com/update/rails/3.2/

Aptana recap: Library updates and bug fixes on the way

Fri, 07 Mar 2008 17:00:54 -0600

This week, the Aptana development team continued working on the 1.1.5 release for Aptana Studio and the 0.95 release for the Jaxer server.

New Release

We're planning to release "nightly" versions of Aptana Studio 1.1.5 and Jaxer 0.95 next week. These releases will contain numerous bug fixes. The Aptana Studio release should contain updates for many of the bundled Ajax Library frameworks, including support for EXT 2.0.2., Yahoo UI 2.5, Adobe Spry 1.6, and more.

Tips and Tricks

Do you have a question about an Aptana Studio Pro license? Or do you need some basic troubleshooting help? Visit our recently re-organized Aptana Studio FAQ and see if your question has already been answered there.

If you still need help, you can always file a support request in our ASAP system, of course.

Community Buzz

We'd like to thank our community for their help with submitting bugs and feature requests in ASAP. If you've submitted a bug or a feature request and are curious if we've implemented the fix or feature yet, visit your ASAP ticket and look for the Fix Version field. This field lists the current target release date for the fix or feature.

Jaxer on AIR: Build Desktop & Server Apps in Ajax

pcolton — Tue, 26 Feb 2008 19:33:56 -0600

Yesterday Adobe announced the availability of Adobe AIR 1.0. At the same time, Aptana released the Adobe AIR plugin for Aptana Studio which simplifies development of Ajax applications that run "on AIR". (Adobe AIR Plugin for Aptana Studio)

If you are not familiar with Adobe AIR, it enables you to use the skills and Web technologies you already know, HTML, CSS, and JavaScript, to write applications that can be deployed to the Windows and Mac desktop, and shortly on Linux desktops too.

And what is Aptana Jaxer, you ask? Jaxer is an Ajax server that enables you to leverage those same Web skills and technologies, HTML, CSS, and JavaScript, to write server-side code and do a whole new range of things with JavaScript like interact with databases, file systems, and remote data sources, do server-side DOM manipulations, cross-domain data calls, make socket connections, and call server-side JavaScript functions from the client-side, plus lots more. Yes, you write both client and server code using HTML and Ajax. You can even write entire web applications in a single HTML file if you wish.

With that said, it becomes much clearer as to what ‘Jaxer on AIR’ is all about -- two systems that enable you to leverage your Ajax skills for building desktop and server apps, unified into a single, very interesting model. With Jaxer you can implement your server-side to know if an app is running in AIR and thus take advantage of offline synchronization and local access to the client system as permitted, or if you’re running on the Web with a subset of the total potential features of your Ajax apps and Web pages.

I did a 10-minute screencast showing a simple example of this. I take one of Jack Slocum’s great Ext / Adobe AIR demos (EXT Tasks Demo) and Jaxer-enabled it. I added a single JavaScript function that can query my backend database, and I use the results to fill the user interface.

This demo just scratches the surface of what is possible, but I hope it opens the doors to your thinking about how to utilize these great technologies – it’s my version of their chocolate and our peanut-butter happily together, enjoy!

View 'Jaxer on AIR' Screencast

Ajax Pioneer Kevin Hakman joins Aptana, Inc.

pcolton — Mon, 25 Feb 2008 17:00:08 -0600

We are excited to announce that Kevin Hakman has joined Aptana to head up marketing and developer community programs. Kevin is a recognized leader in the Ajax community. Long before the term "Ajax" was coined, Kevin was pioneering single page web application concepts via the company he co-founded, General Interface Corp., one of the first enterprise Ajax libraries and visual development tools companies. General Interface Corp. went on to be acquired by TIBCO Software in 2004 as a compliment the company's service-oriented architecture (SOA) products. Today TIBCO General Interface is used by many Fortune-scale companies for rapid Web application development and deployment atop their XML and SOAP data sources.

In addition to his historic role on the steering committee of the OpenAjax Alliance, Kevin currently chairs the organization's integrated development environment working group. The OpenAjax Alliance IDE Working Group which includes Adobe, Aptana, the Eclipse Foundation, IBM, Microsoft, Sun, TIBCO and others is now close to delivering a draft specification for a uniform way to describe Ajax libraries and controls and thus streamline the ability to use Ajax libraries within your development tools of choice. Kevin is a frequent speaker at Ajax industry events and is an author to many published articles on Ajax in the enterprise.

A Jaxer Roadmap

uri — Sun, 24 Feb 2008 05:52:36 -0600

This past week we released another point release of Jaxer, version 0.9.3, updating the standalone server as well as the one packaged within Aptana Studio. Of course there were bug fixes, performance improvements, and API enhancements. Perhaps most important, this was our first release to officially support Linux. Supporting Linux isn't trivial because of the multitude of variants, but it is very strategic as the deployment platform of choice for many people. Look for more distros being supported and more forms of distribution, from buildable source drops to tarballs and installable packages and even to complete EC2 and VMWare images. And thanks to the community for already helping us with supporting Linux distros.

So where are these releases leading — what are some things on the immediate roadmap for Jaxer?

An even more Ajax-y experience: the callback environment will be made more natural, server-side support for Ajax libraries will expand, mashups will be easier to implement, etc.
Scalability and performance: we'll release some interesting benchmarks on current Jaxer performance and stability, illustrate how it scales, and make some significant improvements.
More APIs: we'll make database, file, network, and native interfaces more powerful while maintaining clean APIs that feel at home in JavaScript and HTML.
More integration: we're creating a true bridge to Java by leveraging DWR (Direct Web Remoting) server-side, in addition to our current support for Tomcat (and other servlet containers); we'll expand the list of supported web servers from the current Apache 2.x and Jetty to IIS, Apache 1.3, and perhaps others; and we'll work on other database drivers.
Deployment: we're working on making one-click deployment a reality, so you can develop your Ajax apps in Studio, leveraging Jaxer for the server side, and click to deploy your app to a hosted, managed, monitored, and scalable environment.
Tooling: How about seamless end-to-end debugging of your Ajax app — step through your program starting on the server, move to the browser, go back to the server for a callback, then back to the browser for processing the result...
Real-world apps: in the spirit of eating our own dog food, and supporting dog food consumption in the community, look for complete applications written on Jaxer and en expansion of our web site and of Studio so you can share your snippets, samples, projects and applications.

Oh, and the time frame? We're not exactly the patient type, so for many of these think weeks rather than months. Want something specific to come out even faster? Join the discussions on the forums, join the effort (some folks are supporting Linux distros, others are building persistence frameworks, some are putting together samples), or join our team.

Aptana recap: Jaxer now available for Linux

Fri, 22 Feb 2008 16:48:58 -0600

This past week, the Aptana development team released a patch release that provides support for the Jaxer server on Linux. Read on to learn more details about this release.

New Release

Earlier this week, Aptana released new "nightly" builds of both Aptana Studio (v.1.1.3) and the Jaxer server (0.93). Aptana Studio 1.1.3 contains several bug fixes. Jaxer 0.93 contains several major new additions including support for Linux and integration with Amazon's EC2 technology. You can read more about these developments on our blog:

Community Buzz

Frequent visitors to the Aptana web site may have noticed some changes recently. We've been in the process of re-organizing some of our documentation in order to make things easier for the community to find. One recent major addition that we've made is the Book of Jaxer, which is now the main landing page for all of our Jaxer documentation. Additionally, we've compiled a new FAQ page for Aptana Studio, which should answer most of your questions about Aptana Studio licenses and otherwise help you get started with Studio.

If you're having trouble finding a certain piece of information or notice that we're missing a Help topic on something, please file a new request in ASAP, and we'll try to get the information added to the site as quickly as we can.

Tips and Tricks

Are you new to Jaxer development, but aren't quite sure how to get started? Our new Jaxer Quick Start Guide is a fast and easy way to walk through the entire process. This guide covers all of the basic information that you'll need to get started with Jaxer, including installation, creating your first Jaxer project, and resources for learning more.

Jaxer Server now on EC2

Wed, 20 Feb 2008 21:18:17 -0600

Are you looking for a quick and easy way to deploy your Jaxer applications? You can now take advantage of the cloud technology provided by Amazon's Elastic Compute Cloud (also known as EC2). EC2 provides you with a fast way to get going with Jaxer and to deploy it on a hosted infrastructure. With your own EC2 instance, you can make your Jaxer applications available for both private and public consumption.

The Jaxer Team has set up a CentOS image with Jaxer pre-configured and ready to go. Find out how to get your own instance running (and more) on the Running an EC2 Instance of the Jaxer Server page.

We'd love to hear about what you're building with Jaxer, so if you're working on a Jaxer app or just have a few questions about Jaxer, we'd like to invite you to participate in our Jaxer community forums.

Jaxer Server Now on Linux

klindsey — Wed, 20 Feb 2008 19:36:57 -0600

The Jaxer Team is proud to announce that we now support Jaxer for several Linux platforms:

Ubuntu
CentOS
Fedora

To learn how to get up and running on Linux, see the Jaxer Standalone Installation guide for Linux.

We've been working with volunteer beta testers within the Jaxer community to bring you these distros, and we plan to support additional distros in the future. However, this is our initial release for Linux support and because the various Linux platforms have so many nuances, some Linux platforms could likely still have some issues. Our Linux support is very community driven, so we invite you to participate in the platform vote on the forums to voice your opinion about your preferred platform:

http://forums.aptana.com/viewtopic.php?t=4844

If you have Jaxer up and running on a platform that we have not listed, let us know so we can add it to the list of supported platforms. Additionally, if you need help troubleshooting issues with Jaxer on your Linux platform, post your questions on the Jaxer forums.

A very simple file based blog on Jaxer

cwilliams — Mon, 11 Feb 2008 11:31:42 -0600

This tutorial is a sample of some functionality you can quickly achieve in Jaxer. In this case we'll be building a very basic file-based "blog".

The idea is simple: Create an HTML page that will show all the "posts". A post is created by creating or FTPing a txt file to the server and naming it so it will appear in the order desired. We'll also add the ability to use Markdown syntax in the txt file so you can easily do some basic HTML without the HTML syntax.

You can easily extend this to add a page where posts can be written and previewed, re-ordered/renamed, move to using a DB instead of txt files, etc.

We'll want a folder named "articles" as a sub-folder of our project. Next we'll create a simple index HTML page as a peer of that folder, with a div inside the body containing the id "posts".
<html> <head> <title>My Blog</title> </head> <body> <h1>My Blog</h1> <div id="posts"></div> </body> </html>

To get started writing server side Javascript we 'll add a script tag in the head with a runat attribute set to server:
<script runat="server"> </script>

Jaxer has a nice API that allows you to work with the filesystem directly on the server. We're going to take advantage of that to have it grab files inside the "articles" folder that is a peer of our html file on the server:
function init() { var path = Jaxer.Dir.resolve("articles"); var dir = new Jaxer.Dir(path); var files = dir.readDir().map(function(file) { return file.leaf; }); }
Now we have a function which grabs the "articles" directory and then gets a listing of all the filenames inside that directory. Next we want to loop over the files, read in their contents and append it to a string that we'll be pushing back into the div with id "posts".
var html = ""; for (var i = 0; i < files.length; i++) { var read = Jaxer.File.read("articles/" + files[i]); html+= read; } document.getElementById('posts').innerHTML = html;

Pretty simple. We read all the files, concat their contents together into a string and then push that into the posts div. We can try it out by having this function run when the server has loaded the page/DOM. We just modify the body tag like so:
<body onserverload="init();">
This tells Jaxer to run our init function when it has completed creation of the page's load process.

Obviously, concatenating all the files contents together doesn't look too nice. Lets wrap each file's contents in a div with class "post" so we can style it later.
var read = Jaxer.File.read("articles/" + files[i]); html+= makePost(read);

function makePost(contents) { return "<div class=\"post\">" + contents + "</div>\n"; }
That's much better. Now we don't have all the files in one giant string.

But this hasn't bought us much - we still have to write the HTML tags inside the txt files if we want to do any styling or marking up of the content. Let's provide a markup syntax to allow users to use simple text conventions to generate HTML. One such library is Markdown. We're going to use a nice Markdown in JS library provided from: http://softwaremaniacs.org/playground/showdown-highlight/

It's pretty simple to use. First we include the library on the server side:
<script src="showdown.js" runat="server"/>
Next, we use it to mark up the file's contents before we wrap it in the div:
... var read = Jaxer.File.read("articles/" + files[i]); html+= makePost(markdown(read)); ... function markdown(content) { var converter = new Showdown.converter(); return converter.makeHtml(contents); }
And there you have it. We now have a blog index page which will grab all of our article text files, run them through markdown and insert them into post divs for us.

To wrap up here's the full code:
<html> <head> <title>Articles</title> </head> <script src="/showdown.js" runat="server"> </script> <script runat="server"> var converter = new Showdown.converter(); function createPost(contents){ // Run markdown filter on contents var text = converter.makeHtml(contents); return "<div class=\"post\">" + text + "</div>"; } function init() { try { // read all the articles in text files in "articles" sub-dir of this dir (#.txt) var articlesPath = Jaxer.Dir.resolve("articles"); var files = new Jaxer.Dir(articlesPath).readDir(); var string = ""; var i = 0; for (i = 0; i < files.length; i++) { var filename = Jaxer.Dir.combine(articlesPath, files[i].leaf); if (new Jaxer.FileUtils().ext(filename) == "txt") { var raw = Jaxer.File.read(filename); string += createPost(raw); } } document.getElementById('output').innerHTML = string; } catch (err) { document.getElementById('output').innerHTML = err.description; } } </script> <body onserverload="init()"> <div id="output"></div> </body> </html>

Jaxer integration with Apache Tomcat released

ksawicki — Sun, 10 Feb 2008 19:11:49 -0600

A how to guide on integrating Jaxer with Apache Tomcat has been released.

This guide walks you through how to enable Jaxer to post-process your HTML and JSP pages for your Tomcat web applications. The tutorial includes two WAR files, one that adds support for Jaxer callbacks on your Tomcat pages and the other includes samples on possible ways to integrate Jaxer with your JSP/HTML pages.

Jaxer also has a connector available for the Jetty HTTP server which is used inside Aptana Studio.

Please use this forum thread to discuss the Jaxer-Tomcat connect

The Power of Mozilla - Now Playing at a Server Near You

uri — Sun, 03 Feb 2008 00:49:08 -0600

Jaxer lets you use your full stack of Ajax technologies — HTML, JavaScript, DOM manipulation, XHR, etc. — on the server, to make web application development a lot smoother and more natural.

But Jaxer is also based on the Mozilla engine, in fact on the same core that will power Firefox 3, just without the rendering. And this simple fact unlocks a lot of power that's been built up over many years by Mozilla developers. Unless your apps and sites have targeted Firefox exclusively — unlikely, given its market share — they could not rely on JavaScript features beyond version 1.4. And how about the numerous extensions that have been developed for Firefox, some of which actually ship with the browser? Most developers don't even know about them, and they couldn't rely on them being available to most of their target audience.

But now all that Firefox 3 goodness is under the hood of your Jaxer, on the server side, under your full control. So if JavaScript 1.7 and 1.8 generators, iterators, and array comprehensions float your boat, then happy sailing. Soon native JSON parsing and encoding will be available, along with other features on the march towards JavaScript 2. Perhaps more significantly, you have a rich SOA stack: SOAP, WSDL, and other four-letter friends from the enterprise architect's bestiary. Microformats, anyone? Simply use the script loader to import the built-in Microformats.js and you have access to hCard, hCalendar, and other functionalities. XSLT transformations are at your fingertips by just "new"ing up an XSLTProcessor object. There are all sorts of hidden gems to discover: did you know there's a very nice RDF subsystem in there? How about base64 encoding and decoding? Try typing for (var p in Components.classes) { print(p); } in the Jaxer Shell to see that we've just scratched the surface of what's available.

Of course, if you don't see something you need, you can always just build it: think server-side GreaseMonkey scripts on steroids. I can't wait to see what people will come up with, now that all these capabilities are free from their browser dependence. There's already been a number of cool examples on various blogs, and we'll start to roll out more on a regular basis. More importantly, we'll make it easy to share your own samples and snippets with the community. Stay tuned...

Aptana recap: Aptana Studio 1.1.1 release coming soon

Fri, 01 Feb 2008 18:07:01 -0600

With the excitement of the 0.9 release of Jaxer and the Aptana Studio 1.1 release behind them, the Aptana development team spent the past week working on the first patch release for 0.9/1.1. The Aptana community should have access to these patches early next week.

New Release

The upcoming Aptana Studio 1.1 release will be a patch release that fixes several bugs in 1.1, including the following issues:

An encoding bug where workspace text encoding isn't saved after re-starting Aptana (STU-1111)
A bug involving CSS pseudo classes (STU-1035)
A bug in Prototype code assist involving the $() function(STU-134)

Tips and Tricks

We're aware that some users have been having difficulty installing the recent updates to Aptana Studio. The team is working on isolating the causes of this issue and hope to improve the situation soon. In the meantime, if you have been unable to download/install the updates, try performing a manual installation as directed on the update site:

http://update.aptana.com/update/3.2/

Community Buzz

We see a lot of bug reporting and feature requests on the forums; however, the best way to get support or to request a new feature is to fill out a ticket in ASAP

http://support.aptana.com/issues/

By filing a ticket in ASAP, you enable us to track the status of a ticket more easily, and you can also easily search for related bugs and feature requests.

Next Week

Next week, we'll get started with work on the 1.2 release. Current plans for the 1.2 release include a number of updates to the Ajax libraries bundled with Aptana Studio (EXT, Yahoo UI, etc.) and a migration to the Eclipse 3.3 platform as the base platform for Aptana.

Aptana releases support for Adobe AIR Beta 3

ksawicki — Fri, 25 Jan 2008 15:47:54 -0600

We are pleased to announce that our Adobe AIR plugin for Aptana Studio now supports beta 3 of the Adobe AIR SDK.

This release requires Aptana Studio 1.1 or later which can be downloaded here.

What's new in this release:

Inclusion of the AIRIntrospector.js allowing inspection of running applications by pressing F12
Updated sandbox samples for both application and non-application models
New fields added to the application.xml wizard page making it easier to create the initial configuration of your application
Updated samples compatible with the Adobe AIR Beta 3 SDK

Instructions to install Adobe AIR beta 3 support

Aptana Jaxer -- An Entirely New Kind of Server

pcolton — Tue, 22 Jan 2008 15:23:09 -0600

Wow, it’s been a long road getting to this release date, but I am very excited and proud of our team, and I'm happy to say that today we released our beta 1 of Jaxer -- what we believe to be the first true Ajax Server product.

So what is an “Ajax Server”? Simply put, we unify the development model for Ajax developers. That is, write “Ajax” code client AND server. The same APIs, the same JavaScript, the same HTML and best of all, manipulate the DOM on the server.

What does all that mean? It means that you can do a getElementById() and set its innerHTML on the server side just as easily as you can on the browser. You can write a single JavaScript function and share it between browser and server. You can write server functions which can be transparently called from the browser -- synchronous or asynchronously.

If you’re a beginning Ajax developer and any of that sounds complicated, it’s not. It simply means you can now build an entire Web 2.0 application, client and server, using only the Ajax technologies you love.

I asked several of the leaders in the Ajax space to join with us and with you, the Ajax community, in defining where we go from here. I’m very honored to say that we’ve got an all-star group assembled as our Aptana Advisory Board, just take a look at this who’s who list.

We’ve placed a few screencasts online so you can take a quick look at what Jaxer is all about and how you can start playing with it right away.

Send us your feedback, your suggestions, and tell us what you are building. After all, building a free, open-source product ultimately means we’re building this for you!

Regards,
Paul Colton