WEB front-end tech

Vert.x is the framework for the next generation of asynchronous, effortlessly scalable, concurrent applications.

Vert.x is an event driven application framework that runs on the JVM - a run-time with real concurrency and unrivalled performance. Vert.x then exposes the API in Ruby, Java, Groovy and JavaScript. So you choose what language you want to use. (Scala, Clojure and Python support is on the roadmap too).

We also bundle a host of goodies out-of-the-box including a distributed event bus, Web Sockets, SockJS, a MongoDB persistor and many other features so you can write real applications from the set-off.

Some of the key highlights include:

• Polyglot. Write your application components in JavaScript, Ruby, Groovy or Java. It’s up to you. Or mix and match several programming languages in a single application.
• Super simple concurrency model. Vert.x allows you to write all your code as single threaded, freeing you from the hassle of multi-threaded programming. (No more synchronized, volatile or explicit locking).
• Unlike other popular event driven frameworks, Vert.x takes advantage of the JVM and scales seamlessly over available cores without having to manually fork multiple servers and handle inter process communication between them.
• Vert.x has a super simple, asynchronous programming model for writing truly scalable non-blocking applications.

Vert.x includes a distributed event bus that spans the client and server side so your applications components can communicate incredibly easily. The event bus even penetrates into in-browser JavaScript allowing you to create effortless so-called real-time web applications.

Vert.x provides real power and simplicity, without being simplistic. No more sprawling xml configuration files.

Vert.x is a community project sponsored by VMware.

Future applications will largely be running on mobile and embedded devices. These demand a platform that can scale with 10s, 100s or even millions of concurrent connections, and allow developers to write scalable, performant applications for them incredibly easily, in whatever language they prefer.

We believe Vert.x is that platform.

JSONSelect is an experimental selector language for JSON.
It makes it easy to access data in complex JSON documents.
It feels like CSS.

Moe is a new, not-very-little Javascript-targeted language written in JavaScript. Its features are inspired by Python, Haskell and Coffee. It is aimed to deal with common troubles in JavaScript development. Moe has neatly crafted grammar so that most JavaScript development will be simplified.

Miso is an open source toolkit designed to expedite the creation of high-quality interactive storytelling and data visualisation content.

The first release under the Miso Project is Dataset, a JavaScript client-side data management and transformation library.

Miso is a set of libraries to be released over the coming months that simplify the processes of managing data, building reusable components, and authoring narratives. Miso is in active development, and will have components released as they are completed.

OpenS3 is basically a storage server. What it does is provide a JSON API to upload and download files to a specified path. It includes a bucket feature to organize uploads.

When adding an API to your web service, you have to choose how to encode the data you send across the line. XML is one common choice for this, but it can grow arcane and cumbersome pretty quickly. Lots of webservice authors want to avoid thinking about XML, and instead choose formats that provide a few simple data types that correspond to common data structures in modern programming languages. In other words, JSON and YAML.

Unfortunately, while these formats make it easy to pass around complex data structures, they lack a system for validation. XML has XML Schemas and RELAX NG, but these are complicated and sometimes confusing standards. They’re not very portable to the kind of data structure provided by JSON, and if you wanted to avoid XML as a data encoding, writing more XML to validate the first XML is probably even less appealing.

Rx is meant to provide a system for data validation that matches up with JSON-style data structures and is as easy to work with as JSON itself.

JSYNC is a simple data serialization language. It takes the simplicity of JSON and combines it with the completeness of YAML. This allows for full data graph serialization. JSYNC has the ability to serialize data in a language that is simple and familiar, while reusing the existing and ubiquitous set of JSON implementations.

Kwalify is a parser, schema validator, and data binding tool for YAML and JSON.

YAML and JSON are simple and nice format for structured data and easier for human to read and write than XML. But there have been no schema for YAML such as RelaxNG or DTD. Kwalify gets over this situation.

From version 0.7, Kwalify supports data binding. If you specify class name in schema file, Kwalify YAML parser creates instance objects of that class instead of Hash objects. It means that you don’t have to convert Hash into proper object any more. Data binding makes YAML much easier to handle and manipurate

The open source community has created a huge number of client-side templating solutions. When we did our initial research, we came up with a list of 26 templating technologies. We eliminated 8 right off the bat, as they were either abandoned projects or wholly lacking any documentation or community usage, making it nearly impossible to properly test them out.

This left us with 18 templating technologies to evaluate. We found that these could be broken down into two general categories: embedded JavaScript and logic-less.

Luvit is an attempt to do something crazy by taking node.js’ awesome architecture and dependencies and seeing how it fits in the Lua language.

This project is still under heavy development, but it’s showing promise. In initial benchmarking with a hello world server, this is between 2 and 4 times faster than node.js.

This essay walks through my experience adding garbage collection to Cafe au Life, an implementation of John Conway’s Game of Life that achieves stunning performance by aggressively caching both data and computations.

Cafe au Life is written in a pseudo-literate style that leans heavily on aspect-oriented software development to separate concerns and especially to produce a series of successive “reveals” of functionality. This essay walks through some of the refactoring required to make it possible to implement garbage collection through class extension and method advice, paying particular attention to memoization and abstracting functional composition.

Built on top of Node’s Connect and Express, modeled after Ruby on Rails. Built for the client and server from the ground up.

Default Development Stack
MongoDB (database)
Redis (background jobs)
CoffeeScript
Stylus
Jasmine (tests)
jQuery