Finding Tech

Hapi

A rich framework for building web applications and services. hapi is a simple to use configuration-centric framework with built-in support for input validation, caching, authentication, and other essential facilities. hapi enables developers to focus on writing reusable application logic instead of spending time building infrastructure. The framework supports a powerful plugin architecture for pain-free and scalable extensibility.

ShellJS

ShellJS is a portable (Windows/Linux/OS X) implementation of Unix shell commands on top of the Node.js API. You can use it to eliminate your shell script’s dependency on Unix while still keeping its familiar and powerful commands. You can also install it globally so you can run it from outside Node projects - say goodbye to those gnarly Bash scripts!

Nide

Nide is a web-based IDE for Node.JS, designed with simplicity and ease-of-use in mind.

You can run Nide locally or install it on your remote server, and access it through your Web browser.

Features

• Project tree display
• File operations (create/delete/rename files and folders, hide/show hidden files)
• Syntax highlighted code editing for multiple programming languages
• OS X Lion-style automatic save
• OS X Lion-style version management with revert and side-by-side editing features
• Real time project tree filtering (using regular expressions)
• NPM integration (display currently installed packages, add/remove packages, automatically update package.json)
• Image previewing.
• HTML previewing.
• HTTP authentication (for running Nide on a public server)
• Ability to run as a native Mac application.
• Sleek interface reminiscent of TextMate
• Node.JS Documentation browsing

abaaso[http://abaaso.com]

abaaso is an enterprise class, light weight, RESTful JavaScript framework that provides a set of classes and object prototyping to ease the creation and maintenance of pure JavaScript applications. abaaso is a Level Three framework, on the Richardson Maturity Model. Don’t know REST? No problem! It’s not going to get in your way.

abaaso extends the prototypes of Array, Element, Number, and String with methods (functions) to make magic possible. Semantic classes & methods (Object Oriented Programming) strive to make anything as easy as saying it! Wait, isn’t extending prototypes dangerous? No, it’s the nature of the language.

abaaso is event oriented, with a global observer. The methods on(), fire() and un() is how you register, trigger & unregister listeners. You can see what listeners are registered on something with listeners(), which accepts an optional event parameter.

Chai[http://chaijs.com/]

Chai is a BDD / TDD assertion library for node and the browser that can be delightfully paired with any javascript testing framework.

Chai has several interfaces that allow the developer to choose the most comfortable. The chain-capable BDD styles provide an expressive language & readable style, while the TDD assert style provides a more classical feel.

Plugins extend Chai’s assertions to new contexts such as vendor integration & object construction. Developers can build their own plugins to share with community or use the plugin pattern to DRY up existing tests.

Grunt[http://gruntjs.com/]

Grunt is a task-based command line build tool for JavaScript projects.

Grunt is currently in beta. While I’m already using it on multiple projects, it might have a minor issue or two. And things might change before its final release, based on your feedback. Please try it out in a project, and make suggestions or report bugs!

Dust[http://akdubya.github.com/dustjs/]

Why Dust? Why another templating engine when there are so many alternatives? Dust is based on the philosophy that an ideal templating environment should be:

• Markup-like: A templating syntax should not encompass operations that are better left to a programming language. Templates should make it easy to format content for presentation while keeping application logic where it belongs: in the application.
• Asynchronous: Template helpers should be callable asynchronously and in parallel so that expensive operations (caching, deferred loading, filtering) can run as the template is being rendered.
• Streaming: Templates should allow (but not require) data to be flushed to the output in user-defined chunks.
• Browser and server compatible: Templates should render in both server and browser environments without hacks or extensive configuration.
• Storage agnostic: The templating engine should not impose a particular loading scheme. Developers should be free to load templates via the filesystem, a database or an army of carrier pigeons.
• Composable: Designers should be able to break presentation markup into manageable components and combine these components at runtime. It should not be necessary to statically link templates or manually assemble ‘layouts’ inside application code.
• Format agnostic: While HTML generation and DOM manipulation are useful in specific instances, a general-purpose template system should not be tied to a particular output format.
• Precise: The parser should be accurate enough that designers rarely have to use escape sequences to achieve the desired result. Similarly, templates shouldn’t mysteriously generate or eliminate whitespace.
• Safe(r): At the very least, the engine should be configurable such that it is reasonably safe to render untrusted templates in a server environment.
• Fast: Server-side templates cannot always be cached. Browser-side templates may be rendered on devices with limited system resources. A template engine should be fast enough to render in real time without bottlenecking its environment.

Vows[http://vowsjs.org/]

There are two reasons why we might want asynchronous testing. The first, and obvious reason is that node.js is asynchronous, and therefore our tests should be. The second reason is to make tests which target I/O run much faster, by running them concurrently.