From the TogetherJS website:
- Audio Chat – TogetherJS uses Web RTC technology to enhance communication
for your users.
- User Focus – Your users see each other’s mouse cursors and clicks.
- User Presence – TogetherJS enables your users to see each other in real
- Text Chat – Your users can chat with each other with familiar instant
- Co-Browsing – Your users can follow each other to different pages on the
- Real Time Content Sync – Your users can see content on a site or app
dynamically change together.
The “Why did we build React?” page on the React Blog gives a good overview of the library and the motivations behind its creation.
Some interesting bits:
Play is a web application framework designed to make web development simpler. It is inspired by convention-based frameworks such as Ruby on Rails and Djnago. Play seems to be trying to take the best from the Java web development ecosystem and strip away some of the more cumbersome parts.
From the Play Framework Wikipedia page:
Major differences From other Java frameworks:
- Stateless: Play 2 is fully RESTful – there is no Java EE session per
- Integrated unit testing: JUnit and Selenium support is included in the core.
- API comes with most required elements built-in.
- Static methods: all controller entry points are declared as static (or
equivalently, in Scala, methods on Scala objects). After requests were made
for this to be customisable, Play 2.1 now supports other styles of
controllers, so controllers need not be static/Scala objects; however, this
is still the default.
- Asynchronous I/O: due to using JBoss Netty as its web server, Play can
service long requests asynchronously rather than tying up HTTP threads doing
business logic like Java EE frameworks that don’t use the asynchronous
support offered by Servlet 3.0.
- Modular architecture: like Rails and Django, Play comes with the concept of
- Native Scala support: Play 2 uses Scala internally, but also exposes both a
Scala API, and a Java API that is deliberately slightly different to fit in
with Java conventions, and Play is completely interoperable with Java.
From the Nightwatch.js website:
Nightwatch.js is an easy to use Node.js based End-to-End (E2E) testing solution for browser based apps and websites.
It uses the powerful Selenium WebDriver API to perform commands and assertions on DOM elements.
Simple but powerful syntax which enables you to write tests very quickly, using
classes, you only need to write the test specs.
Built-in command-line test runner which enables you to run the tests either
altogether, by group or single.
Manages the Selenium server automatically; can be disabled if Selenium runs on
Continous Integration support: JUnit XML reporting is built-in so you can
integrate your tests in your build process with systems suchs as Hudson or
Use CSS selectors or Xpath to locate and verify elements on the page or execute
Easy to extend if you need to implement your own commands specific to your
A tutorial covering the following:
- Other types
- Control structures
- Custom objects
- Inner functions
- Memory leaks
libgit2 is a portable, pure C implementation of the Git core methods provided as a re-entrant linkable library with a solid API, allowing you to
write native speed custom Git applications in any language which supports C bindings.
- 100% Cross-Platform: Linux, FreeBSD, OpenBSD, Mac OS X, iOS, Amiga, MinGW and fully native Windows.
- Zero Dependencies: Builds out of the box with no dependencies. Works in embedded devices and iOS.
- ANSI C89: Written with portability in mind. Builds in GCC, Clang and MSVC.
- Permissive Licensing: GPLv2 with Linking Exception. Link with open and proprietary software, no strings attached.
The complete list of language bindings is here on the Github page.
I have to confess that I don’t quite understand how this works. I’m quite familiar with virtualization products like VMWare or VirtualBox. They are virtual servers complete with virtual hardware to install a complete Operating System on.
According to the Rackspace Blog ZeroVM is…
…a lightweight open-source hypervisor created by LiteStack and built to run
cloud applications. ZeroVM breaks down the barriers between compute and
storage. Where traditional cloud architectures have needed to move the data
to the app for processing, ZeroVM flips that approach and moves the app to
the data. This dramatically increases speed of access and decreases latency.
ZeroVM is efficient because it is made to virtualize applications, not
machines. The runtime virtualizes only the server parts that do the actual
work at hand – making it much faster. Today, the fastest virtual servers
take at least two minutes to create, while ZeroVM takes less than 5
milliseconds – or 1/20,000th as long. ZeroVM is fast enough that you can put
every request into its own mini-VM to spread horizontally.
Making things smaller, lighter and faster also provides greater security.
ZeroVM is fast enough to isolate each individual user in a separate
container, which delivers greater granularity of security and control.
Rands in Repose is one of the few blogs that I read immediately as soon as something new has been posted, regardless of the length of the post.
You can find some of his best stuff here: http://randsinrepose.com/dont-skip-this/.
I sort of have a thing for back-end systems: RPC calls, middleware, serialization protocols. A well put together and well-documented API makes me smile. MessagePack (via) looks like another great tool for my tool-belt.
The MessagePack website says:
MessagePack is an efficient binary serialization format. It lets you exchange data among multiple languages like JSON. But it’s faster and smaller.
Small integers are encoded into a single byte, and typical short strings require only one extra byte in addition to the strings themselves.
Here’s an example in Java, also from the MessagePack site:
Simple Serialization/Deserialization/Duck Typing using Value
// Create serialize objects.
List<String> src = new ArrayList<String>();
MessagePack msgpack = new MessagePack();
byte raw = msgpack.write(src);
// Deserialize directly using a template
List<String> dst1 = msgpack.read(raw, Templates.tList(Templates.TString));
// Or, Deserialze to Value then convert type.
Value dynamic = msgpack.read(raw);
List<String> dst2 = new Converter(dynamic)