John Resig on Javascript as a language

In his JavaScript as a Language blog post, John Resig writes that Javascript is ready for its next phase, breaking out from its traditional habitat inside the web browser. In this regard, he thinks two projects have really stood out as having a lot of potential. Rhino on Rails and Helma.

John says about Helma: "This web application framework is a long standing stalwart of server-side development with JavaScript (again, using Rhino). Surprisingly, it’s managed to fall through the cracks with just about every JavaScript developer that I know. I recently noticed it, and after some startup friends of mine revealed that they’re developing an application based on it, I became convinced that we’ll be hearing about this little framework in the upcoming months."

Of course, Javascript has been used on the server-side in many products ever since Netscape used it in its server-side offerings. What makes Helma special, is that it is for "Javascript as a Language" what Django is for Python and what Rails is for Ruby. In fact, Helma probably was the first Rails-ish web framework, offering an agil development approach and code-less mapping of objects to database tables, long before there even was such a thing as Rails.

At the time of Helma's first release the problem was that Javascript was deep in its dark age. Hardly anybody took Javascript seriously as a language. In 2001, the manifestos for a Javascript enlightenment were already in place, though. David Flanagan released the fourth edition of his Rhino book, which cleanly separated the core Javascript language from the client-side Javascript and Douglas Crockford wrote his now famous "Javascript: The World's Most Misunderstood Programming Language" web page, but not many noticed.

Back then, I thought that Javascript was so much stuck in browser-centric preconceptions that we could never redefine what "Javascript" was perceived as and that we should switch to using the language's original project name "Mocha" when talking about it outside the web browser. Later, the Ajax hype came along and proved that it is possible to redefine the way the language is perceived. Generally, Javascript is still seen as a client-side language, but I think we know now that this can change quickly :-)

Rhino on Rails

Steve Yegge has posted more details on his port of Rails to Rhino and his thoughts on Rhino.

"When you start digging into Rhino, you find unexpected depth. JavaScript (unlike Perl, Python and Ruby, at least today) actually has a real specification, and Rhino follows it rigorously, aiming for complete SpiderMonkey compatibility within the bounds allowed by the different language platforms. Rhino also offers rich configurability, has well-defined multi-threading semantics, has a full set of hooks for debugging and profiling, and much more besides. There's a lot under the hood."

About building on Rhino, he says... "keep in mind that this is server-side JavaScript we're talking about, and on the JVM to boot. So libraries aren't an issue; there are plenty. And browser incompatibilities aren't an issue either - there's only one Rhino, and it works as advertised. But we've been able to go a step further and make some fundamental extensions that have made it almost Ruby-esque."

Interestingly, the example he picks is regarding the enumeration of methods and properties extending the Object and Array prototypes... "in client-side JavaScript there's currently no way to define a property that's non-enumerable, which implies that you can't add new functions or properties to Object.prototype, since they'll suddenly start showing up in your object literals (which are JavaScript's hashes, more or less). But in Rhino you just create a Java method that calls into the Rhino runtime to define non-enumerable properties, and you can extend Object.prototype to your heart's content. So we went wild, and added pretty much every interesting Ruby (and Python) built-in method on the built-in classes (Object, String, Array and the like)."

Of course, with the dontEnum method the way it's implemented in Helma, you can additionally also do this in plain Javascript. (Did this feature make it back into Rhino with the Helma patches Norris Boyd recently committed ? Not sure.)

Steve Yegge says that quite a team inside of Google has gathered by now, investing their 20% time into future Rhino development. Very Cool! I think that's probably the best news about the whole story - because on the Rails port side of the story, it seems he didn't really address the most interesting part, ActiveRecord, and they are instead planning to go in the direction of Hibernate.

He makes it clear that the project is not at a stage where it could be open sourced, and that that won't change much for at least a year. It looks like they will keep their eyes open for Rails-ish web frameworks of the likes of Helma.

Hey Steve, you can find it here: http://helma.org/ :-)

So, I think this is great news for Rhino, and as a result great news for the Helma project.

Release Candidate 3 of Helma 1.6.0

Amongst many other improvements, this release includes the new parameter collections req.postParams, req.queryParams, req.params, and req.cookies in addition to req.data, and adds support for monitoring file upload progress.

Check out the updated change log for details and go download it now!

ECMAScript 4 Reference Implementation

ES4 is getting a reference implementation written in Standard ML . The Ecma TG1 group is providing pre-releases early and often to solicit continuous feedback from the ECMAScript community.

As an aside, the Ecmascript language now has its own home on the web:
http://www.ecmascript-lang.org/

Antville Summer Of Code 2007

Tobi dives in to update the Antville code base: "Thus, this summer 2007 shall be taking place under the sign of Antville, lest a sunny stream may enlighten ye good ole program code, and may warm the hearts of the Antville community. Welcome to Antville Summer Of Code 2007 ."

Helma 1.6.0-rc2

In case you missed it: The second release candidate for Helma 1.6 is out for your testing pleasure.

Using H2 with Helma

Maksim Lin shows how easy it is to use H2 together with Helma , even as an embedded database in the same JVM:

..."just drop the h2.jar into helmas lib/ext folder, restart helma, pop the connection details into my applications db.properties and hey presto!"

Then, just change the connection URL in your helma apps db.properties to...

jdbc:h2:/data/h2/col

..."and bam! your H2 db is now running in the same JVM process as helma"

>>> Helma warped around existing db schemas