Yesterday we released Beta 6 of Robotlegs 2. Behind the scenes lots of improvements were made, aimed primarily at extension developers. But we also reintroduced some things and added a few minor functionalities:
The Direct Command Map allows you to execute commands directly and to pin and release commands in/from memory.
Read more
First of all I’m real happy and proud to announce that I joined the Robotlegs team a few weeks ago.
I’ve loved RL from the first moment I started working with it and that hasn’t changed over the years, so it’s really exciting to me to be a part of it now.
And… It’s coming. The official version 2.
No date.
But it is coming.
We’re working hard on improving things, especially everything that has to do with command(map)-related stuff.
The API changes are minimal and in most cases they’re primarily additions instead of modifications. We’ve tried to keep the API as it was, except when we found a much better solution.
One of the things we’re overhauling will mostly impact extension developers. We’re trying to make it a lot easier and more intuitive to create *map extensions. I think we’re succeeding. But maybe I’ve been staring into the sun for too long.
As I’m quite a different developer than Shaun I also brought a different viewpoint to the table. I’m a purist, but I also need to setup things fast. Create classes, wire them into the system without too much hassle. This is also one of the things we’re trying to achieve: to cater to different styles, let the purists feel at home, but allow for more leeway for those that feel the need (and know why they need the leeway).
Anyway, there’s a number of additions I’m really excited about and think will make life a lot easier for us poor, archaic ActionScript devs.
It’s coming. Soon.
For a project I’m working on I need data visualisation and particle systems libs. I’m storing them here for easy future access.
Last week my demo for Dijon (an IOC/DI javascript framework I created) was included in the labs section of TodoMVC, a hugely popular common learning application for JavaScript MV* frameworks.
In the demo Dijon is used on top of JQuery to provide structure and dependency injection for the app. It allows you to decouple several functional units and let them work together and communicate.
Even though Dijon does not impose a typical MV* structure in any way, it allows you to easily do so w/o forcing you to use any specific paradigm.
I wrote a plugin to run jasmine specs with grunt.
It should be stable and is available through npm.
Install this grunt plugin next to your project’s grunt.js gruntfile with:
npm install grunt-jasmine-task
Note: it’s best to install it as a local node module, not global.
Then add this to your project’s grunt.js gruntfile, inside the grunt.initConfig object:
jasmine: {
index: ['specs/index.html']
},
replace specs/index.html obviously with the location of your jasmine spec running html file.
and at the bottom of your grunt.js gruntfile add:
grunt.loadNpmTasks('grunt-jasmine-task');
now you can run the jasmine task with:
grunt jasmine
Source can be found in the grunt-jasmine-task github project
Issues can be posted in the issue queue, all other feedback is welcome here in the comments, or on twitter: @camillereynders
[update 28/04/2012]The dijon demo app was included in TodoMVC’s labs section[/update]
Dijon is an IOC and DI micro-framework for Javascript. Originally it was meant to be a port of Robotlegs, but deviated to something quite different. It remains however heavily inspired by Robotlegs, and more specifically Swiftsuspenders.
Basically it’s an object registry, that allows you to define how and when objects are instantiated, functions and handlers are called and what objects should be passed on to other objects (that’s the injection thingy).
Dijon is not v1.x yet, but it is stable to use.
I’ve jumped into the rabbit hole and have been digging through the various types of inheritance possible in JavaScript.
Not really original, I know, but in a project I’m working on I needed to mix various types of inheritance, so I created a small utility lib to help doing just this: let objects inherit members from another object.
The lib’s called demiurge and can be found in the demiurge github repository.
It’s based on a gist I created a few days ago and already tweeted about, it can be found here.
@google+