Way back in v0.4, I wrote a blog, dot Wonderland, that described the contents of the "dot" directory that held meta-information, configuration information, and cached assets for Project Wonderland. It was meant to be an under-the-covers peak into some operational details for those who were interested and users, who like me, just love to twiddle with files every once in a while. I've been meaning to update that blog post for v0.5, so here we go.

In that earlier blog, I posted an important disclaimer that is worth repeating: modify the .wonderland and .wonderland-server directories at your own risk! Since the information contained in these directories are implementation details and not part of any public API, anything posted here is subject to change without notice.

The .wonderland-server/ directory

In Version 0.5, the files associated with the Project Wonderland server and client are now kept in two separate directories: .wonderland-server/ and .wonderland/, respectively. The structure of the .wonderland/ directory has not changed much since v0.4, so the information described by the dot Wonderland blog is still mostly correct. There are some changes, and I'll talk about those in another blog.

In this blog, I'd like to focus on the files pertaining to the server, in the .wonderland-server/ directory. First off, Project Wonderland keeps files for each revision of v0.5 in separate directories. If you are working with the main line source code (aka the 'trunk'), then files are stored beneath the 0.5-dev/ directory. If you are working with 0.5 User Preview 2, then files are stored beneath the 0.5-preview2/ directory. Once v0.5 is finalized, I'd imagine the files would be stored under the 0.5/ directory.

Keeping the files for each of these sub-versions separate really helps development: we can run and debug each of these different subversions on our development machines at the same time. Users who upgrade from, say 0.5 User Preview 1 to 0.5 User Preview 2, need to manually copy some files if they wish to keep state across these sub-versions. Hopefully the details contained in this blog will make this process a bit easier.

Log files, runtime state, worlds

If you take a look at the ~/.wonderland-server/0.5-dev directory (here, '~' denotes the user's home directory), you'll see three subdirectories: log/, run/, and wfs/.

Log Files

The log/ directory is perhaps the easiest to explain, so let's start there. The directory is only one level deep and contains a bunch of text files (with the .log file extension) -- they are the log files for various Project Wonderland server components. The primary one is the web server log, the latest of which is web_server.log.0 (older versions from previous times the Project Wonderland server was run can be found in web_server.log.1, web_server.log.2, etc).

There are three other log files that always appear in this directory: one for the Darkstar server (darkstar_server.log), one for the Voice Bridge (voice_bridge.log), and one for the Shared Application Server (shared_application_server.log). You may also view these web files via the Web-based Administration UI.

A fourth log file (darkstar_server_snapshot.log) is only created if you take snapshots of your world (see WFS: The Wonderland File System in v0.5 for more details).

Worlds and Snapshots

The wfs/ directory contains all of the initial worlds and world snapshots. Each is stored as a collection of XML-formatted files. The structure of the way these XML files are stored on disk is defined by the Wonderland File System (WFS). WFS has evolved in v0.5 since earlier releases, and the WFS: Wonderland File System in v0.5 blog succinctly describes the contents of the wfs/ directory.

Not mentioned in the blog, however, is the recordings/ directory that you may see underneath the wfs/ directory. The recordings/ directory contains the state stored by the Event Recorder, an experimental module that performs 3D recordings inside the virtual world.

The run/ directory

I left the run/ directory as last to describe for a reason: it's fairly complicated. This directory contains all of the installation information for the Project Wonderland server (including its various server parts, including the Darkstar server, Voice Bridge, and Shared Application Server). It also contains the "live" state of the virtual world (in the form of BerkeleyDB, an embedded database), an up-to-the-minute persistence mechanism that is implemented by the Darkstar middleware layer. The run/ directory also contains the content area for the embedded WebDav server that is bundled with Project Wonderland.

Here's the directory listing that I current see in ~/.wonderland-server/0.5-dev/run:

content/	docRoot/	webserver/	darkstar_server/
shared_application_server/	wonderland.version	deploy/	voice_bridge/
wonderlanddb/	derby.log	webdeploy/

Perhaps it's best to start off by describing which directories you can ignore for now: docRoot/, webserver/, darkstar_server/, shared_application_server/, deploy/, voice_bridge/, wonderlanddb/, and webdeploy/. These directories either contain information regarding the implementation of Project Wonderland's modular server architecture (i.e. deploy/ and webdeploy/), it's embedded web and application server (i.e. doctRoot/ and webserver/), or one of the server components that help implement the virtual world (i.e. darkstar_server/, shared_application_server/, voice_bridge/, and wonderlanddb/).

This leaves the following directory: content/. This directory serves as the content root for the WebDav repository. (WebDav, if you are not familiar, is simply an extension to HTTP, and let's us manage content on the web server remotely by clients). Some of the content stored in this directory is visible to ordinary users via the Project Wonderland client: the Content Browser (Tools -> Content Browser) displays all of the content found beneath the system/ and users/ directories here. For example, if a user drags-and-drops a model or an image or a PDF file into the Project Wonderland client, it gets uploaded to his/her space beneath the users/ directory.

The content/ directory also contains other information that is not visible to ordinary users, but is nonetheless important. It is information that is needed by the client software, so placing it in the WebDav content area was natural and eased its distribution. In fact, all modules installed into Project Wonderland are stored beneath the modules/ directory, and more specifically, the modules/installed/ directory. Feel free to browse the modules/installed/ directory for a bit: it's layout is relatively simple. You'll see a directory per module and the contents of the module JAR file expanded beneath that directory, along with some XML-formatted text files that describe the module. There is no other hidden registry of installed modules: its existence in the modules/installed/ directory is all that is necessary. (Incidentally, if you are ever in a position where you'd like to manually remove all of the installed modules in the system, simple clear out the modules/ directory and restart the server. On the flip side, to install a module, it's best to go through the normal mechanisms, e.g. the Web Administration UI).

The final directory beneath content/, the checksums/ directory, contains checksums computed for various assets in the system. These checksums are computed when a module is installed and is used by the caching mechanism in the Project Wonderland client to determine when it needs to download a new asset, for example.

Migrating Important Data from One Version to the Next

If you've built a world, in say 0.5 User Preview 2 and want to migrate the state of that world to, say the latest trunk, then the information above should provide you with the means. By and large, it's a simple matter of copying the proper files from one directory to another. I've tried this out myself by building a simple world in 0.5 User Preview 2 and then migrating the files so that I have the same world if I want to use the most recent Project Wonderland codebase (the trunk).

Using 0.5 Preview 2, I first installed the Clickable Link module (from the unstable/ section in the wonderland-modules workspace) [1] and created a simple world in 0.5 User Preview 2. I dragged-and-dropped a PDF file, which created a PDF Viewer in-world. I added a Sticky Note. I imported a 3D (.kmz) model using the Insert -> Model menu item and uploaded it to the server, placing it in a module named SatelliteModel. I then took a snapshot of the world (to preserve its state) and exited the client and killed the server.

Next, I ran the server using the trunk codebase. This populated the ~/.wonderland-server/0.5-dev/ directory. I then installed the Clickable Link module [1]. (I'm just using Clickable Link as an example; you will need to re-install any modules you had installed manually when using 0.5 User Preview 2). I then killed the server for the time being.

As a next step, I manually copied over key directories from the 0.5-preview2/ directory into the 0.5-dev/ directory. Here's what I did:

1. Copy the SatelliteModel/ directory in the ~/.wonderland-server/0.5-preview2/run/content/modules/installed/ directory to the ~/.wonderland-server/0.5-dev/run/content/modules/installed/ directory. Since I imported the model via the Insert -> Model menu item, it packaged the model into a module and installed it on my server. This first step copied that module from my old installation to my new installation. (You should do this for any model you installed this way). Related to this is Step 2. Note that models that have been dragged-and-dropped into the world are uploaded to WebDav, and migrated in Step 3 below.
2. Copy the SatelliteModel/ directory in the ~/.wonderland-server/0.5-preview2/run/content/checksums/modules/ directory to the ~/.wonderland-server/0.5-dev/run/content/checksums/modules/ directory. When modules are installed, the system computes checksums for certain of their assets. Since I manually copied the module from the previous installation (Step 1 above), the checksum-generating step did not occur for my new installation. Manually copying the old checksum computation should be sufficient.
3. Copy the users/ directory in the ~/.wonderland-server/0.5-preview2/run/content/ directory to the ~/.wonderland-server/0.5-dev/run/content/ directory. This copies over all of the content that was uploaded to the server when I dragged-and-dropped content into the world. (If you placed content in the system/ directory, you may wish to copy that over too).
4. Copy the snapshots/ directory in the ~/.wonderland-server/0.5-preview2/wfs/ directory to the ~/.wonderland-server/0.5-dev/wfs/ directory. This copies over the snapshot I took after I created my world in 0.5 User Preview 2.

While these manual steps should not take too long to do, a migration tool to perform the migration automatically would be a big help. If you are interested in writing such a tool, I think it would make an excellent contribution from the community.

[1] When I wrote this blog, the Clickable Link module was kept in the unstable/ section of the wonderland-modules workspace. It has since been promoted to the stable/ section and is now bundled with Project Wonderland.  

As the Wonderland core team, we spend a lot of time using Wonderland.  We use it for meetings, we use it for collaborative work, and we even use the world for socializing. But this week we tried something new: a group code review in Wonderland.

Code reviews are an on-going process that we usually work on asynchronously: I email out the code for review, and the reviewers get back to me once they have gone through it. While this is effective for small changes, in this case we wanted to review a large amount of code with the whole group. So we decided to get together in world and discuss the code together, almost like a reading group.

The biggest challenge was getting the code into world. We could have brought a NetBeans editor into world, but that would force everyone to have the same view. Instead, we used Drew Harry's slide spreader app to display PDFs of the source code. We found it works much better when everyone has their own view of the source.  That way we can assign people to break out of the main discussion and answer specific questions before joining the main group again.  And by using the spatial layout, we can always see at a glance where everyone is.  Here is what it looks like in-world:

Overall, it worked pretty well. We were able to explore the code both as a group and individually. And seeing the code sweeping off into the distance definitely gave a sense of how much there is to review!

There is still plenty of room for improvement.  We had to make the slides very big to make them easier to read, but this makes it hard to align your view with the slides. It would have been great to be able to see the code in the HUD.  Also, there is no syntax highlighting and no ability to jump to other parts of the code, which would have sped things up significantly. All this got me thinking it would be nice to have a lightweight shared code viewer -- maybe based on JSyntaxPane -- to use in world. Sounds like a new module to write...

I am delighted to introduce today's guest blogger, Nina Nussbaum-Jones from Lockheed Martin. She has been an active participant on the Wonderland forum as well as an enthusiastic advocate for the use of Wonderland technology in her company. Her energy, persistence, and courage are inspirational. Today, Nina is sharing her story with us. Or, more accurately, her storybook.

I have worked at Lockheed Martin for 27 years, starting out as a system programmer in the basement of the computer center (which consisted of 1 DECsystem-20!).  Working closely with other engineers back then meant fighting over the few terminals in the computer room, eavesdropping on arguments nearby, and generally having fun in those big open spaces has led me on a mission to restore that connectedness that has been mercilessly absorbed in the sound-proof cubicle walls that separate the workforce today.

Why Project Wonderland?

After the packaging is tossed, the software installed, and the novelty has dissipated, it’s the heart of the people writing the software that comes through, and the community around it that has forged the open source movement.  And it’s that sense of community that makes open source a movement!** And that’s what we have found in Project Wonderland.

**Remember Arlo Guthrie’s definition in “Alice’s Restaurant”?

Why a story?

The story you are about to read is true.  We have endured for 9 months, persisting in our quest to tell our story, and we’re a bit tired of repeating ourselves.  So I wrote it down, hoping to inspire all of us who want to keep doing what it is that we do and still have fun doing it!  (And also hoping to show that us misunderstood right-brained engineers really do rock!)

Adventures in Wonderland, Starring Nina Nussbaum-Jones and Christopher Stathokostas
(PDF, 2MB)

- Nina Nussbaum-Jones

Editor's Note: For those of you like me who are old enough to remember Arlo Guthrie fondly, but not the details of the song lyrics, and for those too young to have heard them, I thought you might like a pointer to the lyrics of "Alice's Restaurant." The part about what makes a movement a movement is almost at the very end...but I hope you'll read them all the way through and then think about singing along with the rest of us to turn this small movement into something much larger.

Scratch is a great visual programming environment for kids created by some folks at MIT. Randy has put together a little code to connect Sun SPOTs to Scratch and has released a video (below) to show you how to do it.

Its easy and fun! Try it out!

One of the indicators of the worldwide reach of a project is when you receive complaints about it only being in English. We found ourselves in this position earlier this year when we were contacted on the forums from Switzerland by Ronny Standke. However, Ronny didn't contact us to complain--he contacted us to offer to internationalise Project Wonderland! Since then, working with the core team, Ronny has internationalised the majority of the core source code and also provided German (de) and Swiss German (de_CH) localisations. Not to be outdone, our colleague Michel Denis has provided a French (fr) locale, and I've produced a British English (en_GB) variant of the default US English. 

We invited Ronny to write a blog entry on his experience: 

'Here at imedias, the information center for digital media in school and teaching of the University of Applied Sciences Northwestern Switzerland, we were given a task from the canton Solothurn to set up an "active and living environment" for headteachers.
After a long evaluation phase we decided to use Project Wonderland. The reasons for choosing Project Wonderland were:

• it is available for all major operating systems
• it can be run without any complex installation (thanks to Java Web Start)
• it focuses on the more serious aspects of virtual worlds (such asapplication sharing)
• it is Free Software
• it is written in Java, a great programming language we can also read and write

However, Project Wonderland obviously has some negative aspects, such as:

• it is not very mature
• it is comparatively slow
• it is not available in the (natural) languages we natively speak in Switzerland (German, French, Italian, Rhaeto-Romanic)

We are confident that Project Wonderland will mature over time and that speed issues will be resolved. The one area where we can help to improve the situation is translating the client to our languages. We downloaded the source code via anonymous svn and performed the localisation (L10n) for German, i.e. we just translated the few resource bundle files we found. Unfortunately, most of Wonderland was still missing internationalisation (i18n). Because we have some experience with i18n/L10n of Java programs we tried adding the missing pieces. After some days of careful source patching, translating, updating from svn and resolving conflicts we had a pretty good i18n coverage.
We did not want to keep this work behind our closed doors so I contacted the Project Wonderland team and asked if they were interested in our work. After sending the initial patch I was welcomed with open arms and a huge amount of appreciation and received developer access almost instantly. Then I tried committing the changes we made piece by piece, checked every change and by doing so noticed several little (mostly cosmetic) things that were crying out for a fix. I became a little too ambitious with it, started breaking things until it raised some eyebrows and was brought back into line. Now I am working in minimal invasive mode, conducting a code review with the owner of the source code before committing my changes and also learned to write bug reports before sending in a patch for review. So, let this be a small lesson for you all future Wonderland contributors. ;-)
Right now we (the whole Project Wonderland team) are still finding pieces of Project Wonderland where i18n is missing or can be improved and fixing those parts. We really look forward to a version where our target group must not jump over a language barrier in addition to the technical challenge they will face when using a virtual world client for the first time in their lives. When working with the development version of Project Wonderland it is great and encouraging to see the improvements that happen to it every day. And it is also great to see that other Project Wonderland team members start taking care of little cosmetic things in the source. ;-)
And (just in case you wondered), we are still calling it "Project Wonderland" here.'

To get some idea of how the user interface changes when using different locales, the screenshots below are of the avatar configuration user interface for the US English, German, French and British English locales, respectively (you may need to widen your browser). Volunteers are needed for other languages, so if you're able to spend a while translating from English, German, French, or British English to some other language, please get in touch.

If you were a high school student on summer vacation before heading to college and you had a little extra time and some Sun SPOTs, what would you do? How about sending a Sun SPOT to near space?

  

The whole project is chronicled here: http://hibal.org/missions/apteryx/

They have made their source code available here: http://kenai.com/projects/hibal-spot

Hmmm.... It reminds me a bit of another project

I was honored to have been invited to the Software Freedom Week celebrations at BVB College of Engineering and Technology, India. Here are the proceedings of the event: http://softwarefreedomweek.org/2009/

Thanks to Reshma Desai (Sun Campus Ambassador, BVBCET) and Ganesh Hiregoudar (Sun India OSUM Coordinator) for the arrangements

We have just released the second preview of Wonderland 0.5. You can download the release from the Binary Downloads page. Since we have been feature frozen since the first preview, this release primarily contains bug fixes. Check out the Issue Tracker to see a list of all 214 bugs that were fixed since September 14th. There are still over 200 known bugs left to fix, so it will take a while longer to work through all of those and arrive at a final 0.5 release. While not the final 0.5 version, we believe that this release is now more stable, and certainly more functional, than v0.4. On the programming side, the APIs have also been stabilized. We strongly encourage anyone still using 0.4 to move to this second preview release as soon as possible.

In addition to bug fixes, the release contains a few previously unfinished or incomplete features. These include:

Apps on HUD

In Preview 2, you can right click on any 2D application and select "Show in HUD" from the context menu. This places a copy of the application on the glass pane, known as the HUD or heads-up display. In the image below, you can see Firefox running in the world (bottom left). By also placing the Firefox window on the HUD, we can walk around or change camera angles while maintaining a pixel-perfect view of the Firefox window.

To remove the application from the HUD, you can simply click on the blue Remove from HUD icon or the red X in the window header. This will not close the application in-world, but will simply remove the item from your glass pane.

Go to user

"Go to user," an important feature from v0.4, has finally made a reappearance in v0.5. To use the feature, open the Users list (Window --> Users) and click on the name of the person you wish to find. Then click on the icon to the right of the telephone icon, which the cursor is pointing to in the image below.

Also note that you can change the volume for any user in this window, as well as change how name tags are displayed (right-most icon).

Cone of Silence

Some changes have been made to the Cone of Silence. There is no longer a Cone of Silence item in the Components dialog. Instead, you can add a Cone of Silence capability to any object to turn it into a sound-proof area. The property sheet for the Cone of Silence has been re-designed, providing more options for defining the bounds of the cone. Perhaps the most useful new feature is the ability to "Show Bounds."

This lets you see exactly where the sound proof area is located. In the left-hand image below, you can see what the bounds look like when I select "Use Cell Bounds" from the property sheet. Although the object is cylindrical, you can see from the visualization that the bounds are rectangular. If I used these bounds for the cone of silence, people standing right outside the pod would be included in the cone of silence and be able to hear anyone speaking inside. To avoid this problem, I chose to specify a radius, which gives me a spherical shaped area instead of a rectangular one. By adjusting the size of the sphere (below right), I was able to more exactly match the shape of the pod model such that the cone of silence only activates when avatars step inside the pod.

The new property sheet also allows you to specify if you want to hear any audio from outside the cone.  You might want this, for example, if you are holding private meetings in the cone, but still want to hear the buzz of activity from the surrounding space.

Authenticated Login

In this release, a server can be set up with authentication. The new authentication scheme allows you to configure the server so that any guest may log in, but only authorized users can access the Server Admin console.

See the tutorial Configuring Wonderland Authentication for information on how to set up authentication on your own server.

Webcam

Although not technically part of the Preview 2 release, I wanted to mention the availability of a new stable module for viewing webcams in world. The Webcam module is available for download from the Documents and Files section of the wonderland-modules open source site. To install this module, download webcamviewer.jar and save it on your computer. Then use the Manage Modules section of the Server Admin console to install the module on your server. The next time you restart the Darkstar server, you will have a Webcam item in your Component dialog (Insert --> Component...). For more information on installing modules, refer to the Managing Modules section of the Web-Based Administration tutorial.

The image below shows the Webcam application running in the world. To switch cameras, right click on the application and select "Take Control" from the context menu. Then click on the Open icon (second one from the left) and enter a camera URL. For example, for this Citron-crested Cockatoo cam in Germany, I entered:

http://chrissie.selfhost.tv:85/axis-cgi/mjpg/video.cgi?resolution=640x480

For more information, see Nigel's New Webcam Module forum post.

Yesterday we conducted our second community test of the release candidate for Project Wonderland v0.5 User Preview 2. On the whole, the test went extremely well.

As you can see from the screenshots and video, the test script was based on a Halloween theme. The video should give you a sense of the interaction. During the session, we tested various HUD windows including the Users list, the FPS (Frames Per Second) Meter, and Gestures. The bulk of the test focused on Capabilities, including Audio, Placemarks, Cone of Silence, Clickable Link, and Portal.  During the test we added spooky sounds to objects in the world, including creating a "tomb of silence," we piled into a coffin, and we stepped through a tombstone portal to the "great beyond." In the afterworld, we made good use of our time by creating sticky notes with things that went well during the test and things that went wrong. During this debriefing session we recorded and discussed the various problems that cropped up.

The good news is that most of the functionality worked for most of the people. Of course, as with any test, we did find a number of problems. If you're interested in the details, the issues are listed in my recent forum post. The worst problem of the day happened near the end of the session when everyone's sticky notes simultaneously vanished. Although vanishing was in keeping with our theme, the cause of this unintended vanishing was a real mystery. Fortunately, a few us were able to recreate the problem after the test. It had to do with some software cleaning up too vigorously when people teleported to a far-away place like the "great beyond." Once identified, the problem was easy to fix. The other serious issue that surfaced during the test was a shared application "deadlock" problem. The test helped to characterize the problem, which we had seen before. This one is a bit more complex to fix, but a fix is in the works.

Below are some still images from the test. One feature to point out is the Happy Halloween scary face one. This shows a PDF document on the HUD, which is a new feature in the Preview 2 release.

Eerily coincident with downpours on both coasts of the US, we are publishing a deluge of new and updated Wonderland 0.5 tutorials. You can find links to all of them on the documentation wiki, but here's a rundown:

For world builders, we have these tutorials: 

• Assembling Worlds, an introduction to assembling worlds by inserting, moving, rotating, and resizing new components.

• Building a Project Wonderland World from Scratch, step-by-step instructions on how to create a Wonderland world from scratch.

• Creating and Importing Artwork for Non-Artists, which guides non-artists through creating 3D models using Google SketchUp (TM) and importing them into Project Wonderland.

• Importing 3D Models is an introduction to importing existing 3D models into Project Wonderland.

• Configuring user authentication describes how to enable user authentication in Wonderland 0.5.

Developers should check out these:

• Download, Configure, Build and Run from the Wonderland v0.5 Source is an introduction for all developers on downloading and compiling the source code, configuring the Wonderland distribution, and running both the server and client.

• Working with Modules describes the module architecture of Project Wonderland, the basic structure of a module, and how to deploy a module using the Web-based Administration UI.

• Download, Build and Deploy Project Wonderland v0.5 Modules describes how to download, build, and deploy the source code for Wonderland modules.
  

• Developing a HUD-Enabled Module describes how to develop a module that uses the HUD (Heads-up Display).

• Developing a New Cell describes how to extend Wonderland by creating a custom cell type.

• Writing 2D Applications describes how to develop 2D applications in-world that use the Java Swing GUI toolkit.

• Adding Items to the Context Menu describes how to add items to any object's context menu.

• Writing Client and Server Plugins describes how to write client and server plugins for Project Wonderland, code that runs when either the client or server is first initialized.

Finally, there are some updates on the basics:

• Launching the Client describes how to launch the Project Wonderland client via Java Web Start.

• How to Set Up a Project Wonderland Server Behind a NAT or Firewall describes how to configure Project Wonderland if your server is behind a firewall or NAT, and how to configure your Wonderland client to work with proxies.

In what may be my city-girl roots showing, I feel uncomfortable in a virtual world that has a never-ending horizon. I need the psychological comfort of a skyline. This prompted me to experiment with creating skyline models for Wonderland. Recall from my last blog post, this sand dune skyline:

I thought I would describe how I made this skyline so that those of you out there interested in creating your own models for Wonderland could give it a try, and hopefully share some models with the rest of us.

Preparing the Texture

The first step is to take or find a nice skyline panorama photo such as one of these Death Valley panoramas generously donated to the Wonderland community by MIT Professor and ace nature photographer, Chris Schmandt:

Death Valley Panoramas

Don't be tempted to use the higher resolution versions of these photos. The texture file size will be too large to perform well. Once you have a photograph, use your favorite graphics editor, such as Adobe Photoshop Elements, to edit out the sky. In Photoshop, I use the magnetic lasso to select the sky. I almost always have to zoom in and add and subtract bits from the selection to end up with an accurate selection of the sky. Then I feather my selection with a value of "1" to make a smooth edge and delete the sky. In Photoshop, the space that was the sky is now transparent (as indicated by the gray checkerboard pattern in the image below). Some tools, like GIMP, require you to "add transparency" to the image to achieve this effect.

Once you have deleted the sky, save your edited photo in a new file. Assuming that your original photo is a partial panorama like this one and not a 360 degree scene, you'll need to make sure the image tiles properly. To do this, double the width of your canvas, and paste another copy of the panorama into the file.

Then do a "flip horizontal" on the copy. By having the outer edges of the photo be the same, you ensure that the texture will look correct when another copy of the texture is placed next to it.

Carefully align the two images so that you can't see a middle seam. You may need to do a bit of image editing to remove any odd artifacts at the seam. Finally, save the final image "for the web" in the PNG-24 format.

Before you leave your image editing application, you might want to clip out a small piece of the image to make a ground texture that matches the skyline. In the screenshot at the beginning of this post, you'll see that I made a sandy ground plane by using a small portion of this panorama photograph.

Modeling the Skyline

Now on to SketchUp. In SketchUp, create a circle at the origin with a radius of 150 meters. Then extrude the circle upwards to create a cylinder. Usually about 12 meters high works well. Then delete the top and bottom circles so you have just the ring.

There's a trick I use for importing the texture. Create a "scratch" rectangle someplace in the document that is 12 meters high. Import your image as a texture and apply it to the rectangle. Now delete the rectangle. Select the Paint Bucket tool and navigate to the "Colors in Model" or "In Model" category. You will see a thumbnail of your skyline texture. Click on the skyline thumbnail and use the Paint Bucket to apply the texture to the inner surface of the cylinder. You may need to experiment with different sized circles to get the texture to repeat properly.

When finished, save the model and then select File -->  Export --> 3D Model... Make sure the format is set to "Google Earth File (*.kmz)."

If you would like, now is the time to make your coordinating ground plane. While still in SketchUp, you can open a new document and create a circle with the same 150 meter radius. Extrude the circle .02 meters since there can be issues in Wonderland with zero width models. Create a small "scratch" rectangle and import your ground texture and delete the rectangle. Then use the Paint Bucket tool to apply the texture to the circle. For good measure, I also apply the texture to the rim and the underside of the circle. You may find that you'll need to go back and edit the texture image if it doesn't look good when tiled. Save this file and export it to .kmz format.

Importing the Skyline into Wonderland

To try out the skyline, consider starting with an empty Wonderland world. To get an empty world, navigate to the "Manage Worlds" section of the Wonderland Server Admin console and click "make current" in the "Empty World" row of the Initial Worlds table. Please be sure no one else is using the server before you do this. Then launch the Wonderland client and log in. Make sure you are standing in the exact center of the world by using Placemarks --> Starting Location.

Next, drag and drop the skyline .kmz file you just created into the Wonderland window. If you started with an empty world, you should also drop in a ground plane with the same or larger radius as your skyline. Again, be sure you are standing exactly in the center when you drop in the ground.

There are several adjustments you may need to make. First, make sure your ground plane is at ground level. Right click on the ground model and select "Edit" from the context menu. Now click on "Details" to open the Details pain. If the "Y" position is anything other than zero, change the number to zero and press Tab. Your ground will now be located at the proper level, giving you a point of reference for adjusting your skyline.

If the skyline is too low, right click on it and select Edit. Using the Details pane, increase the "Y" value to move the skyline up until the bottom edge is where you'd like it to be. One technique is to move the skyline up until you see a gap between the ground and the skyline, as illustrated below, and then lower the skyline until the two surfaces meet.

The second adjustment involves lighting. Right click on the skyline again and select "Properties..." When the Properties dialog opens, click on the "Model Component" item in the Capabilities pane. Then uncheck "Lighting Enabled" and click "Apply." This will more closely approximate the lighting settings used in SketchUp. Do the same for the ground model, if desired. Now all you need to do is add other content to your world, such as the Temple of Horus or an Environmental Home, and you are on your way to having a unique virtual setting.

Skylines in the 3D Warehouse

If you have created a new skyline that you would be willing to share, please upload it to the Google 3D Warehouse and let us know, preferably by posting a message to the Wonderland Discussion Forum. I have started a 3D Warehouse collection of models appropriate for use in Wonderland worlds.

Models for Project Wonderland

This sand dune skyline, plus the two others from my previous blog post are included in the Skyline collection. Coordinating ground planes are located in the "Floors for Project Wonderland" collection.  I'll be delighted to add your skyline and coordinating ground planes to the collection. If you do upload to the 3D Warehouse, it's a good idea to geo-locate your model.  Although it seems silly to associate a location with a model like this one, it is the only way to get both .skp and .kmz files included on the page for the model. Instructions for geo-locating a model are embedded in this help document:

Placing a SketchUp Model in Google Earth

Follow steps 1-6. After that, upload the model using File --> 3D Warehouse --> Share Model... Just be sure that you uncheck the box "Google Earth Ready" in the upload dialog.

I'm looking forward to seeing your creations.

To make the videos that I've posted this week, prepare for live demos, and work on new tutorials, I have spent a lot of quality time in Wonderland, Google SketchUp, and the Google 3D Warehouse. As some of you may know, SketchUp was originally designed as a tool for architects and engineers. Google bought the company that created SketchUp in 2006 in order to provide a free tool for people to model buildings for Google Earth. What's significant is that SketchUp was not originally designed for real-time environments like Wonderland or Google Earth.  That means that many of the SketchUp models you find in the 3D Warehouse will not perform well in Wonderland. They are made up of too many polygons, which makes it difficult for the Wonderland client to draw them quickly.

Identifying Appropriate Models in the 3D Warehouse

After experimenting with importing lots of different models from the 3D Warehouse into Wonderland, I learned that the models that work best in Wonderland are those created specifically for Google Earth. You can identify these by the blue ribbon in front of their name. Here's a random example:

The blue ribbon designation means that someone from the Google Earth team hand-selected the model for inclusion in the Google Earth 3D layer. For excellent performance in Wonderland, there are two other factors to consider in addition to the blue ribbon. First, look at the "Model complexity" rating in the lower right corner. Models with a "Simple" rating work best. Then click on the "Download Model" button and look at the file sizes. Anything under 1MB is likely to work extremely well. If the file is over 2MB, you will probably start to see some performance impact.

To find simple complexity Google Earth models, use the advanced search page.

Enter your query, and in the "Item type" section, select complexity "simple" and file type "Google Earth (.kmz)."  Then check the first two check boxes in that section. What's amazing is that there are over 30,000 models in the Google Earth 3D buildings layer that meet these criteria. For example, I found this model of the Parisian Palais de l'Élysée as well as an attractive red sculpture model which we used as a backdrop for this week's staff meeting.

Note that when you bring models like this into Wonderland, they may look too dark. You can fix this by right-clicking on the model and selecting "Properties" from the context menu. In the "Model Component" property sheet, uncheck "Lighting Enabled." This restores the original SketchUp lighting. To learn more about positioning your models in the world, refer to the Assembling Worlds tutorial.

One unfortunate aspect of the 3D Warehouse is that Google treats geo-located models differently from objects that don't have a location. This means that small models like tables, chairs, lamps, etc. do not have the Google Earth (.kmz) formatted files associated with them, nor do they have a complexity rating. The only guidance you have about whether or not the model will work well in Wonderland is the file size of the Sketchup (.skp) download. The same rule of thumb applies - the smaller the file size, the better.

If you want to try a model that does not have a .kmz version listed in the Downloads section, simply download the .skp file for the most recent SketchUp version, open it in SketchUp, and select File --> Export --> 3D Model... Make sure the "Google Earth File (*.kmz)" format is selected and save the file. This will generate the .kmz file you need to drag and drop into Wonderland.

When you are adding models to a Wonderland world, it's a good idea to show the FPS (frames per second) meter (Window --> FPS Meter).

In this example, notice in the middle how the frames per second dropped dramatically. That happened when I turned my avatar to look at some trees with very high polygon counts. Each time you add a new model to the world, face the model and check your meter. If your frames per second drop, then the model may not be suitable for use in Wonderland.

SketchUp Guide for Creating Your Own Models

In researching how Google Earth modelers manage to create fantastic-looking models of large buildings that are often under 1MB, I came across an extremely helpful reference that Google has put together for people creating models for Google Earth:

Modeling a City

I would encourage everyone who is creating their own models using SketchUp to read this document carefully. Let me give you one tip from the document that I have found particularly useful. When you create your own textures, you should export them from your graphics editor (eg, Adobe Photoshop Elements) for the web in PNG-24 format. This format does the best job with transparency and small file size. This has allowed me to create some nice-looking skyline models shown here in Wonderland:

You could model these skylines in Sketchup by applying the texture and then tracing the skyline and cutting out the sky parts. That would create a model with a huge number of polygons. Instead, using a transparent PNG-24 texture, as recommended in the "Modeling a City" guide, I was able to create an extremely simple model with interesting contours.

In my next blog post, I'll describe how you can make one of these skyline models for yourself.

Quizás este blog será entendido sólo para aquellos en el Campus Menlo Park de EEUU pero no puedo dejar pasar la oportunidad de mencionar como es reconfortante trabajar para la comunidad de Sun y saber que alguién estará allí en caso de necesidad.

Recibimos una terrible noticia que le pasó a una de las personas que trabaja como contratista en Sun, que quizás más de alguno a visto en el Campus. No vale la pena mencionar la tragedia aquí pero si es necesario dejar por escrito la buena voluntad de todos los que trabajamos en Sun. Uno nunca sabe cuando le puede tocar y obviamente nadie esta preparado para este tipo de cosas.

Es de esperar que estas palabras se hagan oir y le den fuerza a esa madre que ha perdido un hijo.... Mucha fuerza!!! y que Dios acompañe a esa familia en dolor.

Gilda

Ya había mencionado a mi amiga Keca en un blog del 2008 y su peregrinar debido a la enfermedad ELA (esclerosis lateral amiotrófica o ALS en Inglés) que la afecta desde hace unos años.

El otro día me avisaron que le hicieron un reportaje en CNN Chile por las intervenciones con células madres, una operación que en nueva para el país. El video es un reconocimiento a su esfuerzo y al esfuerzo de su familia para salir adelante.

Hace día que tengo que enviarle el email de felicitaciones y lo orgullosa que me siento de ser su amiga. Obviamente me había propuesto escribir este blog como mi reconocimiento digital pero las cosas han andado un poco locas aunque debería haberlo hecho la semana pasada pues es importante reconocer los sacrificios inmediatamente.

In my September 12th blog post, 0.5 Preview is on the Way, I highlighted the new Wonderland feature called Capabilities. The first video on this page provides a more in-depth look at several of the capabilities that come with the Wonderland v0.5 Preview1 release. Since security is such an important topic, there is a separate video focused entirely on the security capability. Here's a short description of the capabilities included in the video clips:

Audio Capabilities - Provides the ability to add recorded audio or an audio stream from the web to any object. You may also select from several options for playing the audio, including always, when an avatar is in proximity, or manually via a "Play" command on the right-click context menu.

Cone of Silence - This allows you to associate a sound-proof area - cone of silence - with any object. People outside can't hear what's being said inside, but you can opt for some amount of outside audio to penetrate the cone. In the nightly builds there is now a feature that allows you to visually see the bounding box (or sphere) of the cone of silence and adjust its size.

Container - This capability is used to group objects. Any object created while an avatar is within the bounds of a container will be associated with that container. All the objects in the container object can be moved as a group. Security properties applied to the parent object will also be inherited by all the other objects included in the container.  You can use the World Hierarchy pane in the Cell Editor, which you'll find in the Wonderland Tools menu, to view how objects are grouped. You can also drag and drop objects onto one another in the World Hierarchy pane to create and edit groups.

Portal - Using this capability, any object can be turned into a portal. Portals can take users to another location on the same server or to a location on a different server. Portals are part of the support for federation in 0.5, where Wonderland servers can be linked together as easily as web sites.

Security - This capability is used to individually protect objects in the world. Users can restrict what other users can see or do to objects they own by enabling or disabling view and modify access. Object-level security works in conjunction with another new Wonderland feature called Groups. You can create and edit groups using either the in-world Groups editor (select "Groups..." from the Edit menu) or the Group Editor in the Server Admin Console.

Combining Capabilities

Some combinations of capabilities are particularly helpful. For example, combine a portal with the security capability so that only a subset of users can see the portal. This provides an extra level of protection for areas you wish to secure.

The security video also demonstrates how you can combine the container, cone-of-silence, and security capabilities to create a private, sound-proof space in the middle of a public area. By protecting the interior shell of a building, all users can see the exterior shell, but only authorized users may enter the private space. Even if unauthorized users attempt to enter the protected space by turning off collision, neither the interior of the space or the audio within that space will be seen or heard by the unauthorized person.

Write Your Own Capability

While we provide a few important capabilities, any developer may create a new capability. One capability that has already been contributed by a community member is a Clickable Link capability. When you apply this capability, you can enter a URL in the Clickable Link property sheet. After doing so, that URL will launch in an external browser window whenever a user clicks on the in-world object. If you want to experiment with this capability, you can download the module by right-clicking on the jar file link below and saving the file on your desktop:

https://wonderland-modules.dev.java.net/files/documents/8222/142894/clickable-link.jar

To install it on your own server, simply navigate to the Manage Modules section of the Wonderland Server Admin console, scroll to the bottom of the page, and click the "Browse..." button. Once you locate the jar file you just saved, click on "Install." You should get a message that the module was successfully installed.

Jordan is writing a developer-level tutorial on how to write new capabilities, so that will be coming soon. In the mean time, you can use clickablelink module in the "unstable" section of the wonderland-modules workspace as an example if you're inspired to try your hand at writing a new one. Here's where you can find it in the source code repository:

https://wonderland-modules.dev.java.net/source/browse/wonderland-modules/trunk/0.5/unstable/clickablelink/

The following article voids warranty. Say your SPOT is "bricked" and you've been through the Q&A on the SpotWorld forum. Some folks don't like RMAs, warranty and would rather fix it themselves. This blog is for them.

A non-responsive SPOT with no USB activity can often be recovered by reflashing the bootloader. The SPOT's JTAG interface can be used to install a new bootloader if the old one is corrupted. We use a custom eSPOT test fixture and Macraigor USB2DEMON JTAG interface with flash programmer/OCD Commander software for reflashing. The test fixture has PCB retaining plastics and Millmax spring loaded "pogo" pins for connecting to the JTAG interface. The test fixture is not publicly available. How you connect to the SPOT pogo pin targets will take some ingenuity. Soldering wires would be easiest; however, soldering the targets make for poor pogo pin contact and can damage our test fixture.

A bricked SPOT will power up and the power LED comes on. The activity LED may be off, or just steady green. If the activity LED is steady red then it failed the SRAM memory test. There will be no USB activity even though different cables and computers are tried.

JTAG

JTAG (Joint Test Action Group) is a synchronous serial interface used for testing complex ICs. The interface is defined by IEEE Standard Test Access Port and Boundary-Scan Architecture, IEEE1149.1. It is used to control external pins (boundary scan), read and modify internal state and interact with internal modules such as the ARMs debug unit. For this application, we are using the ARMs built-in debug unit.

SPOT JTAG Interface
To get to the JTAG pads, you need to disassemble the SPOT. Remove the Phillips screw holding the plastics together and snap apart the sections gently. Disconnect the battery connector. Remove the main board from the plastics by cutting off the two heat-staked pins near the antenna with a sharp knife flush with the board (Xacto or Swiss Army works). Before you remove the board from the plastic, put a piece of tape over the button plastic to hold into place. It's natural disposition is to escape and disappear once the board is free. The board should pop out of the plastics. Flip the board over with the antenna (or MAC label) at the top. On the upper left side, you will notice 3 x 5 array of gold plated pads. The five pads closest to the shield are the JTAG connections to the ARM. The pogopin targets are 0.060" diameter pads. They measure 0.100" between centers and the JTAG row is 0.300" from the edge of the board.

The JTAG signals from top to bottom are TDI, TDO, TMS, TCK and nRST. The JTAG signals lines are pulled down to ground with 10K resistors. The JTAG interface should not obtain power from the SPOT. The SPOT can be powered by a fully-charged battery or USB. RTCK is not used and we do not use adaptive clocking. nRST is connected to system reset and TRST. VCC (3.0V) can be used as the VDD_SENSE voltage, this let's the JTAG interface know what voltage to signal at. VCC is on the first column second pad down and ground on the first column bottom pad. Ground can be alternately connected  to the screw hole pad or the USB shield.

Standard JTAG interfaces connect to a 20 pin (2x10) 0.100" pin center keyed male header through a short ribbon cable. The following drawing are the SPOT JTAG connections to that header.

JTAG Interfaces
There are a large number of interfaces and development software packages.We've used the commercial units from Macraigor and the Segger "ARM-ICE" JLink units. They work out of the box and the companies provide support. If you are doing mission critical stuff, this is the way to go.

Recently I've been experimenting with an open source alternative called openocd. It is a command line application that works with a large number of interfaces. SparkFun has a community forum for openocd and they sell the Olimex ARM-USB-OCD based on FTDI FT2232 USB to serial converter. Amontec has similar JTAG interfaces with openocd support. While the FT2232 is a popular JTAG interface, there are licensing issues with the FTDI drivers and the openocd GPL code. The upshot is they do not release binaries and the sources need to be compiled.

There are good writeups on how to build openocd on the Sparkfun forums, through Yagarto and the openocd documentation. For the PC, you can use Mingw or Cygwin. This project uses libtool, automake and autoconf in addition to the usual gcc tools and you will need to install them if you don't have them already. openocd can be downloaded using subversion.

openocd
openocd is an open source software package for interacting ARM processors using JTAG. While it is capable general JTAG usage, it's primary target is the ARM processor. openocd uses a scripting language called Jim to customize to various ARM processors, cores and boards. Jim is a stripped-down version of Tcl.

openocd can be given optional arguments to run a command, execute a script, set debug level or log to a file. If no arguments are given, it will attempt to load the default script, openocd.cfg, in the current working directory. openocd can connect to telnet or gdb to interact with it once it's launched.  There is the Zylin plug in modules for Eclipse SDK which add a GUI for all of this.Yagarto has a good writeup on how that is used.

openocd has builtin commands for low level JTAG manipulation, memory peek and poke, and basic debug with breakpoints, trace, run, register dumps. The higher level functions let you probe, erase and write Flash memory.

For the SPOT, my openocd.cfg script is: 

telnet_port 4444
gdb_port 3333
source [find interface/arm-usb-ocd.cfg]
source [find board/espot.cfg]

The first two commands tell openocd what telnet and gdb port number it should listen on. By convention, openocd scripts are organized by subdirectories: "interface" contains information about the specific JTAG interface dongle, "target" is the ARM Processor IC and so on. I used the existing Olimex arm-usb-ocd.cfg script and put the rest of the stuff into the espot.cfg board script. You can download the board config file here -> espot.cfg and copy it into your "board" subdirectory.

The 9200 starts at 32KHz, and JTAG needs to run at a fraction of that (4KHz). The initialization routine in the espot.cfg starts the main oscillator and the two phase lock loops going. It enables and sets up both flash and external RAM. Once initialized, the SPOT will be running 180MHz with JTAG at 6MHz.

We lock the first four sectors of Flash to prevent accidental writes of the bootloader in normal operation. Unfortunately, there was some incompatibility with the openocd flash protect command and the Spansion MCP Flash memory we are using. I ended up writing two procedures which will lock and unlock the lower four sectors.

Say you have a working version of openocd. Make your own openocd.cfg script like the one above. If you have a recent SPOT SDK go into the spot sdk directory and find the "arm" directory. Inside is a file called bootloader-spot.bin, copy this file to the same directory your openocd.cfg file is in.

Connect the JTAG interface and the SPOT, power the SPOT and launch openocd. You should get messages that the JTAG interface is happy. Connect with telnet (I use PuTTY) with localhost as IP and port 4444 as telnet port number. Telnet should give an openocd prompt and wait for input. First thing that must be done is to initialize the processor with the command reset init. It should display progress of setting things up and it's slow.

Open On_Chip Debugger
>reset init

JTAG tap: at91rm9200.cpu tap/device found: 0x05b0203f (mfg: 0x01f, part: 0x5b02, ver: 0x0)
JTAG Tap/device matched
srst pulls trst - can not reset into halted mode. Issuing halt after reset.
target state: halted
target halted in ARM state due to debug-request, current mode: Supervisor
cpsr: 0x60000013 pc: 0x20000cc0
MMU: disabled, D-Cache: disabled, I-Cache: enabled
4 kHz
Main oscillator stabilized
PLL A locked at 179.712MHz
PLL B locked at 48.05MHz
External Memory Initialized
Clocks enabled
Update cp15 control register
2: 40001078
6000 kHz
>

This will put the ARM into a known good state. Next try:
>flash probe 0
Flash Manufacturer/Device: 0x0001 0x0000
flash 'cfi' found at 0x10000000

It found the flash and can talk to it. To flash the new bootloader, give it the command flash_boot.
>flash_boot
Flash Manufacturer/Device: 0x0001 0x0000
flash 'cfi' found at 0x10000000
boot section unprotected
auto erase enabled
wrote 19308 byte from file bootloader-spot.bin in 3.922000s (4.807616 kb/s)
boot section protected

You should be able to plug the unit into USB and do a normal ant upgrade from there.

flash_boot is a procedure I wrote which unprotects the lower four sectors, runs the flash write_image and protects the sectors.

I added a few other commands to the script. One was a dirt simple RAM test.
Testing internal RAM at 0x200000 is
>test_ram 0x00200000 64
Testing external RAM at 0x20000000 is
>test_ram 0x20000000 512 alternatingbits
You can fool with the SPOT LEDs too with
>set_led green on
>set_led red off

Exit the session with:
>shutdown

One more thing. Please don't post SPOT problems here in this blog. Better to post them on the sunspotworld forums.

Thanks

-bob

So much has been happening around 0.5 since the Preview1 release on September 14th, that I haven't had a chance to do any writing. It's time to start catching up! Today, I'll tell you about two virtual world conferences a number of people on the Sun Labs team attended and show you one of the new 0.5 demo videos that we've been working on.

Engage Expo - 3D TLC Track

Jonathan, Mike, and I attended the 3D Training, Learning and Collaboration (TLC) track at the Engage Expo conference in San Jose on September 23-24. Eric and Sam Driver from ThinkBalm talked about their most recent report on the barriers to entry for virtual worlds in business. I'm sure it will come as no surprise that computer hardware and firewalls were two of the biggest problems.  There weren't too many people demo'ing at the conference, but we did hear from a number of companies that have been doing real virtual world projects. My favorite project was the virtual chocolate factory created by FXPal. Visitors can take tours of the virtual factory and workers can monitor the factory remotely. They also had a mobile interface for controlling some of the factory systems.

On Thursday, I participated on a panel called "Integrate or Evaporate: Plugging 3D into the Enterprise Infrastructure." I prepared the video above for this session. The video shows how a business might use Wonderland to create a world from "found art," primarily from the Google 3D Warehouse, and existing marketing collateral in the form of web pages, images, and PDF documents. Users can create ad hoc worlds by dragging and dropping existing art into the virtual world without requiring an artist to create custom content. Our import mechanism makes it possible for artists to create high-quality artwork which can be deployed just as easily. In the world shown in the video, we can give presentations, interact informally with customers in front of a whiteboard, and run live training sessions in-world using a web-based tool.

FountainBlue Virtual World Event

The following day, the same crew, plus Paul, attended the FountainBlue Virtual World event, which Mike hosted on Sun's Santa Clara campus. FountainBlue is an organization that runs events for entrepreneurs, investors, and other innovators. I was asked to demo Wonderland v0.5 during lunch. This marked our very first live demo of the Preview1 release! Jordan and Miriam participated remotely from the east coast. I'm happy to report that the demo went flawlessly. We used the Orientation World, the only artist-created default world that comes with the Wonderland release.

The demo focused on application sharing, audio features, brainstorming, and world creation using drag and drop. I also demo'd object-level security, but since it's difficult to show with only a single computer, I used a video clip. I'll include that video in my next post.

CNBC Interview

The second live demo of Preview1 happened only hours after the first one. Miriam and I were interviewed by a CNBC reporter in the same Wonderland world we demo'd earlier in the day. The most stressful part of that demo was that the reporter asked us to do the screen capture for them! Fortunately, all went well. I'll certainly post a link to the story if and when it appears.

As you know if you follow the Wonderland Forum or the ISIG mailing list, we did the very first community test of Wonderland yesterday. Certainly everyone on the Sun Labs team was pleased with the results. We didn't get quite enough people to test the server limits in terms of low-quality avatars, but we took the opportunity to test other features including avatar configuration, the whiteboard, sticky notes, and several shared applications. We had a total of about 22 to 23 clients connected to the world. After an initial period, everyone switched to using high-quality avatars.  The server held up extremely well. There were no show-stopper server-related problems for the whole hour of the test.

On the client side, a persistent out-of-memory problem cropped up for just about everyone, causing people to have to restart their client, so that will be the focus of this week's debugging efforts. There was also another shared application problem which occurred after we had been using the applications for a while, which we'll also look into.

The consensus was that we would like to try to keep doing these tests on a regular basis, so I hope more of you will join in for the next one.

Here are some images from the testing. We only had one really good blooper. That happened when I clicked on the hand-raise button twice in a row. My arm stretched to gigantic proportions! Otherwise, you can see us testing out the various applications, including a Flash game playing in a Firefox window that Sun's Chief Gaming Officer, Chris Melissinos, could not resist showing us.

Aquí estan mis notas de dos presentaciones de la primera sesión que asistí en GHC09. Esto fue ayer Miércoles pero el tiempo ha estado escaso. Los títulos están en Inglés pues no vale la pena traducirlos a este nivel.

Talk 1: "Improving the User Experience of Information Technologies in Residential Settings"
Speaker: Erika S. Poole (Georgia Institute of Technology)

La presentación estuvo basada en los resultados empiricos de los estudios que miden la interacción de los dueños de casa con el suport técnico de los diferentes artefactos electrónicos que se manejan en estos dias en la casa, comenzando por el teléfono, contestadora y los computadores. Entre los estudios estuvo el analisis de 4 años de datos sobre soporte via web y la idea principal es sacar las mejores prácticas o tener una mejor idea de como la red en una casa debería lucir. Este PhD está en el ámbito de interacción humana.

Se dieron cuenta que lo normal es recibir ayuda informal en vez de suporte técnico. Es decir, llamar a un amigo es más comun que llamar al servicio técnico. El estudio también busca poder predecir los problemas computacionales y terminar con los conceptos errados en computación. De cambiar, las modificaciones van desde (1) cambiar la arquitectura, (2) cambiar la configuración y (3) detección/correción de errores.

Esta construyendo la aplicación Tech Clips que le permitirá a la gente compartir consejos tecnológicos para compartir con mienbros de alguna comunidad social.

Talk 2: :Automatic Generation of Parallel Programs with Dynamic Scheduling on a Network-on-Chip (NoC):
Speaker: Jungsook Yang (UC Irvine)

Comenzó con una introducción a NoC y de donde nace la necesidad de tener este tipo de comunicación. Dado el nuevo paradigma del diseño de microprocesadores, se ha tenido que innovar en la manera de conectar procesadores y es la justificación de comunicación on-chip. De ahí el paso de buses, a point-to-point y ahora a NoC que usan menos wires, son escalables y tienen una mejor bandwidth.

3 son las metas en esta tesis: (1) mejorar la comunicación durante lectura y escritura, (2) una estrategia de balance de carga en tiempo real y (3) un simulador NoC para la optimización de hardware y software.

Cuando iba en camino a un desayuno de Latinas in Computing, pase por el puente que une dos sectores del hotel cuando vi gente mirando hacia la quebrada. Obviamente pregunté que pasaba y ahí me contaron que una mamá lince estaba debajo del puente. Según la gente del hotel esta mamá esta criando unos cachorritos en el sector. Por lo general no se ven pero este año no ha llovido mucho entonces quizas el animal andaba buscando comida o agua.


Image Copyrights 2009 @ Gilda Garreton

asi se llama el video filmado en la versión 2008 de la conferencia Grace Hopper y vale la pena ver el video para ver la energía que existe en este tipo de conferencia y para los que me conocen me podrán ver por ahí. Buena suerte y a ver si me encuentran.

Increible pero este la quinta vez que tengo la oportunidad de asistir a la conferencia Grace Hopper, todo gracias a Sun que me ha permitido participar todos estos años. Los beneficios han ido en aumento y sólo en el 2004 no presenté.

Desde el 2006 he estado participando/organizando paneles (07,08), BoFs (06,07,08,09), almuerzos (07,08,09), recepciones (08,09), poster (09) y las mesas donde Sun está representada.

Todo partió en el 2004 en Chicago y aquí esta un mapa de mis viajes. Desde el 2006 se han tenido temas y siempre es interesante como gente propone cosas que calcen con el tema de la conferencia.

GHC04:
GHC06: Making Waves, San Diego CA
GHC07: I Invent the Future, Orlando FL
GHC08: We Build a Better World, Keystone CO
GHC09: Creating Technology for Social Good, Tucson AZ

Vamos a ver como se presenta el futuro y si tengo la oportunidad de ir a GHC10 Atlanta GA

El miércoles me toca presentar un poste técnico sobre Wonderland, un toolkit para la construcción de mundos virtuales en 3D. El poster se llama "3D Collaborative Environments for Social Good" (dejemos el título en Inglés por ahora) y será presentado en la Conferencia Grace Hopper 2009 que comienza el Miércoles 30 de Sept. en Tucson Arizona.

La razón por la cual decidí proponer este proyecto fue para demonstrar que este tipo de herramientas son ideales cuando uno necesita buscar manera diferentes de como ayudar a nuestras comunidades. Maneras que sean económicas del punto social pero también tecnicamente viables.

Mi primer encuentro cercano con Wonderland fue para el proyecto voluntario en Sun en el 2008 donde conectamos una escuela de Fremont California con una de Santiago de Chile. Ese proyecto se llamó "Hello Buddy/Hola Amigo" y más información se puede encontrar aquí y aquí.

Ahora he tenido la oportunidad de actualizar mis conocimientos sobre la nueva version 0.5 de Wonderland, que es increible, especialmente si uno lo compara con la versión anterior. Para los novatos en el tema, Wonderland no es espacio virtual como Second Life. Wonderland es una herramienta que permite generar espacios virtuales.

Es muy fácil de instalar y correr. Basta con tener Java 1.6 y Ant 1.7 para compilarlo y empezar a experimentar con las nuevas opciones. Entre todas, soporta el standard Collada y nuevos modelos se pueden cargar con sólo hacer "drag and drop". Los nuevos componentes son poderosos y se puede extender mediante la creación de nuevos modulos.

Y me queda mucho que aprender pues mi meta es ver la posibilidad de usar Wonderland en el diseño VLSI colaborativo usando Electric.

Nos vemos en GHC09 en la sesión de posters.

ghc09

de personas registradas para el almuerzo de Latinas en Computing en la próxima Conferencia Grace Hopper... la sequencia desde 2007 (la primera vez que se organizó) es: 26 (07), 101 (08), 119 (09)

y aprovecho de testear los tags y ScribeFire que no estuvo funcionando por algunos días...

Acaba de salir el anuncio oficial de la participación de Sun en la conferencia Grace Hopper que comienza la próxima semana en Tucson Arizona. Somos 24 los que vamos y entre las presentaciones a destacar esta la presentación técnica de Susan Landau, ingeniera distinguida en Sun Labs y la presentación del libro Citizen Engineer, A Handbook for Socially Responsible Engineering escrito por Greg Papadopoulus (Sun's CTO), Dave Douglas (Sun's Chief Sustainability Officer) y John Boutelle.

Tambíén aparecen las dos ganadoras de las becas de Sun para mujeres interesadas en el desarrollo de hardware. Este año las becas fueron ganadas por dos estudiantes de doctorado.

1. Taniya Siddiqua de la Universidad de Virginia (UVA)
2. Lamia M. Youseff de la Universidad de California, Santa Barbara (UCSB)

Es la primera vez que ellas atienden esta conferencia y ojalá que tenga la oportunidad de hablar con ellas.

Faltan 10 días para que comience la versión 2009 de la conferencia Grace Hopper que se realizará en Tucson Arizona. Este año participaré en las actividades de LiC pero también presentaré un poster sobre Wonderland (sobre ese poster bloggearé después).

Cada año tenemos más eventos donde nuestra comunidad está representada. Partimos en 2006 con 1 BoF(B), 2007 con 1 Panel(Pa), 1 BoF(B) y 1 almuerzo(L=lunch), en 2008 fue un almuerzo(L), 3 paneles(Pa), 1 BoF(B) y este año son mucho más.

Miércoles Septiembre 30
11:00a-12:00, PhD Forum “Towards the Semi-automated Building of Knowledge Bases for Biological Research:
1:15p-3:30p, CRA-W Workshop: Early Career Researchers
3:45p-5:00p, Panel: A Person of Influence In Real Life
5:00p-7:00p, Latinas in Computing Reception: Sponsored by ABI
7:00p-9:00p, Poster, “United to enhance women’s opportunities: Increasing numbers technologywise
7:00p-9:00p, Poster Técnico, "3D Collaborative Environments for Social Good"
7:00p-9:00p, Poster Técnico, “Using Random Code Generators to Cover Core Microprocessor Test Areas

Jueves Octubre 1
11:15a-12:15p, Panel: Women of Color: Identifying and Discussing the Unique Issues
4:30p-5:30p, BoF: Support Groups for Women in STEM: International Perspectives
4:30p-5:30p, BoF: Baby Loading, Please Wait: Pregnancy, Graduate School, & Computing

Viernes Octubre 2
10a-11a, Panel: "Technical Mentorship and Sponsorship: Why You Need It and How to Find It"
12:30p-1:30p, Latinas in Computing Lunch, Signature Grills Restaurant: (Prior RSVP required) sponsored by Lockheed Martin
4p-5:30p, Panel: "Empowering Immigrant Communities Through Technology"
4:15p-6:30p, K12 Town Hall Meeting
5:3-6:30p, BoF: "Speed Mentoring for Latinas in Computing”
5:3-6:30p, BoF: "Cross Cultural Communication Challenges Faced by Women in Computing"

Sábado Octubre 3
8a-2:30p, K12 Computing Teachers Workshop

Asi la progresion ha sido increible desde el 2006. Se ve mejor si lo resumo de alguna forma y abajo está la mejor manera que se ocurrió

2006: 1B
2007: 1Pa1B1L
2008: 3Pa1B1L
2009: 1F2W4Pa1R3P4B1L1T

Donde: F=Forum P=Poster B=BoF Pa=Panel L=lunch R=reception W=workshop T=Town Hall Meeting

A partir del 2008, hemos puesto posters cerca de nuestras sesiones para que la gente sepa donde más nos puede encontrar. Una de nuestras lideres Patty Lopez de Intel se encarga de hacer los brochures y posters. En unos diás más nuestro folleto debería esta en nuestro sitio web.

Nos vemos en Arizona

Prior to the Mac OS X 10.5 (Tiger), it was completely legal for one process to modify another for the purpose of controlling its execution (single stepping, resuming, stopping etc) and inspecting/modifying its memory. In Tiger, this policy was modified so that only a process owned by root or with a primary effective group of procmod or procview has this privilege. In Leopard (Mac OS X 10.5), this policy was changed such that a debugger process now depends on the security framework to authorize use of the task_for_pid system service which gives a process the capability to control another process. The details are in the man page for the taskgated daemon. The default launch configuration for this daemon (in the file /System/Library/LaunchDaemons/com.apple.taskgated.plist) runs the daemon in the aforementioned Tiger mode.

The reason I mention all this is that the Maxine VM has a companion tool (called the Inspector) that is used for debugging a running instance of the VM. That is, the Inspector process needs the ability to control the VM process. Up to (and including) Leopard, the Inspector was granted this capability by means of a (somewhat insecure) workaround. Given that the Inspector is itself a Java program, one could simply modify the java executable used to run it. For example:

% sudo chgrp procmod /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home/bin/java 
% sudo chmod g+s /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home/bin/java 

It should be obvious of course, that this opens up potential security vulnerabilities that can be exploited by other Java programs run by the same executable. This was considered tolerable for those developers working on Inspector on a Mac. However, with the release of Snow Leopard (Mac OS X 10.6), this workaround was rendered ineffective. If one tries to run the inspector on Snow Leopard with the altered java executable, the result on the console is:

2009-09-16 11:14:23.307 java[1654:903] The application with bundle ID (null) is running setugid(), which is not allowed.

Not being a very knowledgeable Mac developer (nor wanting to invest the time to become one just yet!), I'm not exactly sure what this means. However, the outcome is that modifying the ownership and permission bits of the java executable is no longer possible on Snow Leopard. So, what is an Inspector user on Snow Leopard to do?! Unfortunately, the current solution is to force the Inspector to be launched as root via sudo.

However, the ideal solution is to use the Authorization Services on a Mac to dynamically obtain the privileges necessary for the Inspector to use task_for_pid. Unfortunately, use of this framework turns out not to be as straight forward as I thought it would (should!) be. Based on the sample code provided by Apple, I would have thought the following code is sufficient to acquire the privilege for calling task_for_pid:

#include "auth.h"
#include <Security/Authorization.h>
int acquireTaskportRight() {
    AuthorizationRef authorization;
    OSStatus status = AuthorizationCreate (NULL, kAuthorizationEmptyEnvironment, kAuthorizationFlagDefaults, &authorization);
    if (status != 0) {
        fprintf(stderr, "Error creating authorization reference\n");
        return -1;
    }
    AuthorizationItem right = { "system.privilege.taskport", 0, 0 , 0 };
    AuthorizationItem items[] = { right };
    AuthorizationRights rights = { sizeof(items) / sizeof(items[0]), items };
    AuthorizationFlags flags = kAuthorizationFlagInteractionAllowed | kAuthorizationFlagExtendRights | kAuthorizationFlagPreAuthorize;

    status = AuthorizationCopyRights (authorization, &rights, kAuthorizationEmptyEnvironment, flags, NULL);
    if (status != 0) {
        fprintf(stderr, "Error authorizing current process with right to call task_for_pid\n");
        return -1;
    }
    return 0;
}

When executed, this code results in the expected authentication dialog:

When I enter an administrator name and password, the dialog closes and the authorization appears to succeed. This suspicion is supported by the entry written to /var/log/secure.log:

Sep 16 11:11:28 isquawk com.apple.SecurityServer[21]: Succeeded authorizing right 'system.privilege.taskport' by client \
    '/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home/bin/java' for authorization created by \
    '/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home/bin/java'

However, a following call to task_for_pid returns an error code of 5 (i.e. a generic kernel failure). At this point, I'm at a loss as to what extra steps are required to convince the OS that I indeed have the permission to debug one of my own programs!

We've been doing a tremendous amount of testing and bug fixing this week. I would like to extend a special thanks to those of you in the community who have helped with the testing! We had hoped to get the Preview release out earlier in the week, but there were a few show-stopper bugs that appeared late in the game. The release is certainly not bug-free yet, but Jon is doing the build this weekend and the release should be out on Monday, barring any major disasters over the weekend.

In what seems to have become a tradition, I'd like to share some of our testing experience and point out some of the new features in this release. In yesterday's final test of the Preview build, we had up to 12 people in world for part of the time, and 6 who stayed to run through the entire test. The first thing we all tried was to configure our avatars. You now have a choice between two different low-poly avatars, including the two cartoon avatars shown below and two toy avatars. These are designed to improve performance while testing or when using a computer without a good graphics card. You can experiment with these by selecting "Configure Avatar" from the Edit menu.

To create an avatar that will walk, run, or perform gestures, click on the "New..." button in the Configure Avatar dialog. Jon and I found fairly normal looking clothes, but we have no idea what Mike was thinking!

Once we were happy with our avatars, we ran a shared X11 application. You now configure these using the Server Administration console. Once configured, users can add instances of the application into the world either by selecting "Component..." from the Insert menu or by opening up the Shortcuts panel (notice a "firefox" icon in the right-most position).

The next part of the test involved importing a variety of different sized Google Earth (kmz) formatted models into the world using both drag-and-drop and the "Model..." command from the Insert menu. After struggling with some bugs in this area at the beginning of the week, model importing is now working quite well. Although it's not ideal, models that are over a certain size will appear on top of your avatar when you drag them into the world. This was preferable to the alternate behavior of them appearing so far away that you couldn't see them. Smaller models will appear directly in front of you. If the model is very small, you may need to step aside (use the Q or E keys) to see it. Here are some nice large models, as well as a small seat.

One extremely handy new feature in this release is the ability to edit an object's exact coordinates without having to open the property sheet. To do this, right click on a model and select "Edit..." from the context menu. This will bring up the Edit Component pane shown in the illustration above. If you want to position the object more precisely than you can with the graphical tools, click on the "Details..." button to open the position Details pane. This is a huge help if you are trying to align objects or move objects to another part of the world. One nice feature is that you can click on objects that you are not currently editing to check their coordinate numbers. Be a little careful - you need to click back on the model you want to move before editing the numbers, otherwise you'll move the wrong one.

The Sticky Note module, contributed by a community member, is a great example of an interactive 2D Java application. In the standard Wonderland bundle, you will see two new items in the Components list: Sticky Note and Task Sticky Note, both illustrated below. After inserting one of these, right click on the new note to "Take Control." Now you can type in some text. Use the new "Release App Control" button that appears in the upper right corner of your Wonderland window when you are finished. You can use the "Edit..." context menu command to move the note, or use the "Change Color" context menu command to recolor your note.

Capabilities

Lastly, I would like to highlight Capabilities. These are generally useful features that can be applied to any object. To apply a capability to an object, right click on the object and select "Properties..." from the context menu. Then click on the "+" sign underneath the Capabilities pane. This will bring up the list of all capabilities that are installed on your system which can be applied to the selected object.



The Audio Capabilities are documented in the Adding Sound section of the "Creating and Importing Artwork for Non-Artists" tutorial. You can turn any enclosed space into a sound-proof area by applying the Cone of Silence capability, and you can make any object into a teleporter by adding the Portal capability. The Container capability allows you to group objects together. During the test, we dropped in an amphitheater and added the Container capability. Any objects we dropped in while standing inside the amphitheater were automatically grouped with the amphitheater, allowing us to reposition the amphitheater and have all the containing models move with it.



You can also manually add objects to a container by using the World Hierarchy editor that appears when you select "Properties..." from an object's context menu. You may need to click on the arrow in front of "World Root" to see the details of the hierarchy.



Just drag and drop objects displayed in this list to nest them. Note that it if you plan to do this, you should use the Basic Properties pane to name each object, known as a "cell," otherwise your list of objects will be a jumble of numbers and you will have no way to tell what is what.

Another important use of the Container capability is to add the same security properties - another capability - to a set of objects. This way you can create a private meeting room, for example, and have all objects created within that space be viewable only by members of a particular group.

Bloopers

Testing wouldn't be any fun without the bloopers. When we were testing adding objects to the world, Deron added a lunar lander model and placed it at the origin using the Details pane to set X, Y, and Z to zero. While testing something else, his client hung, so he had to quit and come back in. When he got back, his avatar came into the world inside the model. Deron said, "I was stuck in the lunar module! I moved it above my head and then I was okay." Good thing there weren't too many people around to hear that conversation!

At one point, I had a tragic teleportation accident. I walked through a portal, but I didn't quite come out whole on the other end. On top of that, I was tumbling around. Later, when I logged out and back in again, I came in with two avatars at the same time.



Real double trouble!

Es el título de un reportaje que destaca los esfuerzos de los proyectos EELA, la infrastructura E compartidad entre Europa y Latinoamerica. La sigla también funciona en Español asumiendo que la primera "E" es por Electrónica . El artículo en Español está aquí.