developer toolbox

http://wiki.github.com/ry/node/modules

http://giantflyingsaucer.com/blog/?p=894

http://wiki.github.com/ry/node/using-eclipse-as-node-applications-debugger

Google Chrome Developer Tools

This project provides debugging tools for developers writing applications that run on Google Chrome or its open-source version Chromium. The tools enable you to debug JavaScript inside these browsers over the TCP/IP protocol. If you are looking for information on the Google Chrome browser built-in Developer Tools, please have a look at this official primer.

• A ChromeDevTools SDK that provides a Java API that enables a debugging application to communicate with a Google Chrome browser from the localhost using the TCP/IP-based Google Chrome Developer Tools Protocol.
• An Eclipse debugger that uses the SDK. This debugger enables you to debug JavaScript running inside Google Chrome tabs from the Eclipse IDE.

As the SDK and Eclipse debugger are written in Java, this project is of most benefit to developers who use Java tools for debugging web applications inside Google Chrome. You can use the SDK to write your own debugger that uses the protocol to communicate with Google Chrome.

http://github.com/mhevery/jasmine-node

http://static.creationix.com/node_docs/browser/#api

http://github.com/ry/node_docs

http://github.com/ry/node_postgres

http://techno-weenie.net/2010/1/15/node-js-for-my-tiny-ruby-brain

http://simonwillison.net/2009/Nov/23/node/

Node.js is genuinely exciting

I gave a talk on Friday at Full Frontal, a new one day JavaScript conference in my home town of Brighton. I ended up throwing away my intended topic (JSONP, APIs and cross-domain security) three days before the event in favour of a technology which first crossed my radar less than two weeks ago.

That technology is Ryan Dahl’s Node. It’s the most exciting new project I’ve come across in quite a while.

At first glance, Node looks like yet another take on the idea of server-side JavaScript, but it’s a lot more interesting than that. It builds on JavaScript’s excellent support for event-based programming and uses it to create something that truly plays to the strengths of the language.

Node describes itself as “evented I/O for V8 javascript”. It’s a toolkit for writing extremely high performance non-blocking event driven network servers in JavaScript. Think similar to Twisted or EventMachine but for JavaScript instead of Python or Ruby.
Evented I/O?

As I discussed in my talk, event driven servers are a powerful alternative to the threading / blocking mechanism used by most popular server-side programming frameworks. Typical frameworks can only handle a small number of requests simultaneously, dictated by the number of server threads or processes available. Long-running operations can tie up one of those threads—enough long running operations at once and the server runs out of available threads and becomes unresponsive. For large amounts of traffic, each request must be handled as quickly as possible to free the thread up to deal with the next in line.

This makes certain functionality extremely difficult to support. Examples include handling large file uploads, combining resources from multiple backend web APIs (which themselves can take an unpredictable amount of time to respond) or providing comet functionality by holding open the connection until a new event becomes available.

Event driven programming takes advantage of the fact that network servers spend most of their time waiting for I/O operations to complete. Operations against in-memory data are incredibly fast, but anything that involves talking to the filesystem or over a network inevitably involves waiting around for a response.

With Twisted, EventMachine and Node, the solution lies in specifying I/O operations in conjunction with callbacks. A single event loop rapidly switches between a list of tasks, firing off I/O operations and then moving on to service the next request. When the I/O returns, execution of that particular request is picked up again.

(In the talk, I attempted to illustrate this with a questionable metaphor involving hamsters, bunnies and a hyperactive squid).
What makes Node exciting?

If systems like this already exist, what’s so exciting about Node? Quite a few things:

1. JavaScript is extremely well suited to programming with callbacks. Its anonymous function syntax and closure support is perfect for defining inline callbacks, and client-side development in general uses event-based programming as a matter of course: run this function when the user clicks here / when the Ajax response returns / when the page loads. JavaScript programmers already understand how to build software in this way.
2. Node represents a clean slate. Twisted and EventMachine are hampered by the existence of a large number of blocking libraries for their respective languages. Part of the difficulty in learning those technologies is understanding which Python or Ruby libraries you can use and which ones you have to avoid. Node creator Ryan Dahl has a stated aim for Node to never provide a blocking API—even filesystem access and DNS lookups are catered for with non-blocking callback based APIs. This makes it much, much harder to screw things up.
3. Node is small. I read through the API documentation in around half an hour and felt like I had a pretty comprehensive idea of what Node does and how I would achieve things with it.
4. Node is fast. V8 is the fast and keeps getting faster. Node’s event loop uses Marc Lehmann’s highly regarded libev and libeio libraries. Ryan Dahl is himself something of a speed demon—he just replaced Node’s HTTP parser implementation (already pretty speedy due to it’s Ragel / Mongrel heritage) with a hand-tuned C implementation with some impressive characteristics.
5. Easy to get started. Node ships with all of its dependencies, and compiles cleanly on Snow Leopard out of the box.

Build¶

... Node eventually wants to support all POSIX operating systems (including Windows with MinGW) but at the moment it is only being tested on Linux, Macintosh, and Solaris. The build system requires Python 2.4 or better.

http://net.tutsplus.com/tutorials/javascript-ajax/learning-serverside-javascript-with-node-js/

http://www.nakedjavascript.com/going-evented-with-nodejs

http://github.com/sprsquish/libxmljs

http://libxmljs.squishtech.com/

http://github.com/jcoglan/faye

Faye is a set of tools for dirt-simple publish-subscribe messaging between web clients. It ships with easy-to-use message routing servers for Node.js and Rack applications, and clients that can be used on the server and in the browser.

http://jsclass.jcoglan.com

JS.Class - Ruby-style JavaScript

JS.Class is a JavaScript library for building object-oriented programs using Ruby idioms. It implements Ruby's core object/module/class system in JavaScript, as well as several standard Ruby libraries and various other extensions.

Features

JS.Class is designed to make JavaScript behave like Ruby in terms of its OOP structures. To this end, it provides the following features:

• Classes and modules with Ruby-compatible inheritance
• Subclassing and mixins
• Late-binding arguments-optional super calls to parent classes and mixins
• Singleton methods and eigenclasses
• included, extended and inherited hooks
• Method binding
• Ports of various standard Ruby modules, including Enumerable, Hash, Set, Observable, Comparable, Forwardable

Its inheritance system supports late-bound super() calls to parent classes and modules, including calls from singleton methods. It has been designed to mimick Ruby as closely as possible, so if you know Ruby you should feel right at home.