Showing posts with label open wonderland. Show all posts
Showing posts with label open wonderland. Show all posts

Thursday, January 19, 2012

Open Wonderland - Best View proposed changes

Best View is about the most useful capability ever! It works great with objects with an aspect ratio very similar to your screen, but it's not as good with wider objects such as a cardwall.

You can see what I mean in the following video:



So scratching an itch, I've been working on a patch to add functionality to the capability so that you can focus on certain parts of the object. The key modifiers I'm proposing are:

Mouse wheel = zoom in and out
alt + Mouse wheel = move left and right
alt + crtl + Mouse wheel = move up and down

UPDATE
The keys to be used now are:

Mouse wheel = zoom in and out
ctrl + Mouse wheel = move left and right
ctrl + shift + Mouse wheel = move up and down


The mouse wheel effect also works with trackpads and Mac mouse devices by just sliding a finger as if you had a real wheel.

The patch has not been reviewed yet but if you want to give it a go, I have sent it to the mailing list, and I would appreciate any testing and feedback. Just take into account that it might be rejected.

Sunday, November 20, 2011

Open Wonderland and Google Docs Proof of Concept

I have been very quiet for the last while but as my work load eases out I've had some time to mess about with Open Wonderland again.

This time I've spent a couple of hours putting together a proof of concept (POC) to send information to Google Docs from inworld. In the following video you can see how a word processor document is created from an in world HUD.



The module is very rough and has only been thought of as a proof but if you want to check it out feel free to do so. As usual my code is in github: Proof of Concept for Google Docs and Open Wonderland Integration.

I have to say that the Google Data API has its quirks, although I have only spent a couple of hours using it, but it seems to be solid enough to create powerful client applications.

Any feedback is very welcome as usual!

Friday, September 30, 2011

the busiest September in years!

This has certainly been the busiest September for me in many many years. I can even say the busiest in my life.

After finishing August in a high note with the Ruby Ireland Rails 3.1 launch party, September started with a Ruby Project night in amworks in which we were working a bit on Conway's Game of Life.

The following week two events took place, on the Tuesday the dublinjs meetup with a fantastic backbone.js presentation by David and a kata by Wiktor, and on the Saturday I had the privilege to co-organise and co-facilitate the first code retreat in Dublin (and in Ireland as far as I know!).

If that was not enough, on Sunday I took a flight to Madrid to attend XPWeek. The Monday was a full day of talks, and the rest of the week I attended the TDD courses by Carlos Ble.

I have posts coming about some of these events so won't go into details here, but all the events were absolutely fantastic!

We have also been pushing a new release of Open Wonderland for a while and I think there will be some juicy news out very soon, which is very exciting!

And tomorrow, 1st of October I will certainly not be missing the SocketStream session that the AOL Dublin guys are preparing. That is if this stupid cold I've been nursing since I'm back in Ireland allows me to get out of bed!

Thursday, August 4, 2011

Open Wonderland OurBricks module Preview 2

Another update on the OurBricks module to use within Open Wonderland. This time you can see the process end to end.





There are still a few glitches in the UI, not being very responsive, and the OurBricks API is likely to change in the near future as it is in active development, but the prototype is working now, as you can see in the video.

If you want to play with the sources you can find them in my github account.

Tuesday, August 2, 2011

Open Wonderland OurBricks module Preview

I've been working for the last couple of weeks in a new module that will eventually allow the loading of 3D models from the OurBricks collection directly from within Open Wonderland.

The module is in a very early stage and we are collaborating with the guys at OurBricks to get it finalised as soon as possible, but for now you can see the progress (search functionality) in the following video:



As usual, you can find the source code in my github account. Feel free to clone and change. Pull requests always welcome!

Update: Just got a couple of models imported; a bike and an aircraft, as can be seen in the following screenshot:

Models from OurBricks.com

Tuesday, July 12, 2011

Code Review Session for Open Wonderland 0.5 Preview 5

Preview 5 is coming... finally!

The Open Wonderland community is closing off the last bunch of issues, being the major one the Video Module that will finally work out of the box, without having to fiddle with the sources. As usual, Jon is in charge of the really hard stuff (Thanks Jon!).

As always, this is a community effort and we are all trying to contribute as much as we can. If you would like to help us move forward please do not hesitate to contact us!

At the meeting, the usual suspects were around, and we all took on some of the problems to fix. On my side of things, I've been poking about with the Placemarks menu, trying to make it a bit more user friendly by alphabetising the marks, separating them in more logical chunks, and so on.

Discussing and Assigning Bugs in-world


Last wonderland Wednesday session was devoted to discuss what was going to be fixed and added in the preview, and this Wednesday (July the 13th), we have organised a Code Review session after the normal Wednesday session.
I think a code review is a great way to learn, and it will definitely be very helpful for me, as I am not very familiar with the codebase. Please feel free to join us if you are interested in Wonderland development.

Wednesday, April 13, 2011

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!

Saturday, March 19, 2011

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!

Tuesday, February 15, 2011

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:

Saturday, February 12, 2011

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:

Wednesday, February 9, 2011

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.

Tuesday, February 1, 2011

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!

Friday, January 28, 2011

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.

Tuesday, January 25, 2011

Open Wonderland Development course starting tomorrow

I cannot believe it is already tomorrow!!! I am really excited and cannot wait to start working.

In the end a great bunch of people applied for the course, and although initially I was only offering 10 seats, it will be 12 of us starting the course. Hope it will also be 12 of us finishing it!

I am truly sorry to have had to deny several applications, but the pre-requisites were higher than an introductory course, and a good bunch of people did not complete the sign-up task, so I could not approve their applications.

If you are still interested, you can follow the course through the P2PU site, as all the content is openly available. Course link.

Looking forward to starting this collaborative project and I will be documenting several steps of the process in this blog, so stay tuned if you want to hear more!

Friday, January 14, 2011

sample sign-up task for the OWL development course

This is a sample of what I am expecting to see with applications for the course. The exercise is explained in the Sign-up task section at the main page of the OpenWonderland development course at P2PU.

Here is the screenshot of the bean-shell plugin working on my local Wonderland server:

Saying hi from beside the Beanshell Console





























To get it to work I had to compile and run the core server, and then, from the wonderland-modules unstable folder, cd into the beanshell-plugin directory and type:
ant deploy

That deployed the module to my server. To activate it, I just added it from the main Wonderland menu (tools --> Beanshell console).

Reflection: I did not run into any trouble doing this, but this was only because I had done it before! call it cheating if you like! ;-)


And this is all you need to finish the sign-up task. The last step would be to apply for the course and send me the link to your blog post.

Open Wonderland Development Course at P2PU

I am organising an 'Open Wonderland Development course' at P2PU. This is a course that follows a peer to peer approach, it is all community based, and totally free.

About P2PU
The Peer to Peer University is a bit different. All work is done through p2p collaboration. Courses generally run for 6 weeks (next batch starting on the 26th of January 2011). You do not need to be an expert to organise a course, mainly because of the fact that you will be a facilitator, as opposed to a teacher/lecturer. All you need is a collection of open accessible resources to run a course (you can also create your own).

I think this model fits perfectly the software profession, if you compare it with the individualised approaches of any 'normal' university. You will not get a degree after finishing a course, but you might get much more out of it...

About Open Wonderland
Open Wonderland is a toolkit to create virtual worlds. It is 100% Java, it has a relatively small core, but its extensibility through 'wonderland modules' makes of it a platform to do pretty much whatever you want within the 3D environment. Out of the box you can share X11 apps within the world (Open office, Chrome, Eclipse, or freemind work pretty well), communicate through text, voice, or even the telephone, and drag and drop all kinds of digital materials such as pdf files, images, etc.

You can also write your own modules. One of the available modules is an scripting engine based on "JSR 223: Scripting for the Java platform". Using this module you can script objects inside the virtual world using any language supported by the specification (Javascript, PHP, Ruby, and so on).

The project was initially born at Sun Microsystems in 2007, but support from Sun/Oracle stopped earlier last year(2010). It was an open source project from inception and although most people envisioned its death after Oracle laid off the team, it has been quite a different story since then. The community has taken control of the project through the creation of the Open Wonderland Foundation (non-profit), and all kinds of meetings inworld have been happening ever since. All Wednesdays at 1pm (EST) there are development meetings in which the community share an instance of Netbeans and hack on code as a group (every avatar can take control of the instance and start driving).
I do have to say that things are going a lot slower, no doubt of that, but there are more users now than ever before, and development continues at a steady pace.

Motivation
So, why am I doing this, what's in it for me? The experience really. I was not part of the initial wonderland team and my association has not been other than as a volunteer in the community for the last few months. I thought this would be a good way to give back to the community.
I am also a researcher in IT in Education, and this is just a way for me to experiment with ideas, mostly taken from Software Craftsmanship.

I see a few different ways that learning can be organised around the wonderland system (apart from development work which will also be covered).
Although it is a fairly big system (with a small core), test automation is almost inexistent. One of my goals would be to start inspecting the system by testing it from within, and see where that leads us. There is a test harness in place, but it hasn't been used much and it would be great to inspect that too.
Another course for experimenting is the building system. Ant scripts exist for the system but dependency management is not explicit. The build is also way too dependent on netbeans.

These are two scenarios that people are quite likely to find in their everyday job. So, what's in it for you? Well, the experience really! :)
Some people might find attractive the fact that some out of the office learning can being organised (to a point) by someone else. I say 'to a point' because, as mentioned earlier, this is a peer to peer experience, I am not an expert, and learning is ultimately the responsibility of the participants themselves.

This is a 'distance learning experience', and I do not expect people meeting face to face, but I do expect meetings avatar to avatar. It is definitely not the same (nowhere near!) but in my opinion is the closest experience to the real thing that I've had so far.

In a nutshell
So, as a summary, if you are interested in learning through technology, be it software development, testing automation, scm, and so on, and you want to do it within an existing system, and more importantly, in a collaboratively, community-based way, please have a look at the course.

Link to the course: http://www.p2pu.org/general/open-wonderland-development-java
Dates: starting on January the 26th (2011)
Pre-requisites: Please read through the sign-up task (main page of the course) before applying.

Friday, October 8, 2010

Documentation about the git session

The git session held on October the 8th is being documented in the community wiki at this location.

The session focused on how to use git and github to collaborate in the development of open wonderland modules (or any other project that you fancy!).

Please feel free to add to the page if you want. The more info, the better!

Thursday, October 7, 2010

Introduction to Git for version control

Hi everybody!
We are organising a session on Git to keep track of your source code. The meeting will be in-world, in the Open Wonderland Community Server and we are still trying to finalise the times.

Possible dates are being tracked down here. Write your name down if you want to participate.

The session will be very simple, all from scratch, and will focus on how to use Git and github.

Hope to see you there!

UPDATE: The session happened on the 8th of October but it will be repeated soon, so get in touch if you want to participate!

Saturday, July 3, 2010

Cloning the Open Wonderland subversion repository

The question about cloning the wonderland repo was raised at a recent development meeting.
The main reason to clone is that you might not have permissions as a commiter to the main repo, but you still want to be able to commit your changes locally, whether or not they will eventually be propagated to the main repo.

I decided to give a go at using Git instead of Subversion. I have been using Git for a while now, and although it can be very tricky at the beginning, it is a great system.
I am not going to go into the differences between the systems, cause a simple google search will provide a lot more information that I could ever compile on here.

So let's cut to the chase and see what I got so far, and what problems I'm having:
First thing to do is a google search! These are a couple of interesting links that I've found, and the process I followed in here was taken from those links:

[2]: Automating the authors file.

Git manages authors in a different way to svn, so one of the steps needed for the migration is a text file with the authors' names and email addresses. Although in the first link they create this file manually, there is a script in the second link to automate its creation.

From [2]:

Create author mapping file

Create a svn.authors file, which maps the svn author names to git author names:

#!/bin/bash
authors=$(svn log -q | grep -e '^r' | awk 'BEGIN { FS = "|" } ; { print $2 }' | sort | uniq)
for author in ${authors}; do
echo "${author} = ${author} <${author}@dev.java.net>" >> svn.authors ;
done

I will not go into many details here because both links are very clear. What I did to clone, step by step, was:

1. run the authors script and modify the output if you have real information about the authors. To run the script as it stands, you will need a local svn copy of the original repo.

2. cd to the location where you want to have your git repo.

3. create a temporary location for the code: mkdir wonderland_temp

4. cd wonderland_temp

5. git svn init http://openwonderland.googlecode.com/svn/trunk --no-metadata

6. git config svn.authorsfile /location/to/your/svn.authors

7. git svn fetch (This step is going to take a good couple of hours!)

The last step will get rid of all the superfluous svn information and leave a clean git repo. The problem here is that it also gets rid of a bunch of empty directories that are needed to compile, so if you do 8, you will have to recreate those folders.
8. git clone wonderland _temp wonderland

Some Problems:
A weird thing happens when I try to compile wonderland core and wonderland-modules exists at the same level. For some reason the build tries to compile the audio-recorder module from the modules directory, and this fails when it tries to hit the ContentRepository class.
The failure in itself makes sense, or so I think, because it is trying to compile a module that depends on part of the core, when the core has not finished compiling. What puzzles me is that the core build triggers compilation in the modules tree??? this is very strange. Stranger is that if I get rid of the wonderland-modules directory, the build runs like a charm!

It might be me, or something in my system, but I guess the only way to know is to track down the build scripts, which I intend to do as soon as I have time for it.

Other than that, when I run the new server, I run out of memory, which does not happen in the svn tree. I will need to track this down too.



These instructions will provide you with a local copy of the repo that you can use for personal purposes. If you want to share this 'main' copy with other people, say at your company, you will have to check how to publish a git repo; some ideas here:

Have fun!


[UPDATE]: Just tried the process under Windows 7 + Cygwin and all goes really smooth. Server compiles and no out of memory errors (the ones noted above were on MacOS X).

[UPDATE 2]: The compilation problems were only in my machine, and due to the fact that the empty directories were not present. The main build checks for the wonderland-modules project, and in case of existing, it builds it too.

Sunday, May 2, 2010

Launching the Open Wonderland server through screen

Hello there! This is a short screencast about how to launch the wonderland server in a remote machine, and being able to detach the launch so that you can safely close the terminal session without halting the execution of the server. At a later stage, you can connect back to your server and retrieve your process again. Handy!


There is also a transcript in the wonderland community wiki. Enjoy!