In the following tests, we have measured the performance of several web application platforms, full-stack frameworks, and micro-frameworks.
dnode is an asynchronous rpc system for node.js that lets you call remote functions.
You can pass callbacks to remote functions, and the remote end can call the functions you passed in with callbacks of its own and so on. It’s callbacks all the way down!
dnode uses a newline-terminated JSON protocol.
These libraries implement the dnode protocol too so you can make RPC calls between scripts written in different languages.
Portability
Write code portable to the Java VM, .NET CLR, and JavaScript in the browser.
Familiar Syntax
Java and C# programmers will feel at home with Fantom’s evolutionary syntax.
Mixins
Interfaces but with implementation.
Concurrency
Tackle concurrency with built-in immutability and actor model.
Object Oriented
Everything subclasses from Obj. Value types when you need the performance.
Functional
Functions and closures are baked in.
Static and Dynamic Typing
Don’t like the extremes - take the middle of the road.
Serialization
Built-in “JSON like” serialization syntax makes Fantom ideal for declarative programming too.
Elegant APIs
We’re quite obsessive about providing all the key features required for a standard library, but with much less surface area than the APIs found in Java or .NET.
REST
URI literals and a unified namespace of resources identified with URIs.
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.
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
