jerakeen.org

An astonishingly good implementation of web-based presentation software. Very hard to believe it’s written in JavaScript.

http://280slides.com/Editor/

Makes all the Rails JS helpers work with jQuery, rather than prototype

http://ennerchi.com/projects/jrails

REALLY GETTING ANNOYING NOW

http://www.russellbeattie.com/blog/server-side-javascript...

http://www.codepress.org/

One of the things that’s been annoying me about JavaScript recently is the inability to only catch certain classes of exception, as in Java or Python, for instance. The try {..} catch(e) {..} block has always seemed too inclusive. But recently Ash found a crazy syntax in SpiderMonkey that lets us only catch certain exceptions.

try {
  // something that can throw
} catch(e if e.bar == 'foo') {
  // an error is only caught here if it has a 'bar' property of 'foo'
} catch(e if e.bar == 'baz') {
  // there can be different catches for different conditions
} catch (e) {
  // otherwise it's caught here. Without this block, the error would fall
  // through the 'try' and be re-thrown.
}

I haven’t bothered testing this in Internet Explorer (or any other web browser for that matter), because I’m only interested in server-side JavaScript execution at the moment. It works in at least recent SpiderMonkey CVS and Rhino 1.6r6, not sure about earlier versions.

Rails-style routing for Helma. I find the default Helma URL dispatching very annoying - this is far better.

http://grazia.helma.at/pipermail/helma-user/2005-November...

http://marijn.haverbeke.nl/highlight/story.html

mod_js is an Apache module written by Ash Berlin and I that embeds the SpiderMonkey JavaScript engine and lets you run JavaScript code on the server as CGI scripts. As you’d expect, it’s very early, but is good enough to compile scripts, run the JavaScript, and print the output to the client. mod_js is licensed under the GPL3.

http://www.berniecode.com/blog/2007/03/08/how-to-debug-ja...

javascript charting framework. Shiny.

http://www.solutoire.com/plotr

I’m finding E4X to be one of those weird technologies that is alternately utterly wonderful and incredibly irritating. The ability to treat XML data as any other JavaScript data structure allows very fast app development and messing around, but every so often I find myself amazed at how awful the syntax is.

Today’s irritation is about E4X attributes.

// a perfectly normal E4X object.
var myXML = <xml foo="bar">content</xml>;

// the attribute with value 'bar'
var myAttribute = myXML.@foo;

Easy. I love this stuff. Unfortunately, Zimki, my company’s product, uses uneval to store complex objects, and the myAttribute variable there would count. uneval won’t produce JSON but it does produce a string that, when run through eval, will probably produce the original data structure, and we store that string in a database to store object.

Not so for E4X nodes. Playing in the SpiderMonkey JS console,

js> uneval( myXML );
<xml foo="bar">content</xml>

js> uneval( myAttribute );
bar

The first one is fine. That string will eval nicely back to the original E4X object. But the ‘bar’ there isn’t valid JavaScript - eval won’t restore the original object. In fact, had the original XML been something like:

<xml foo="delete_all_zimki_data()">bar</xml>

and we’d tried to use eval/uneval to store this XML, we’d have executed the attribute as JavaScript. Ick.

Unusually, Rhino handles this much better (normally I find Rhino lags in features..):

js> uneval( myAttribute );
<>bar</>

Not really an attribute node any more, but at least it’s valid JavaScript and won’t destroy my server.

I don’t even have a good solution for this. Right now I’m fudging E4X nodes in the storage engine, but I really feel that attribute nodes should uneval to something a little more sensible. Perhaps I’ll be able to produce a patch to SpiderMonkey, if I have time..

ooooh, I like this. Steal methods from the array namespace and use them on the arguments object..

http://www.danwebb.net/2006/11/7/a-low-down-dirty-goblin-...

Utterly nifty - DTrace embedded in JavaScript. Via dwilson

http://blogs.sun.com/brendan/entry/dtrace_meets_javascript

JavaScript Error object stack manipluation

http://weblogs.mozillazine.org/weirdal/archives/005505.html

http://www.manageability.org/blog/stuff/javascript-in-the...

Utterly lovely. Java/Rhino based JavaScript-using server

http://www.bluishcoder.co.nz/2006/07/javascript-continuat...

I gave a talk on E4X. In a Just and Decent world, I wouldn’t have to write a blog entry on this, because there would be a nice front page to jerakeen.org that listed all the recent things I’ve done, with the option to subscribe to RSS (or whatever) feeds of various subsets. But I’ve been too lazy to write this so far, so I’ll just link to it here until I get django to do what I want.

E4X is a lovely extension to JS (well, compared to messing with the DOM, and it’s in core, so embedded users get it too), despite its crazy inconsistent syntax and annoying brokeness in Firefox. Fortunately, I don’t have to care about web browser-based JS implementations, so I get to use it, and you don’t..

http://jerakeen.org/talks/e4x/

server-side javascript, running on a Java server

https://phobos.dev.java.net/

Having played around with the JavaScript string type some more, I think I understand why it acts as it does. I’m a Perl monkey normally, so I’m not used to the concept of immutable strings, but JavaScript strings are immutable. Playing with the === operator (approximately, ‘is this the same object’) gives:

js> "a" === "a";
true
js> "a" + "b" === "ab";
true
js> "ab".replace(/./, "c") === "cb";
true

but

js> new String("a") === new String("a");
false

If strings were to magically upgrade themselves to objects, they’d change behaviour - previously equivalent strings would suddenly not be equivalent. Likewise, suppose this worked:

var a = "string";
var b = "string";
a === b; # true
a.foo = 1;

Shoud a still be equivalent to b? If not, a clearly isn’t immutable, as we’ve changed it. But if it is, then we’ve chanaged b at a distance - it’s grown a foo attribute.

Still all very annoying, of course, but I understand why now.

Recently, I mentioned a peculiar difference between uneval and toSource. Specifically (using the SpiderMonkey JS console):

js> uneval("");
""
js> "".toSource();
(new String(""))

"" and new String("") are different types of objects. The first is the basic string type, and only really has a value. The second is a full Object, that happens to have a value. However, it turns out that if you treat a basic string type as an Object, say by putting ‘.’ after it in an expression, the SpiderMonkey runtime will implicitly promote the string to a String. Hence, "".toSource() promotes the string object, then calls toSource on the new String object.

Annoyingly, the String Object doesn’t hang around, it’ll get thrown away as soon as you’re done with it. This leads to the weird case that you can set attributes on a basic string type (because it’ll get promoted to an Object, and Objects have attributes) but they don’t stay set (because the Object you’ve set them on gets thrown away as soon as the set call finishes).

By the way, all of this applies very specifically to the current CVS trunk SpiderMonkey. I don’t know what most web browser engines do with strings, so don’t assume this applies in, say, Internet Explorer. But I’d be interested if someone wants to find out and tell me…

http://badgerfish.ning.com/

how to use javascript regular expressions. The bit I always have to look up

http://www.webreference.com/js/column5/methods.html

http://wiki.script.aculo.us/scriptaculous/show/Prototype

http://bob.pythonmac.org/archives/2005/12/05/remote-json-...

http://dean.edwards.name/IE7/overview/

Javascript templating language. Completely insane.

http://trimpath.com/demos/test1/trimpath/template_demo.html

Rui liked this a lot

http://www.apress.com/book/bookDisplay.html?bID=10042

a ⊘GUI efffects toolkit built on prototype.js

http://wiki.script.aculo.us/scriptaculous/show/HomePage

Holy cow, this is gorgeous. I especially like the trick for permalinking

http://www.endoflow.com/ibrowser

The Mozilla Spidermonkey javascript engine

http://www.mozilla.org/js/spidermonkey/

..and not a single non-ascii character on the page.

http://www.crockford.com/JSON/example.html