Wonderland Wednesday -- Subsnapshot importer

We've been working on a new Open Wonderland module for exporting and importing parts of a world for the last couple of months. The idea is that when you have a world laid out, you might want to export bits and pieces, or even the whole space, to rebuild it at a later stage or in a different server, or simply as a backup of all your hard work.

Exporting is done by just right clicking in a model or container and choosing Export.
Importing is done by just dragging and dropping the exported file onto the Wonderland client. Easy peasy!

A couple of shots from today's session, in wich we are exporting and importing a bunch of the big fellas.

Anyone needs an army?

Well behaved big fellas

bit to the left... bit to the right... perfect!

The module is taking this long to be developed because we are writing all the code as a group, and we only meet about 1 hour a week, so things are moving slowly.

As a result, we are all learning a big deal from each other, especially from Jon, but all of us have worked on parts of the module, which is really cool.

We are even using JUnit to test bits and pieces of the code. The codebase was not written with automated testing in mind, but we are doing all we can to move towards that direction, even if it's just in small doses, and the results are great so far, cause although we are quite far from being able to TDD or test-first even, testing after writing is saving us a lot of time in deploys and server restarts.

Also we are not really pairing but 'grouping', and although communication can be harder than in the former, we are having a lot of fun, and that is what really counts!

These are a couple of shots of us working against netbeans and also the space we use, with the wallcard on the far end wall with all the stickies.

Close up of Netbeans in-world

The group writing code, live

The WallCard with all the stickies: we are almost there! ...almost!

Better quality pictures can be found on facebook.
These sessions happen most Wednesdays at 1p.m EST, 6p.m GMT, and everybody is welcome, so hope to see some of you quite soon!

Talks at the Virtual Worlds Best Practices in Education 2011 Conference

In a couple of hours I will be talking about the Open Wonderland Development course that I organised through P2PU earlier this year. The time is 7a.m. PST or 2p.m. GMT and everybody is welcome!

This is the master schedule for the whole conference, which is finishing today.

Yesterday was the turn of Roland Sassen from Thinsia Research to talk about Wonderschool, their fantastic project that allows children in schools to use Alice through Open Wonderland. Roland also talked about some new research they are starting, to use Wonderland through thin clients and that sounds really exciting!

After that, Nicole and Jonathan from Open Wonderland Foundation and Wonderbuilders talked about the imminent preview 5 release that we are all waiting for!

As for today, I will be talking about the P2PU course and later on, at 1p.m. PST or 8p.m. GMT, Jon and Nicole will be joined by Kathryn Aten to tell us all about how to learn to program collaborative using Open Wonderland. This is a talk based on Wonderland Wednesdays which are our community weekly meetings in which we've been gathering together to write code collaboratively almost every Wednesday for the last 6 months. Can't wait!

The importance of Cell Messages in Open Wonderland

Last week at the P2PU Open Wonderland meeting I tried to explain why Cell Messages are important. I did not do a good job of it so for that reason I decided to record the following two screencasts. In the first one I explain how you can get two (or more) clients running on the same machine. That gives a good starting point for the second one, an overview of the importance of Cell Messages.

The cell used in the video was developed following the Developing a new Cell tutorials part 1 to 3. Part 4 is the one that deals with messages, and would make the shape update properly in all the clients connected.

How to launch more than 1 client in the same machine:



Cell Messages and its importance for client communication:

Open Wonderland, High level Architecture - the story of the system

I would highly recommend Michael C. Feathers' 'Working effectively with legacy code' to anyone who cares about code, how it is written and how to deal with complex and (automated) untested systems.
Although the word legacy might evoke images of Fortran or COBOL procedures, the definition in the book refers to any kind of system that does not have an automated suite of test to rely on when making changes.

It was in this book where I read about the concept of telling the story of the system. According to the author, you need at least two people for this technique to be effective. One asks the other; What is the Architecture of the system?
The other will answer the question in just a couple of sentences, using only a few concepts, and targeting individuals with no prior knowledge on the system itself.

So I asked Jon Kaplan if he'd be so kind to put this into practice with Open Wonderland and this is the result:

Connecting Open Wonderland to external services

I've been working on a tutorial about how to connect Wonderland to (and from) services on the Internet (webservices).

I am a big fan of REST so that's what I chose for the first tutorial that can be found in the community wiki.
The  code for the module can be found in my github account: REST sample module, and this is a screencast showing what you can expect from the module:



As per the utility of this module, as it stands it is quite limited, but what I am trying to show here is that it is very simple to connect to external sources, and in the same way that this very simple module sends information to be stored in an external database, other REST communication could be as easily programmed, be it integration with services such as twitter or facebook, or learning management systems such as moodle or sakai.

You can see some similar examples by Bernard Horan in Wonderblog and his youtube channel.

Client communication is not the only way that Open Wonderland can communicate with external services and I have started documenting this topic in this page. Please feel free to contribute; help will be much appreciated.

Workarounds and Tutorials

I have been working a bit on the community wiki, adding content and some workarounds for problems that have been mentioned in the list. Here are a couple of links:

A tutorial to explain components, which is a work in progress, and I would really appreciate some help with it. It uses the tooltip component as source code.

A workaround for the scripting component editor window, that does not seem to get along well with Windows boxes. This is the ScriptingComponent module in modules/unstable.

I would quickly like to mention a new module that allows scripting in a different way that the already existing module does. EZScript is being written by Ryan, and it can also be found in modules/unstable. It's only a couple of weeks old, and in almost incubation phase, but looks really promising. Looking forward to playing with it a bit more!

Empty module for Open Wonderland development

I was going through the first part of the 4 part tutorial Developing a new Cell when I realised that the empty module that is available for download contains quite an outdated classpath for use with Netbeans. So I decided to create a new one an upload it to my github account, mainly because in this way it can be developed further if things change in the near future (this pretty much means: feedback very welcome!).

As it stands now, the module is just an updated copy of the one in the tutorial. With time, I'm planning to modify the build file to add testing libraries (probably JUnit and mockito). It would be really cool if these dependencies could be 'pushed down' in to the Wonderland building system so that they are available to all module developers out of the box. But for now, feel free to clone, fork, or download the code.

If your local copy of Wonderland source files follows the structure in the README file, then you should be ready to go with little changes to the module (just a couple of rename actions, and the cusotmisation of my.module.properties).

To make it even easier, I've recorded a screencast, and I've been working (in progress) on an update of the tutorial material.