Wednesday, October 8th, 2008
Category: Aptana
![[image]](http://mowser.com/img?url=http%3A%2F%2Fwww.aptana.com%2Fimages%2Fjaxer_logo_whitebg.jpg)
The Jaxer team has released a release candidate for Jaxer 1.0.
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
They are moving pretty fast, so are looking for feedback before they wrap up a final 1.0 release.
Wednesday, September 17th, 2008
Category: Aptana
Jaxer has been out in beta for a while and is nearing its 1.0 release. Many comments on Ajaxian about Jaxer have been about performance benchmarks. Uri Sarid, CTO of Aptana, has compiled some initial benchmarks including comparisons to PHP and Ruby on Rails. (Jaxer comes out in between the two):
![[image]](http://mowser.com/img?url=http%3A%2F%2Fwww.aptana.com%2Fsystem%2Ffiles%2Fjaxer_benchmarks0_individuals_2.png)
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 tests include page scraping tests (e.g. mashup work), database performance, file I/O, JSON, and programatical loops.
Monday, September 8th, 2008
Category: Aptana
![[image]](http://mowser.com/img?url=http%3A%2F%2Fwww.codegobbler.com%2Fsites%2Fcodegobbler.com%2Ffiles%2Ffckeditor%2Fjaxer.jquery.png)
Tom Kirkpatrick has written about writing one form, and using access control to map it to various roles using jQuery and Jaxer.
This is a simple pattern. You never want to use client code to manage access, for obvious reasons. The approach is to use the server to spew out HTML that makes sense, and then parse in the input and check access control.
Using Jaxer, this is all taken care of in JavaScript, and you can use libraries such as jQuery to do work there.
One solution to the roles issue is to manipulate the DOM on the server before it heads to the client. The magic lies in the 'server-nocache' directive which tells Jaxer than "the code should only run on the server, and that the code or should not be cached and will therefore not be available during callbacks."
HTML:
// some kind of authentication to get current users role
role = getRole()
// remove private form elements
$((role == 'employer') ? '.employee.private' : '.employer.private')
.remove();
// disable irrelevant form elements
$((role == 'employer') ? '.employee input' : '.employer input')
.attr('disabled', 'disabled');
// no need to inject Jaxer client framework (saves about 20k)
Jaxer.response.setClientFramework();
</script>
Of course, to be safe, you need to always test access control incoming, and not rely on the HTML that you send down.
Wednesday, August 20th, 2008
Category: Aptana, JavaScript, Server
![[image]](http://mowser.com/img?url=http%3A%2F%2Fwww.codegobbler.com%2Fsites%2Fcodegobbler.com%2Ffiles%2Ffckeditor%2Fjaxer.process.png)
Tom Kirkpatrick has written about a new API in Jaxer, Jaxer.Process, that allows you to call out to the host operating system. His example has a call out to get the uptime on the machine:
JAVASCRIPT:
<script runat="server-proxy">
function runUptime() {
// run the uptime and return the output from STDOUT
return Jaxer.Process.exec("/usr/bin/uptime");
}
</script>
You can see the application running live.
Friday, August 1st, 2008
Category: Aptana
Greg Murray has blogged about a new release candidate for Aptana Jaxer that contains a lot of new features.
Kevin Hakman told us about the release:
We've had server-side JS database APIs all along, but now handing result sets is even easier. There's also now full fine grain control and access to the entire communication cycle with APIs for message headers, redirects, content and types. Speaking of types… for the first time with Jaxer, you can return content types other than HTML including JSON, XML, GIF, etc… Yes, even GIFs. Jaxer has a fresh new Image API that among other things can convert Canvas to static images and serve them up. Like, Greg, I too really like the idea of using Jaxer for easily creating JSON data services which is a rapidly growing trend as developers discover the powerful capabilities of JSON more and more. In Jaxer, it's very cool since it's all native JavaScript on the client, on the wire, and on the server. There's even enhanced JSON serialization to make it even easier than before on both client and server. JSON services also open Jaxer to be useful in combination with rich internet clients other than Ajax UIs such as Flash, Flex or even Silverlight since all those support JavaScript on the client and can consume JSON data. For Ajax and RIA developers this is a boon since you can now write your client-side and server-side code in the same language. And if you prefer XML data services Jaxer's native E4X (ECMAScript for XML) support means you can handle XML docs natively in JS on Jaxer as well.
This release also includes a totally new concept: a secure sandbox which as Greg explains, "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 gives your code access to their window objects and anything inside them". For anyone who has ever done screenscaping for mashups or other applications, this really helps a lot since Ajax pages have historically thwarted scraping operations. With this feature in Jaxer you can securely get a remote page, execute its functions, and scrape the resulting DOM nodes (yes, you need not do tedious manipulations with strings) and voila!
Here are the features:
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.
Uri Sarid has a great post that shows how you can do DOM Scraping with Jaxer, and updates it for this latest release:
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!
It includes code that shows the Sandbox in action, as well as the DOM work:
JAVASCRIPT:
// 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;
Monday, July 28th, 2008
Category: Aptana
Paul Colton posted that Aptana has a couple of new recruits in Greg Murray and Ryan Johnson.
Greg Murray was the Ajax guy at Sun, created jMaki, and did a lot of work in organizations such as the Open Ajax Alliance. Ryan Johnson is the creator of the livepipe and object.event Ajax libraries. What are they doing?
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!
Friday, July 4th, 2008
Category: .NET, Aptana
What does your CEO do? Paul Colton, CEO of Aptana, gets his fingers dirty. He just wrote a post about accessing COM objects from JavaScript with Jaxer.
This is possible as the JavaScript is running on the server, and this server is running on Windows. You can download the source code to check it all out.
HTML:
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 type="button" value="Rotate"
onclick="rotate(document.getElementById('angle').value);
document.getElementById('img').src =
document.getElementById('img').src + '?' + new Date()"/>
<img id='img' src="new.jpg"/>
</body>
</html>
Wednesday, June 11th, 2008
Category: Aptana, Ext
When Aptana released Jaxer, it really excited the community because you could now leverage your client-side skills on the server end of things. Rich Waters of Ext JS talks about how to leverage Ext JS on the server via Jaxer. The code created by Rich creates a Ext JaxerStore which allows you to run queries and directly put them into a Ext Store. This has the benefit of leveraging the same Ext language syntax you've become accustomed to for server-side processing by allowing Jaxer to wrap client and server-side communications up allowing either synchronous or asynchronous calls between the client and server.
I asked Rich why would developers do this versus doing a simple Ajax call to a template sitting on a server:
The template bit lets you generate the html before the page is served up so that no extra client side calls are necessary. I think the Ext template system is really slick and easier than even a lot of other existing server side templating systems. More or less it was also just an example to get people thinking about what could be done now that Ext can be run server-side.
The code snippet allows you to make the calls to Jaxer very easily:
JAVASCRIPT:
Ext.onReady(function() {
var store = new Ext.data.JaxerStore({
table : 'demo',
fields : [
{name : 'name'},
{name : 'phone'},
{name : 'email'}
],
readerConfig : {
sortInfo : {
sort : 'name',
dir : 'asc'
}
}
});
// create the Grid
var grid = new Ext.grid.GridPanel({
store : store,
columns : [
{header : "Name", sortable : true, dataIndex : 'name'},
{header : "Phone #", sortable : true, dataIndex : 'phone'},
{header : "Email", sortable : true, dataIndex : 'email'}
],
viewConfig : {
forceFit : true
},
stripeRows : true,
height : 350,
width : 680,
title : 'Jaxer Demo Grid',
renderTo : Ext.getBody()
});
});
which would then populate a grid control and render it accordingly.
The source code to this new functionality can be downloaded here.
Tuesday, June 10th, 2008
Category: Aptana, Cloud, JavaScript
Dougal Matthews has been playing with Aptana Cloud in a beta form. He wrote up this piece that walks you through the functionality with screenshots:
After creating a project it then is automatically available in the cloud options.
When you click on the project under the cloud menu you are taken through a (very easy to use) wizard for configuration. This runs your through a few steps, setting up a site name, picking a payment plan (the beta is free), payment details and so on. Most of these screens are fairly standard, however the service selection is quite interesting. I imagine these prices are not final, so just take them with a pinch of salt.
The payment scheme seems to be quite flexible and we can see a large number of services that are included, PHP being the main server side language at the moment, with Aptana Jaxer still being a beta… (Ruby of Rails is on the ‘coming soon’ list). The prices range from the cheapest being 256 MB ram and 5 GB hard disc for $0.99 a day, up to 2 GB of ram and 25 GB hard disc for $8.22 a day. Seems fairly reasonably priced.
After set-up is finished, it phones home and does some magic.
This is an important step for Aptana, as it not only gives us a good general cloud service, but it also gives you the perfect place to play with Jaxer. I am looking forward to seeing more.
Monday, April 28th, 2008
Category: Aptana, Cloud, JavaScript
![[image]](http://mowser.com/img?url=http%3A%2F%2Fwww.aptana.com%2Fsystem%2Ffiles%2Fimages%2Fcloud_logo_large_0.png)
Aptana have announced their cloud platform initiative, Aptana Cloud.
Aptana Cloud plugs right into your IDE to provide instant deployment, smart synchronization, and seamless migration as you scale. Aptana Cloud is ideal for developers who use scripting languages to create Ajax, Facebook, mySpace and all other sorts of Web applications.
The key is that this isn't a infrastructure play, which they clearly point out:
Aptana Cloud is architected to complement Cloud infrastructure providers like Amazon, Google, Joyent and others. To get started we've selected Joyent who serves up some of the largest of all Facebook apps.
This shows that their platform is designed to go meta, allowing you to deploy to various clouds in the future.
I think that the number one meme from Web 2.0 Expo last week was the "cloud", coming off of the excitement of Google App Engine. With Aptana Cloud we will see sophisticated tools to make us productive in the cloud. I am very excited to see that it won't be too long until developers will be able to build an application, hit DEPLOY, and be done. This is a huge win.
For developers:
IDE plug-in integrates Cloud development, deployment and management life-cycles right into Aptana Studio in either its standalone or Eclipse based editions Instant deployment of projects to Cloud One click sync your project to the Cloud, or provide fine grained sync control too Integrated service management consoles Configure desired memory size and disk size Develop and instantly preview remote files right inside your Studio desktop environment Subversion source control.
As Ajax developers, the vision of Jaxer in the cloud is very interesting too. The entire application using JavaScript, and deployed up into the cloud, all through the nice IDE.
I was also pleased to read that not only Ruby on Rails, but Python is on the docket. After developing Django applications and playing with Google App Engine, I would love to be able to use Studio for Python code too. Not that Emacs (X or GNU) isn't great, Steve!
Darryl Taft wrote:
Aptana adds extra value via IDE integration, deployment automation and active monitoring and notification services, Hakman said. “It's like the ease and simplicity between iTunes on your desktop and its connectivity to services on the Web,†he said.
For developers, the IDE plug-in integrates cloud development, deployment and management lifecycles right into Aptana Studio in either its standalone or Eclipse-based editions, Hakman said. "The ability to deploy stuff to the cloud from Eclipse is part of this as well."
Other developer features include instant deployment of projects to the cloud; one click can sync your project to the cloud or provide fine-grained sync control; the technology features integrated cloud services management, enables users to provision their cloud right from Aptana Studio, configure desired memory size and disk size, develop and instantly preview remote files right inside the Studio desktop environment, and includes Subversion Source Control.
Can't wait go get an invite. If you want one too, request an account.
Also, Aptana Studio just passed 1,5 million downloads. Impressive.
Monday, April 14th, 2008
Category: Aptana, Articles, JavaScript, Server
Davey Waterson of the Aptana Jaxer team has posted an article on using jQuery on the server-side with E4X and more that shows an example of server-side Ajax with a popular framework.
The article describes a polling application that features:
Using jQuery server-side to manipulate a DOM before it's sent to the client Doing some database / SQL interactions, server-side in javascript of course User sessions in javascript (Jaxer.session.set('status', status);) Using E4X on the server-side.
There are fun little features such as nuking portions of the page if the permissions call for it:
JAVASCRIPT:
$((status == 'voter') ? '.nonvoter' : '.voter').remove();
Since the application delivers no JavaScript itself, this would all work even if the user has JavaScript turned off, on a simple mobile phone, etc.
Thursday, March 20th, 2008
Category: Aptana, Examples, JavaScript
Dealing with file uploads can be a test of a Web framework. I personally long for the input type="file" to be improved with items such as multiple="true" for multiselection, let alone showing the status of the upload (20% complete).
The Jaxer folks have posted on Easy File Uploading using Aptana Jaxer which shows how you can tinker in JavaScript to get everything you need in a very simple way:
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.
HTML:
<script type='text/javascript' runat='server'>
var message = "";
for (fileCount=0; fileCount <Jaxer.request.files.length; fileCount++){
var fileInfo = Jaxer.request.files[fileCount];
var destinationFilePath = Jaxer.Dir.resolvePath(fileInfo.originalFileName);
fileInfo.save(destinationFilePath);
message += "<br>" + [
"Saved to : " + destinationFilePath
, "original filename : " + fileInfo.originalFileName
, "temp filename : " + fileInfo.tempFileName
, "contentType : " + fileInfo.contentType
, "size : " + fileInfo.fileSize
].join("<br />");
}
document.write(message);
</script>
Wednesday, March 12th, 2008
Category: Announcements, Aptana, Rails, Screencast
Aptana took over the RadRails open source project a few months back, and now have fully integrated it with Aptana Studio with the RadRails 1.0 release.
RadRails 1.0 runs as a plug-in to Aptana Studio. So in addition to all the Ruby on Rails IDE goodies and the integrated Rails shell command-line console, developers get the great HTML, CSS, DOM, JavaScript and Ajax features in Aptana Studio, which can run stand alone or within Eclipse to that all your other Eclipse tools can be right there as well.
The new version has a slew of new and enhanced functionality such as:
Rails 2.0 support JRuby support 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
You can watch a screencast of the product at work or a full feature list.
Aptana continues to add new functionality to its products as it tries to hit the "best tools for Web development with scripting languages" vision.
Tuesday, March 4th, 2008
Category: Aptana, Dojo
Yesterday we posted about Dojo and AIR and how the framework could be well suited for certain desktop applications.
Today we have Kriz Zyp talking about their Jaxer support and how you can use the Django template language, that Dojo recently added, to once again do its thing on the server side.
Kris tells us more:
HTML:
djConfig = {baseUrl:"/dojo/",usePlainJson: true, parseOnLoad: true};
</script>
<script runat="both" type="text/javascript" src="../../../dojo/dojo.js"></script>
dojo.require("dojo.jaxer");
...
</script>
Once this is done, Dojo should load in Jaxer, and you can utilize the library capabilities of the Dojo Toolkit on the server side. In particular, you can now use the DTL renderer as you would on the browser. The DTL renderer can take templates written using Django template language and render the templates based upon JSON data. If you are running Jaxer, you can view a demonstration of DTL rendering on the server by loading /dojox/dtl/demos/demo_Templated_Jaxer.html (make sure the Dojo Toolkit base URL is correct).
By using Jaxer’s capability to allow scripts to execute on both the client and server, we can utilize our Dojo Toolkit in both environments. On the server we can utilize many of the Dojo Toolkit’s features such as functional language features, math libraries, cryptography, dates, encoding, and more to improve development speed and code quality. We can use the same powerful features and idioms in both the browser and the server. An example of a practical way to use the Dojo Toolkit in both environments is to utilize the DTL renderer as described above to generate HTML on the server, and then use the Dojo Toolkit’s Ajax capabilities to dynamically update the page once it’s on the browser. For example: we could use the DTL renderer to display the comments in a blog, dynamically add any new comment the user makes at the end of the list of comments, and then send the comment to the server using Ajax.
It is important to note that Jaxer is not capable of transferring the programatically set event handlers for widgetsâ€â€it can only send the static HTML to the browser. This means you can use DTL as a templating engine to create HTML on the server, but the Dojo Toolkit client side widgets are still necessary if you want to use interactive widgets on the browser.
Wednesday, February 27th, 2008
Category: Aptana, Editorial, TIBCO
![[image]](http://mowser.com/img?url=http%3A%2F%2Fwww.networkmagazineindia.com%2F200609%2F20060933.jpg)
When we posted the last podcast on Aptana Jaxer, someone commented on the fact that Kevin Hakman was there, and "Doesn’t Kevin Hakman work for Tibco? What does he have to do with Aptana?".
Aptana has now come out with the news that they have hired Kevin:
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.
I asked Kevin a couple of questions about his move, comparisons between the companies, and the industry in general.
What similarities / differences do you see between pioneering heavy JavaScript on the client w/ GI and JavaScript on the server with Aptana
GI and Aptana's primary application models are different to serve different purposes similar to the way that Java has multiple presentation tier architectures for differents kinds of apps: Swing, SWT, AWT for application GUIs and JSP, JSF for generating web pages. With GI, the concept in 2001 when we deployed some of the first "Ajax" apps pretty much evolved from a need to migrate software-style GUIs to the Web and a technical approach summarized as "we like Java Swing, but not the JRE dependency, so let's do something Swing-like in JavaScript with a JavaScript VM of sorts and get data as XML / SOAP via the XML HTTP Request Object -- an oh yeah, make it Visual Basic-like easy to visually develop too". That led to what I call a "Client-Services" architecture where you have a full fledged JavaScript application running in a web page talking to back-end data services plus the WYSIWYG rapid development tools for which GI has been recognized as best in class in enterprise IT journals. With GI, you never really interact with the HTML page or its DOM. Instead there's a higher abstraction of application concepts and a model of the GUI, called "dual DOM" by some. The result is that the JavaScript applications are deployed into a webpage more like an applet, (except it's all in the same JavaScript memory space and there's no JRE dependency of course). This "Client-Services" architecture has been a great fit for many enterprises pursuing service-oriented architecture strategies.
Aptana Studio is clearly among the best-in class for the predominant model of Ajax development called "single DOM" where you work directly in the HTML DOM to describe elements within a page, then apply Ajax and CSS concepts to bring that page to life with interactive features. Aptana Studio meets the needs of Ajax developers working in this model extremely well. Whereas tools for web page development have historically focused on layout, image placement, styling, and JavaScript for roll-over and simple navigational assists, Aptana saw that with Ajax and the popularity of all the single-DOM model Ajax libraries like dojo, Ext, prototype, MooTools, and jQuery, the page was becoming increasingly programmatic in the client and needed tooling optimized for the programmatic page.
What excites you about Aptana
Aptana Jaxer is a very cool concept for all the JavaScript developers out there because they can now go boldly where no JavaScript developer has gone before--to the server-side. Sure Netscape had LiveWire back in the day, but remember there was no real DOM, no real CSS and certainly no XHR object at that time. Aptana Jaxer's genius is that is takes the same Mozilla engine we know and love in the browser, and puts it inside a server along with a bunch of handy Jaxer methods and properties to do server-side things like interact with databases, web services, session concepts, sockets and more. I personally love the ability to write a script that runs on the server, but call it from the client as if it were running on the client. In this case Jaxer handles all the sync or async communications for you transparently, and soon will provide end-to-end debug capabilities as well. We're also now working with Joe Walker of the DWR project to extend this kind of capability to remote Java objects as well through Jaxer. We're also investigating how to best interoperate with Microsoft’s .NET platform.
To some, JavaScript is not a preferred language and that's where things like GWT and DWR come in real handy. At the same time there's millions of developers who like the ease and mutability of JavaScript. Aptana Studio, with its JavaScript debug and type inference capabilities, and Aptana Jaxer with its server-side power enable all JavaScript developers to do much more, more quickly in the language we love to work with -- JavaScript! Thinking beyond the solid JavaScript programming tools in Aptana Studio today, things like visual WYSIWYG GUI composition and data-binding are clearly natural extensions. Not many people know that the Aptana team contributed to much of the Eclipse Monkey code which enables JavaScript to run within and communicate with Eclipse's APIs. This means that Aptana is extraordinarily well positioned to execute a first-class solution for WYSIWYG editing -- and further streamline the creation of Ajax web pages and full-featured Ajax applications.
Now you have been around JavaScript for awhile, what are you likes and dislikes, and do you have any thoughts on JavaScript 2?
Having been part of Ajax projects where we had single HTML pages running for 9 hours sessions with over 180 separate application modules you could load/unload during that time (and that was in 2001), the GI core team (Luke Birdeau, Michel Peachey, Jessee Costello Good, and myself) has had loads of experience in what it means to make highly scalable, full featured apps in JavaScript. Much of what we had to invent and implement in JS1.5 for the TIBCO GI Framework, things like object orientation for example and better memory management, is on the horizon for future releases of JavaScript. The primary pain of JS though, until recently, has been lack of great debugging, type inference, and code assist capabilities. What few people realize about Aptana Studio is that it not only code assists on the Ajax libraries you've loaded, it assist with the Ajax objects, classes, packages, functions and properties that you create too -- again a concept borrowed from the Java community, but with less programmatic overhead since its JavaScript.
Monday, February 18th, 2008
Category: Aptana, Framework, JavaScript, Podcasts
I had the opportunity to sit down with three fine gents from Aptana to discuss their recent launch of Jaxer, the "server side Ajax framework".
Paul Colton, Uri Sarid, and Kevin Hakman all sat with me to chat about things. I have already played with Jaxer, and created the Google Gears wrapper which can be used seemlessly for use cases such as "If the user doesn't have Gears installed, just do it on the server".
We discussed a lot in the twenty odd minutes including:
Where the idea for Jaxer came from The difference between a server side JavaScript framework and Jaxer (since there are many of them!) How Jaxer works (think of a headless Mozilla browser) Side effects of going this direction How developers are using it How does your architecture change if you are using Jaxer? How can you talk to code in Java and other languages? How JavaScript 2 fits into the picture What about deployment?
A lot of good stuff. Thanks to the crew for taking the time to chat with me. What other questions do you have for them?
We have the audio directly available, or you can subscribe to the podcast. We also have the video in high def here, or in normal def right below:
Next Page »
![[image]](http://mowser.com/img?url=http%3A%2F%2Fajaxian.com%2Fwp-content%2Fthemes%2Fajaxian%2Fimages%2Ficon_feed.gif)
![[image]](http://mowser.com/img?url=http%3A%2F%2Fmedia.techtarget.com%2Fdigitalguide%2Fimages%2FMisc%2Fplatinum_site_sponsor.gif)
![[image]](http://mowser.com/img?url=http%3A%2F%2Fajaxian.com%2Fimages%2Fpragmatic-ajax-book-cover-sm.jpg)
