I’ve begun messing with a number of different technologies all around the same time – namely, RequireJS, CoffeeScript, and FuncUnit. I’ve managed to reconcile them with one another for the most part, which is quite fun.

RequireJS I’ve actually been tinkering with to varying degrees for a few months now, and am finally starting to put into practice across the board at CrossLoop. I’ve got a few AMD modules in use, and a number of other scripts which RequireJS loads just as well. I’m in the process of breaking a lot of complexly-ordered script tag inclusions into neat-and-tidy cascading dependencies via AMD and RequireJS’s define() and require() functions.

I started work on an article on the topic of RequireJS a couple months ago, and hope to resume writing it in the next couple days. Interestingly, RequireJS has gone through some changes (and the CommonJS list has seen some activity revolving around “casting out” RequireJS or unlisting AMD as part of the CommonJS spec/draft/whatever. (some of this revolves around treating AMD as an “authoring format” versus as a “transport format”, which is an important differentiation to some. The feasibility of the dynamically-generated [with dependencies] transport proposition is questionable…) There is some feeling the two are irreconcilable. I’m not of that opinion, but I may not be in a good position to knowingly opine. So I won’t go into much more detail here than to say I’m still digging RequireJS, and that it’s helping me to organize my day job code better.

I’ve recently tried briefly to rewrite some of our CSS as Sass, and I’ve come to a stop. I think what would be more productive right now is a complete rewrite/reorg of the CSS as-is to shorten the files from 1000+ lines to something more manageable. We can always @import additional files, and RequireJS can stitch together CSS files once I come up with a proper build/release process and we automate it for production! (right now we’re entirely manual)

I’ve also finally gotten round to writing some unit tests for much of the JS code I’ve written for CrossLoop. I’ve been using QUnit for this, which is handy enough for most basic work. Having previously used JSSpec thoroughly, I do miss proper setup/teardown across a group of related tests, and nesting these sorts of things would allow me to keep things much DRYer than I’m ending up doing currently. QUnit has “modules” as declared with the module("module name") call, but it doesn’t really logically group code together, merely bookends code between calls to module(). Meh.

The unit tests I’ve written thus far have all been written in CoffeeScript and loaded into the page via RequireJS’s “cs” plugin (require(["cs!test1", "cs!test2"], $.noop) for no post-test code, which is what I’ve been doing) Seems to work well and has given me good practice in writing concise CoffeeScript, as well as discovering gotchas like the “isnt is not is not” comment I made after writing more than a few asserts where I wrote something like assert x is not -1. What this actually resolves to is assert(x == !-1) which is the same as asserting x == 1, which it frequently wasn’t. (you may have guessed I was checking indexOf on strings, etc)

The CoffeeScript plugin for RequireJS is available right on the main site and works just like any other plugin; put it in the regular modules dir, no need to load it manually, etc.

I can definitely see myself writing more CoffeeScript going forward, likely it’ll be the source language for txtwax, a text adventure game library I’ve been putting off writing for some time now. It may also provide a coffee/node backend for txtwax servers. I really love a number of features in CoffeeScript, such as automatic local variables, array comprehensions, implicit returns, decomposition assignment, multiline strings, string interpolation, heregexes, function syntax, function binding, improved switches, ranges, postfix conditionals… the list really does go on a bit. Anyone who hasn’t played with it, you have no reason not to do so, this language is useful right now. Tests are the perfect use case to dip a toe in the coffee (!), since even if you do worry about CS stability or whatever, they’re not user-facing.

I do appreciate the “fixture” in recent versions of QUnit, which allows you to throw arbitrary markup into the DOM temporarily, with the understanding that QUnit will clean it up after you’re done with it. Now if only there was a way to tester higher-level application-level functionality in JS… waitaminnit, that’s what FuncUnit is for!

FuncUnit (a product of JupiterIT, the lads behind JavaScriptMVC) builds on QUnit, incorporating their Syn synthetic events library for typing in fields, tabbing into and out of fields, hovering over and dragging and dropping. Lots of heavyweight event stuff that might otherwise take quite a bit of hacking on your own to figure out. On top of this, FuncUnit adds support for opening pages in separate windows and navigating through the contents of the window via S(), a selector for running Syn methods identical to jQuery’s self-titled function or $. Like jQuery, FuncUnit uses the Sizzle selector engine for this purpose.

FuncUnit seems great, especially when you add in the ability to record tests via FuncIt, (a Selenium IDE-like recording environment) the ability to play back tests headless, (without a browser – via Resig’s env.js to mimic a browser for continuous integration) or the ability to drive Selenium RC for true multi-browser/platform automated testing. I’ve yet to give it a real run for its money, because I’ve hit a speed bump I’ve yet to find a way around, which is transitioning from http pages to https, or vice versa. Many pages, particularly logins, make this jump and I don’t believe a remote-controlled page using S() can retain control after the page switches protocols. I’m very happy to hear a workaround, though! (I’d imagine env.js or Selenium-driving wouldn’t have this problem, but I’d like to be able to run the tests raw in the browser as well..)

I also recently started using Vimperator. This software, combined with the speed Firefox 4 brings with it, have me switching back to Firefox as primary browser, both for development and general browsing as a user. Vimperator takes getting used to, for sure, but if you’re a Vim head like I’ve become over the last 6 months or so, you may never see browsing the same again. Quick hints allow you to jump to fields/click links/submit forms faster than ever before and without a mouse. Your fingers will fly, taking you from buffer to buffer (tabs), zooming with new ease, and adding macros and mapping arbitrary commands to keys. All of this is retained in a .vimperatorrc file, which feels right at home to a Vim user! Modal browsing is great, and shedding even more of the browser’s chrome is liberating as well. I occasionally still like to browse with tabs visible (:set gui=tabs) and haven’t found a handy way of launching Selenium IDE via a keybinding but am otherwise nice and clean with gui=none.

There’s a knockoff for Chrome called Vimium, which is uh… fun but not nearly as powerful as Vimperator, due to limitations in Chrome’s JS plugin architecture, I assume. There’s a newer version of Vimperator called Pentadactyl, but I haven’t found a reason to switch and some reasons to stay, such as support for apptabs in Firefox 4 (:set apptab toggles a buffer as one, and app tabs can’t be accidentally closed via d the way normal tabs can)

Speaking of Vim, I’m currently trying to find the best TextMate-like “select some text and wrap it with delimiters” plugin. This should allow me to select text in visual mode and wrap it with quotes, single or double, parens, curlies, asterisks, underscores, or what have you. Please let me know if you know of one! (would like to be able to edit the delimiters or have them correspond to those recognized by % when jumping to matching delimiters.) I’m also still really interested in getting CommandT working under Windows (and Linux for that matter) so any tips there are welcome as well.

I also finally jail broke my iPod Touch 2nd or 3rd gen, whatever it is. I’m almost ready to toss the damned thing, it’s so slow. jail breaking allows me to lock orientation and enables multitasking, though the device seems to crash under the weight of more than one app in memory at a time. Haven’t really used Cydia much, but if I do I’ll surely blog about my experiences with it. I can tell you, however, that the process of jail breaking (I used red sn0w) is needlessly littered with hurdles and makes the user feel silly at best. I’ve mostly been neglecting my iTouch in favor of my iPad, though.

Really excited to see the TouchPad (and Pre 3!) in person. Also excited about improved notifications in newer iOS, but multitasking in webOS is just so much nicer.

Make an XHR request (in this case a POST) to a service (in this case a Spring authentication URL) that redirects to some other URL which itself provides a JSON body indicating success or failure of login.

So again, super simple:

1. POST to URL A. This responds with a 302 to URL B.
2. Browser auto-GETs URL B, which contains a JSON content body.

What Firebug sees, however, is this:

1. POST to URL A. This responds with a 302 to URL B, but also appears to return a JSON body.
2. Browser auto-GETs URL B, which appears to have no body at all.

And here’s what it looks like:

I wonder why it’s mixing the responses like this… has anyone else seen this?

Finally managed to get pathogen working on my Windows work box (remotely) today, which made me very happy. It was all being held up by a problem resolving https versions of repo URIs, in that all my submodular plugins under bundle/ had failed to clone when the first https guy was reached. Be aware of this issue if you’re gitifying/pathogenizing your vim setup.

I just barely cracked the virtual cover of Stoyan Stefanov’s JavaScript Design Patterns but am liking the tone quite a bit so far. I’ve certainly mentioned elsewhere that Stefanov’s previous book, Object-Oriented JavaScript, is my favorite book on the core language, so I have high expectations for this one.

Very excited to see what happens with the new webOS stuff, though like many others I’m a little upset they’ve pulled the plug on OTA 2.0. Gotta check out Enyo over the weekend. If you’ve already played with it, please share your opinions in the comments! Anyone heard even a rumbling on carrier rumors?

I also briefly toyed with Jo, a cool [though in-flux] cross-platform mobile JS framework that’s easy to learn but fairly versatile. Hoping to leverage it (or similar) on a prototype app for CrossLoop Search.

Have used RequireJS more at work this past week and am very happy with the ease of use. Next go round I’ll likely throw together a build file. Right now it’s just CLI optimizer, and I haven’t tried the new node-based version yet.

I see a lot of hubbub (some of it bordering on unfriendly) on the CommonJS list, but I’m glad there’s more discussion of modules in-browser these days.

I tried to take notes on every presentation or workshop, but to tell the truth I wasn’t much good after lunch, as I’d not gotten much sleep the night before. These notes were taken using Simplenote on my iPad and Notational Velocity (a rad Simplenote client) on my MacBook.

Most examples we watched are available at https://github.com/joyent/node-camp.git

There seems to be an awesome collection of links on the camp site as well: http://camp.nodejs.org/resources.html

Morning

The morning started with a bevy of power issues from the daisy-chained strips, but this was settled before lunch. Wi-fi was very good throughout.

Ryan Dahl

@ryah was up first with a great little demo, building a chat server and client in about 10 minutes. Hilarious as always, he discussed standard out using console.log, the availability of setTimeout in node, and talked about net and http modules.

Of interest was hearing that require can take a version # if need be, but managing in package.json ensures existence of modules before runtime.

• http.createServer takes a callback which itself takes request/response params, returns server object.

• net.createServer takes callback with socket param

• socket can accept events using on() method

• socket has properties such as remoteAddress, etc for obtaining info about the connection

• on() can take event names such as “data”, “end”

• end event is useful for tracking data/cleanup

• response.write(), response.writeHead(), response.end()

• You must bind to a port before a server will continue running.

• Concurrent connections are not a problem even out of box – maybe load issues?

Isaac Schlueter on npm – the node package manager

This presentation started slow but became interesting a couple minutes in.

• npm can be used for handling dependencies for local projects, specifying tests, start scripts – all in package.json

• start script is actually a line of shell command to run

• Interesting commands: npm and various subcommands… ls, adduser, install, installed, publish, activate (jump to a version)

• npm start loads dependencies before running start script from package.json

Next up was Guillermo Rauch (@rauchg) on express (billed as just routing in the agenda for some reason?)

Express

This was a quite in-depth quick tour of Express. We built a blog app with express, using jade, and testing with Expresso was covered in brief, or at least mentioned. (maybe someone could school me on what went down when I had my head turned away)

• express routes are like Sammy/Sinatra, using HTTP verbs with patterns to match

• next passes on control to next piece of middleware

Jade is very similar to haml:

• allows filters like haml (markdown!)
• uses “-” to jump into js for condition lines etc, no blocks of js needed, just indentation
• no % before tagname (haml uses this)
• multiline text needs to be prefixed with “|” on each line (haml doesn’t need this)
• “=” will escape html
• “!=” will not
• jade has layouts, partials like Rails

• in template, this refers to app

• Express routes receive params like Rails in request.params

• has response.redirect, response.render methods, similar to Rails

“fs” module can be used for dealing with static files, has both sync and async methods.

Expresso comes with Express now (have I got this right?) You can use make to run tests? Comes with rcov-like tool called test-cov. Didn’t get much detail about this.

express command works similar to rails command, generates an app directory, etc. Interestingly, you can’t use this outside an existing directory.

Tim Caswell (@creationix) was up next.

socket.io and the game client

Tim built a cool demo, the beginnings of a game, really. You can see it on https://github.com/joyent/node-camp/tree/master/hexes. He tried to bring some interactivity to the git-together (sometimes I kill me) by having people shout out ideas for games, etc. There were one or two volunteers with ideas, but mostly the room was silent.

People’s shyness (in large groups) seems to have kept them from participating much in sessions like this. (it certainly kept me from doing so…)

The main thing I got out of the talk was that socket.io (which seems freaking awesome) falls back to long-polling, Flash, XML request, iframe and maybe even more options if WebSocket is unavailable in the browser (should work everywhere)

Matt Ranney on Redis

His company is doing Voice over HTTP ha! Crazy right? He was majorly enthusiastic about Redis, I can tell you that!

Redis is “like” good for session, shared data across, “like”, many processes, great for when you outgrow one node.

Quick note: Ranney totally reminds me of Jeff Haynie. Not totally sure why. I was very happy to finally hear someone else pronounce JSON “Jason”! Go team. And stuff.

Ranney’s redis client ensures client requests finish in order, so you can embed a callback in only the last request(this is accomplished via combining all queries into one http request, piped together)

• Redis is straight key/value, simple client (redis-cli) with GET/SET commands

• special functions for pubsub, storing/getting entire hashes

• harder to make work as primary db

I was glad to hear him speak about redis as a great tool while still mentioning its downsides.

After this we broke for lunch, and my note-taking and consciousness-maintaining abilities suffered noticeably. The following are my afternoon notes:

Afternoon

Cloud9 IDE with Rik Arends

Cloud9 is working on a potentially very cool product, an in-browser IDE along the lines of Bespin, or Palm’s Ares, but with maybe more possibilities in store.

Unlike Bespin, Cloud9 IDE runs on a node server instead of python, and it uses DOM manipulation instead of canvas. Supposedly, they’ve run tests and shown that their DOM stuff works faster.

There was also talk of the projects merging, though I’m not quite sure if this is more of a fork in the project or what parts of each project will remain.

Cloud9 has a full debugger, just like Ares. It has many keyboard shortcuts, including different ones between win/Mac. We were told the debugger in V8 provides most internal functionality.

The tabbed editor in Cloud9 looks kind of like the tabs in Chrome. It looks pretty good, but it was hard to make out much in my state while also taking notes.

• Cloud9 will run locally, and eventually [the company] Cloud9 will be hosting projects, well, in the cloud, obviously!

• Cloud9 [the IDE] already supports Textmate themes, and has some keyboard equivalents with that lovely editor.

• Kinect driver for node? Demoed a live scan of the room using a Kinect sensor bar. “completely useless, but fun!” What, if anything, this has to do with the IDE is beyond me, but it was definitely fun. The Cloud9 guys have gotten WebGL working on the server side, rendering data live to the browser somehow.

The only hitch I remember seeing was a stop button that wouldn’t work, which Rik responded to promptly – “I do have to mention we’re beta”. And somehow, I was the only one laughing? No one has a sense of humor!

• Realtime source editing – builds off V8 internals. This was slick, the browser demoing his server-rendered WebGL code showed a change in his code immediately after he saved the file, without having to reload the browser. Not really sure I understand what happened still, though.

• Github account: https://github.com/ajaxorg/cloud9

• Jslint coming soon, currently matches curlies

• Autocomplete coming soon

• Collab coming in the future… Great for pair programming

• Local will continue to work well (open source), saas will focus on integration with other services etc

• Works with git already

• Ruby a next target language to code/debug against

More Socket.io

@rauchg was up again to talk about socket.io, but by this point I was fading fast. I have very vague notes about pub sub in socket.io, but nothing worth repeating.

One thing that did break through my haze of sleeplessness:

Someone recently commented that Twitter IDs may be reaching a point where they’re too big for js to handle as numbers. Does this break lots of current js clients? Haven’t followed up on this just yet, but it was interesting.

That’s all I’ve got, I didn’t make it to the presentation on deployment. I sure wish I had!

Oh, and much of the event is or will be available online as videos for everyone at http://www.ustream.tv/channel/node-js-camp.

Thanks for the great day to everybody at Joyent and the other contributors and attendees, and thanks to @ryah for putting node out there!

While nothing is perfect, Mojo has a lot of things going for it: consistency of API let’s users quickly ramp up to speed any time a new widget is added or simply learn more of the large existing set; a deep, thorough set of events for every widget allows you to hook behaviors on widgets at any point in their lifecycles; a growing list of services on the device means you have access to almost all the functionality you see Palm’s own apps exhibiting; and Prototype is quite powerful in its own right.

That last point is as good a place as any to dive in. Prototype is, like MooTools or Base, essentially a class system and set of utility functions. While libraries like jQuery focus solely on DOM, Prototype and its kin exist to facilitate extension of existing classes and the creation of new ones. It’s this presentation of the classical inheritance pattern that allows Prototype to shine. Prototype and similar libraries allow you to inherit from existing classes much more easily than with raw JavaScript.

Palm’s Mojo framework takes distinct advantage of this functionality by building a vast library of classes you can make use of: from the most important widget, list, to buttons, spinners and WebViews, Mojo has a lot of UI elements available for developers to take advantage of when building applications. In addition to the set of widgets available, Mojo presents most of its additional functionality through a unique twist on the MVC paradigm.

The view, of course, is represented in the DOM. Controllers manipulate the DOM as well as manage all the scenes and data management assistance for the closest thing to Ruby on rails is controllers. Assistants have various lifecycle phases such as setup activate, deactivate. You can hook into these phases and fire off whatever functionality you need. For instance, making a request of the GPS service. Once this on-device service has responded, you can make additional requests. For instance hitting a web service and passing in the GPS data as part of the parameters. In Mojo models are represented by the transient in memory objects connected to widgets. A model might contain, for instance, an array of elements which is used to populate the DOM in terms of the list widget. By updating the status of these structures in memory and then calling the modelChanged method widgets will automatically rearrange the DOM as needed.

Ares is an in-browser IDE (think Eclipse or Visual Studio in the browser!) that let’s you drag and drop to design scene layouts, hookup widgets, and assign initial model properties and attributes for these widgets. It also contains a full- fledged debugger (hooking into the emulator via Java applet) with breakpoints and interactive console a la Firebug. These tools are amazing, and sped up the development of Taxi Magic for webOS significantly. There’s even a standalone version of the debugger, which let’s you debug non-Ares projects!

This kind of advanced functionality is what Mojo is all about. I’ll be blogging about Palm, Mojo, the future of webOS (thank you, HP!), and my own experience with Mojo and Ares and related topics more soon.