RSSMix.com Mix ID 11245

Smalltalk Party Brussels 11 March 2006

Only six days left to the Smalltalk Party in Brussels! I'll be there, and more interesting people, too. You should come, too!

Be a magician

A very nice post about the Magic of Smalltalk.

Sophie, Tweak on the OLPC laptop

I just installed Sophie on my green machine. Sophie is a project of the Institute for the Future of the Book, is implemented in Squeak (just like my Etoys activity on the laptop) using Tweak as its UI framework (which is the original topic of my blog). Tweak is also the base for the next-gen Etoys.

Installation went pretty smooth. I downloaded the cross-platform zip file using the Web activity from Sugar
and unpacked it using the command line. The first start of Sophie failed, but after replacing the failing plugin with one from the pre-installed Squeak it started and worked. Yay!

This is an excellent example why it's a good idea to have a regular X11 installation on the kid's laptop: a lot of software will just work, even if it is not correctly integrated into the Sugar UI.

Michael Rger of impara (a Squeak shop leading Sophie development here in Magdeburg, Germany) came over and made a little book, downloading two logos directly from the web (Sophie can do that!), adding a bit of text and color ... Tweak performance is not exactly blazing on the XO machine, I think we made the right decision to not use the Tweak-based Etoys but stick to the proven Morphic-based one. Of course one could optimize it a lot, but who has time for that? Anyway, it was useable - click the image to get a larger view:

Croquet & Tweak at NASA

Ted Shab posted a job offer to the ECOOP list. Part of it was this:

We are currently building a [...] testbed for user-experience exploration in Squeak (Smalltalk) (really). The resulting framework will be used by the various NASA centers [...] to build distributed, multi-mission systems for planning and executing a variety of NASA missions, including robotic (e.g. Mars rovers & deep- space probes) and manned (e.g. the new Moon/Mars exploration effort, including the Crew Exploration Vehicle currently being designed).

Andreas Raab commented:

FWIW, this project uses Croquet and Tweak. If you ever wanted to work with a bunch of really sharp guys this is definitely a place to consider.

Sounds cool :)

Performance Profiling

Andreas Raab wrote a nice primer on profiling in Squeak. MessageTally might be the single most undervalued Squeak performance tool - a mandatory read for every serious developer.

OLPC talk at design school

I gave a talk about the $100-laptop at the Magdeburg school of Industrial Design. We did some very inspiring projects using Squeak, Etoys, and Croquet together before. The designers always come up with interesting ideas, even though not everything is directly implementable by us developers.

Carola Zwick, dean of the school, wrote a book Designing for Small Screens that certainly gives valuable insight for OLPC developers, and she provided (though indirectly) some very important infrastructure for the OLPC office: her group designed the chairs they are sitting on. I got the actual invitation by Christine Strothotte, who got her PhD doing computer graphics in Smalltalk just a few years before I got mine from the same school. She's teaching interaction design nowadays. I'm looking forward to doing an OLPC-related project with these great folks.

A student took some photographs during the talk. Also, from his blog post it seems I convinced him of the merits of the OLPC project (it was a lively discussion). Thanks for posting, Cheng!

Squeak Elections

The first-ever elections are held in the Squeak community. Candidates have to be nominated by February 17, same deadline for getting certified at SqP if you want to vote.

Squeak for every child

Lately I work on Squeak integration in the One Laptop Per Child (OLPC) project, perhaps better known as the "$100 laptop". The whole etoys group came over to OLPC's office in Cambridge. Squeak looks surprisingly well on the display prototype, and also etoys are reasonably fast. Ian Piumarta took some nice pictures, which might very well be the first photos of the actual display in the wild.

Tweak Interview

Andreas gave an interesting interview about Tweak.

Simplified TeaTime

The next Croquet release, code-named "Hedgehog", will be centered around a real replicated object model, rather than the ad-hoc meta sends in Jasmine. See Andreas' and David's OOPSLA presentation (PDF) for an overview.

Sophie movies

Steve is posting screen clips of progress in Sophie (a.k.a. the Future of the Book), which is developed in Squeak with a Tweak UI. It's looking nicer and nicer every week.

OLPC, graphics, and more

I just returned from a nice productive visit to California, where I brought back my very own $100-laptop. Got the camera working in Etoys (see picture on the right, showing Yoshiki and me) with just a few patches to Diego's code.

We also went to visit Keith Packard and Carl Worth of Cairo fame in Portland. Had a nice chat about Twin and then hacked away on a Pepsi version of image compositing operators. A very interesting meeting it was, with the old folks (Alan Kay, Jim Gettys) and the younger ones all sharing their thoughts.

And back to OLPC, read this nice essay titled Free Laptops: Creating, Producing and Sharing a Revolution.

Croquet SDK 1.0 Beta out

Get it at opencroquet.org!

OLPC video from NECC

Just found a nice video on youtube about the $100 laptop at NECC 06, including a cameo of our very own Kim Rose (at 3:21) while the speaker is mentioning "creativity" - very apt, I'd say.

Etoys kid-tested on XO

I brought my green machine home this weekend, and my twins had fun with it. Enormous fun in fact for the two 7-year olds, pounding on TamTam furiously. I couldn't bear it anymore after half an hour or so.

Instead, I showed Jakob how to make a little figure bounce around on the screen in Etoys, while his sister went to practice her cello. He painted a simple head, and then we used the "forward by" and "bounce" tiles in a tiny two-line script making it move around. I made the mistake of pointing out that the "bounce" tile can produce some noise when bouncing. Endless fun trying the different noises ensued. Oh well.

Disturbed in her practice by these noises, Sophie came over and wanted to paint, too. So we saved Jakob's project and started a new one for her. I sat back to work on my email and let her brother teach. She spend like half an hour just painting the figure. The paint tool showed that it is not tuned to the XO's display resolution yet, it's far too small. But not giving up that easily, Sophie was erasing and repainting it over and over until she was satisfied with her "cow girl". Then Jakob proudly told her how to let it move and bounce, he had rembered almost everything needed. Together they quickly made it work, and just started exploring the noise-making possibilities again when we were saved by the call to dinner ...

Why Second Life Won't Get a Third

Max Borders opines on what he views as the key differences between Second Life and Croquet. Another piece comparing the two technologies can be found here.

Touchy-Feely Croquet

UNC's Jeff VanDrimmelen has recently begun exploring ways to integrate haptic technology with Croquet virtual worlds. Haptic technology allows simulations to convey information to users in the form of mechanical stimulation. Haptic devices typically transmit information in the form of vibrations or motions, thereby creating a sense of touching or feeling virtual objects. The main types of haptic devices are 1) tactile feedback devices (that generate resistance to user input movement) and force feedback devices (that generate movement back to the input device).

The Novint Falcon device is a new haptic device developed for use as a gaming peripheral and input device. The user interacts with a small knob with three degrees of freedom in movement at the front of what is otherwise a stationary desktop device. The knob is attached to the main body via three multi-hinged and motorized arms. The step motors within the arms feel what the user is doing as well as apply forces back to the knob.

Jeff recently posted this video about his earliest effort to integrate the Novint Falcon haptic device with Croquet technology.

The Server Dilemma

The following quote from the article Second Earth (MIT Technology Review, July-August 2007) provides some interesting numbers around the server dilemma associated with server hosted virtual worlds such as Second Life:

This reimagining of the real world can go only so far, given current limitations on the growth of Linden Lab's server farm, the amount of bandwidth available to stream data to users, and the power of the graphics card in the average PC.

According to [Cory] Ondrejka [Linden Lab's now former CTO], Linden Lab must purchase and install more than 120 servers every week to keep up with all the new members pouring into Second Life, who increase the computational load by creating new objects and demanding their own slices of land. Each server at Linden Lab supports one to four "regions," 65,536-square-meter chunks of the Second Life environment--establishing the base topography, storing and rendering all inanimate objects, animating avatars, running scripts, and the like. This architecture is what makes it next to impossible to imagine re-creating a full-scale earth within Second Life, even at a low level of detail. At one region per server, simulating just the 29.2 percent of the planet's surface that's dry land would require 2.3 billion servers and 150 dedicated nuclear power plants to keep them running. It's the kind of system that "doesn't scale well," to use the jargon of information technology.

But then, Linden Lab's engineers never designed Second Life's back end to scale that way. Says Ondrejka, "We're not interested in 100 percent veracity or a true representation of static reality."

Saving and Loading Spaces

A new build of Cobalt has just been made available download. Added functionality includes the ability to save and load spaces from web or local directories. This means that you can now make your custom Cobalt spaces available to others as a kind of template virtual world over the web!

Duke Receives Mellon Award

Today, the Andrew W. Mellon Foundation awarded Duke University a $100,000 prize for leadership and development work to advance Croquet in the open source. The prize was one of ten presented as part of the second annual Mellon Awards for Technology Collaboration (MATC) which are given each year to notforprofit organizations for leadership in the collaborative development of open source software tools with application to scholarship in the arts and humanities.

The award was presented at the Fall Task Force meeting of the Coalition for Networked Information in Washington D.C. by Sir Timothy BernersLee, Director of the World Wide Web Consortium and the inventor of the World Wide Web. Dukes MATC award was one of three that received the top prize of $100,000. The other award winners received prizes of $50,000 each. Award recipients were selected by the MATC Award Committee, which included BernersLee, Mitchell Baker (CEO, Mozilla Corporation), John Seely Brown (former Chief Scientist, Xerox Corp.), Vinton G. Cerf (Vice President and Chief Internet Evangelist, Google, Inc.), John Gage (Chief Researcher and Director of the Science Office, Sun Microsystems, Inc.), and Tim OReilly (Founder and CEO, OReilly Media).

Squeak by Example

Croquet is written in Squeak, a modern open-source development environment for the classic Smalltalk-80 programming language (the first purely object-oriented language and environment). Squeak was used because Croquet required a number of capabilities that could only be provided by a true late bound, message sending language. Croquet's relationship to Squeak gives Croquet the property of a purely object-oriented system. This has allowed for some significant flexibility in the design and the nature of the protocols and architectures that have been developed for Croquet.

An essential property of Squeak is its ability to keep the system running while testing and making changes. Squeak allows even major changes to be performed incrementally and within a mere fraction of a second. Another key feature is Squeak's generalized storage allocator and garbage collector that is efficient in real-time so that animations and dynamic media of many kinds can be played while the garbage collector is collecting. It also allows reshaping of objects to be done safely. This is important to the creation and delivery of media rich collaborative virtual environments.

Early on in the project, a Java-based Croquet was considered. However, that approach was abandoned because Java lacks needed meta facilities. In many ways Squeak/Smalltalk is still far ahead of its successors in promoting a vision of an environment where everything is an object, and anything can change at run-time. This is an important property for virtual environments that are deeply flexible and modifiable as an immediate result of the actions people take within those environments. Still, the lack of significant corporate backing and marketing muscle behind Squeak/Smalltalk has meant that less capable technologies are the ones with which most of today's developers are most familiar.

To help more people get familiar with Squeak's very powerful programming environment, the new book Squeak by Example is now being made available under the Creative Commons Attribution-ShareAlike 3.0 license. It's intended for both students and developers and guides readers through the Squeak language and development environment by means of a series of examples and exercises. This is very useful to those who wish to become more familiar with the Croquet programming environment. You can either download the PDF for free, or you can buy a softcover copy from lulu.com.

A Croquet Winter Wonderland

It has emerged as a type of practice here in the United States for people to begin putting up holiday decorations on the weekend after our annual Thanksgiving celebration. In keeping with this, I offer this link to a new video from the folks at EduSim. In this one, they use a projected Croquet space in combination with a very compact eBeam input device that converts any surface (in this case a regular wall) into an interactive surface. The result is an on demand and relatively low cost interactive white board solution ($800-900 US) that, in combination with a data projector ($600-2,500 US) and Croquet software (free), may represent the beginnings of an economical alternative to traditional in-classroom visual communication boards (the typical front-of-the-classroom whiteboard/bulletin board installation is comparable in price). Could this be the earliest manifestation of a new form of broadly available classroom media for K-12?

Cobalt Released

Cobalt is an emerging open source and multi-platform metaverse browser and toolkit application being built using the open source Croquet SDK. A pre-alpha build of the Cobalt application is being made freely available to the emerging virtual worlds community by Duke University and its partners under the Croquet license. We hope that by doing so, we will foster a viable community-based software development effort leading to open virtual world technologies supporting the needs of education and research.

The current build of Cobalt is located here.

The Monticello source code repository for Cobalt is located here.

The Cobalt-specific Mantis bug tracker is located here.

Software testing and bug reporting is a very important contribution to the effort. Doing so will help the Cobalt development community to identify areas in need of programming and re-engineering. Well-written bug reports can be an especially useful contribution by non-developers who are interested in advancing this effort during these early stages of Cobalt development. We hope that many of the community's software developers will consider taking on bug fixes.

Mark McCahill will be coordinating updates and code contributions to Cobalt to ensure compatibility with the base classes within the present Croquet SDK. In this way we can ensure that Cobalt development does not create a fork from the Croquet SDK. The goal here is to build a Croquet-based application that end-users can really use and then to contribute the application back to the Croquet Consortium for distribution as part of a future Croquet release. We hope that by making the pre-alpha available we can tap into the creative potential of the broader community as a way of advancing something that all of us can freely use to create deeply collaborative, greatly featured, and widely interlinked virtual environments on a very large scale. Lets do it!

Wii-mote Possibilities

Here is a clever video from Johnny Lee at Carnegie Mellon University showing how you can use a Nintendo Wii-mote and home-made infrared LED light pens to create a low cost multi-touch interactive whiteboard system.

Croquet Skeletal Animation Part 2

Another example video of skeletal animation in Croquet.

A Croquet Spoof

Recently posted by David Faught. Happy New Year!

Building a Lesson in EduSim

Here is another video tutorial developed by Rich White at the Greenbush EduSim project showing how to bring resources into an EduSim/Croquet world and how apply textures to those resources.

Croquet Selected!

This past weekend, it was announced at The Boston Media-Grid Summit that the Immersive Education Initiative (see article on the initiative's goals) has selected Croquet as one of three official "next generation" immersive education platforms. The Immersive Education Initiative is an international collaboration of universities, colleges, research institutes, consortia companies, and foundations that are working together to define and develop open standards, best practices, platforms, and communities of support for virtual reality and game-based learning and training systems. The other two immersive education platforms selected were Sun's open source Project Wonderland client and the now open source Second Life client.

What this all means is that the open source Croquet platform's value will become better known and that the Immersive Education Initiative will now direct both funding and programming resources towards the development and deployment of open source Croquet technologies and open source Croquet-based educational applications. Selection criteria for this important honor included the following: 1) support for the Windows and Macintosh operating systems; 2) availability as open source code; 3) vendor-neutral client and server architectures (no vendor lock-in); 4) stable and reliable runtime implementations; 5) integrated text chat and voice chat; 6) high resolution graphics; 7) multi-user support for collaboration; 8) highly customizable avatars that support high resolution graphics and body animation (gestures); and 9) support for user-created content.

The event in Boston was an invitation-only affair hosted and sponsored by the Grid Institute, the Woods College of Advancing Studies at Boston College, and the City of Boston with participation from the Federation of American Scientists and the Ewing Marion Kauffman Foundation.

Avatars in First Life

This video illustrates what real life might be like if we were limited to the avatar capabilities/interactions presently available in virtual worlds such as Second Life. It very much underscores the limitations in the ways we are able to represent ourselves within today's 3D gaming and chat environments. If we are going to leverage virtual environments to support interactions between people, then we need far better ways of representing ourselves within them. Our representations should ideally be able to project as fully as possible the broadest range of human cues and capabilities. Clearly, 3D virtual worlds have a long way to go in this regard. As a first step, we need to get past the dress-up doll house metaphor that appears to have emerged for interaction within these environments.

The static avatars presently made available as placeholders in the Croquet SDK are far less capable than those of Second Life. Still, the Croquet SDK offers developers an opportunity to change whatever they need about the way people are represented with virtual environments. Opportunities for avatar experimentation are huge. Just imagine avatars that contain action triggers, link buttons, or even multiple on-board virtual environments. The possibilities through Croquet are as limitless as the imaginations brought to bear on the problem (and of course the resources expended in implementing them). The flexibility and efficiency of the Croquet programming environment gives researchers and other creatives far more capability in exploring how best to represent presence in virtual environments than is available with today's commercial 3D world technologies.

I should point out that all of the .mdl avatars that the Croquet SDK now uses actually came from an early version of the Alice project and from Squeak's Wonderland. However, the Croquet team at the University of Minnesota is working on some nicer avatars that will likely be made available in the next version of the Croquet SDK. A preview of the Minnesota avatars can be seen briefly on the Croquet video in a previous post. Also, Matt Schmidt and his team in Missouri are also beginning to experiment with avatar improvements and it will be interesting to see what they come up with.

NSF SGER

I've just been awarded an NSF Small Grant for Exploratory Research (SGER) to advance exploratory work towards a more complete open source Croquet-based browser application and toolset that can support the large scale needs of the scientific community. With this support, we will be helping to advance the Cobalt effort by 1) making general improvements to the user interface which includes the more complete buildout of Cobalt's menus as well as improvements to basic navigational control, 2) fully implementing and testing of the ability for end-users to tag and electronically store their Cobalt-created worlds to online directories, 3) designing and implementing methods for finding and contacting other users of Croquet spaces by leveraging XMPP/Jabber as a presence registration and rendezvous mechanism, and 4) designing and implementing of methods that enable Cobalt users to browse a directory of all registered and active Cobalt spaces and to make it possible for users to contact current participants of those spaces by leveraging XMPP/Jabber and institutional IAA infrastructures as a means of defining user permissions by group affiliations. At the end of this, we hope to have a full Beta of the Cobalt application available for download to all.

Another Digital Rainout

Today, for the second time in as many weeks, Second Life became unavailable for the same reasons that 3rd party large-scale server-based architectures should not be relied on to support mission-critical virtual worlds in any serious way. The outage happened, once again, just at the time that Aaron Walsh of the Media Grid Immersive Education Initiative was trying to host a Second Life in-world meeting. Here is what Linden Lab had to say: Logins have temporarily been restricted to staff-only as Operations addresses a slowdown in the asset system. Weve also broadcast a request in world for residents who are currently logged in to refrain from manipulating or transferring assets. Well have more info ASAP. Obviously, this company is in real trouble given the frequency of these problems in a system that so many have come to rely on....

MS-OLPC?

Nicholas Negroponte just posted the following announcement:

"One Laptop per Child is announcing an agreement with Microsoft
to make a dual boot, Linux/Windows, version of the XO laptop. In addition, our intention is to engage one or more third parties to port Sugar to run on Windows in order to reach a wider installed base of laptops. In the meanwhile, OLPC remains fully committed to our goal: a completely free and open learning platform for the world's children. The mission statement of OLPC has not changed in three years.

Sugar is the first user interface specifically designed for children and teachers to learn and collaborate, and remains central to our strategy. Broadening Sugar's reach to as many children as possible remains key to OLPC's mission.

To enable the Sugar environment to reach as many children as possible, particularly in the poorest areas of the world, OLPC must be able to bid on educational technology contracts, some of which require that Microsoft Windows be able to run on our hardware. The increased volumes will lower the XO-1's price, already lowest in the industry with capabilities no other laptop shares.

OLPC is substantially increasing its engineering resources and all software development continues entirely on GNU/Linux. We will continue to work to make Sugar on Linux the best possible platform for education and to invest in our expanding Linux deployments in Peru, Uruguay, Mexico and elsewhere.

No OLPC resources are going to porting Sugar to Microsoft Windows, although as a free software project, we encourage others to do so. The Sugar user interface is already available for Fedora, Debian and Ubuntu Linux distributions, greatly broadening Sugar's reach to the millions of existing Linux systems. We continue to solicit help from the free software community in these efforts. Additionally, the Fedora, Debian and Ubuntu software environments run on the XO-1, adding support for tens of thousands of free software applications.

Open Firmware V2, the free and open source BIOS, is now capable of running Linux, Microsoft Windows XP and other operating systems, and was developed by Firmworks with support from OLPC. This will enable dual boot of OLPC XO laptops with Microsoft Windows XP in addition to the existing Fedora-based system and will become the standard BIOS/bootloader for all XO systems when completed. With this "free BIOS," the XO-1 continues to be the most open laptop hardware currently
available."

For more information, see http://wiki.laptop.org/go/AnnounceFAQ.

Deep play

Over thirty years ago, anthropologist Clifford Geertz posted a proto-blog on "deep play." Today, "Deep Play: Notes on a Balinese Cockfight" could stand as the manifesto for www.seriousgames.org. It's certainly an inspiration for this blog.

So, what's deep play? For Geertz it was what happened when groups of people got really engrossed in the same dynamic activity. Relating to one another in terms of that activity flow, they got the chance to see what their culture was all about and comment on the underlying rules that controlled their lives.

Of course, Geertz came up with this notion while watching a cockfight. Like today's batch of videogame researchers, Geertz recognized in an "edge" activity the makings of an ideal learning situation.

A little background. Cockfighting was illegal in Bali, but it happened anyway. It was an ad hoc sort of event -- popping up on side streets and plazas, then shutting down and picking up again down the road. A fight would start up and a flashmob of gamblers would swarm around it. Geertz called it a "FOCUSED GATHERING."

So the sight of "one chicken mindlessly hacking another one to bits" was a kind of "strange attractor" that drew all these people to it. But Geertz thought the cockfight was more than a bloody entertainment.

The Balinese cockfight was "a SIMULATION of the entire social matrix . . . in which its devotees lived." The Bali caste system had rigid rules -- it was one very serious game. As a complex system, social caste affected every aspect of their everyday social relations and was too complicated to see in its entirety.

Geertz thought of the brutal cockfight as a way for the Balinese to LEARN what their culture looked like "when it was SPELLED OUT IN A COLLECTIVE TEXT." Here was the entire Balinese pecking order "raised to a level ... where it could be more exactly perceived."

Simulation as learning tool. For the Balinese, this cockfight-as-simulation was more than a chance to stand back and see the rules that controlled their collective lives. It was a chance for participants to REFLECT and COMMENT on the underlying rules of the game.

So what does this mean for education today?

Cockfights, like videogames, are an object lesson for academic -- as J.C. Herz points out in her terrific essay "Gaming the System." But not because universities need to get into the business of staging cockfights or making games.

What these forms of DEEP PLAY illustrate is what Herz calls "the learning potential of a network, and the social ecology that unlocks that potential."

But universities won't be able to harness that potential until they have easy, cost-effective tools for building online educational worlds that scale.

We need to use our network technologies to support the emergence of AD HOC collaboration communities where groups of learners can see and interact with one another, becoming engrossed in a common flow of activities, and having the tools ready-at-hand to reflect on what they're doing -- collaborative CRITICAL THINKING -- e.g. the basis of an effective liberal arts education.

My role in the Croquet Higher Education Collaborative is to take on an immediate challenge - bringing together as many researchers as possible to design breakthrough applications that show the value of Croquet in the educational domain.

This blog will talk about what it takes to build a multi-institutional open-source collaborative from the ground up.

New Posting . . . At Last

First, I apologize for not blogging for such a long while. Like everyone else involved in Croquet, I've been juggling full-time responsibilities at work with dedication to the Croquet cause. Okay, no excuses.

The Third International Conference on Creating, Connecting and Collaborating through Computing (C5 2005) conference in Kyoto, Japan was a great opportunity to make progress on the Wisconsin/Minnesota plan to build an international alliance of educational institutions around the Croquet Project. Much more on this in later postings.

While Mark and Julian demonstrated new interface elements geared towards making the Croquet experience as intuitive as possible for educators and their students, I presented on "Croquet and Higher Education." I spoke to a growing realization at the highest levels of the American academic technology community that commercial course management systems will never touch the heart of education -- teaching and scholarship -- in a transformative way. Our colleagues in Japan agreed.

After all, the CMS was never meant to support innovative teaching practice. It was intended as an administrative container or set of containers for course management (connoting efficiency and restraint). Regardless of the number of improvements grafted onto the CMS platform, the conceptual framework will always give primacy to administrative matters over pedagogical experimentation.

In point of fact, we have been far too easy to please until now, but as greater and greater numbers of faculty members commit themselves to using CMSs, vendors are likely to be confronted with a considerably less pliable customer base. To put it bluntly, its about time we (e.g. universities, colleges, academic technologists and educators) learned to feed ourselves. After all, give a man [sic] a fish; you have fed him for today. Teach a man to fish, and you have fed him for a lifetime.

One powerful organization that agrees with this argument is NLII, the National Learning Infrastructure Initiative of the Educause organization. In fact, NLII will soon be renamed to reflect a new strategic focus on the neo-millennial learner and how to address that learner's needs through emerging technologies. Croquet is going to be a large part of that focus, I'm sure.

So here's an ANNOUNCEMENT -- check out the upcoming March/April issue of Educause Review for my column "Standing on the Plateau," which introduces Croquet to univerity CIOs, Chancellors, Provosts, and the like. You'll also find a link to a longer version published online by NLII. The extended article will also be available for download on the Croquet Project site's "Whitepaper" page.

When you have a chance to read the article, we'd really appreciate your feedback. Post your comments to my blog. Thanks!

New Version of Gallery Released

Well it's far from finished
but our rewrite of the Digitial Gallery software
has reached a point where we'd like to share it!

Documentation and download are available here:
http://www.citris-uc.org/hosted/projects/ith/gallery

If you used the first version at all,
we think you'll be much happier with this one.
We certainly are.

Additions & Improvements:

* Gallery design is now entirely in the 3D world,
no more split 2D/3D business.

* Collaboration Actually Works!

* 3D Annotations.

* VRML model loading.

* Overall streamlining, improved ease-of-use, etc.

Ideas, suggestions, criticism, and bug reports are always welcome-
please use the links at the bottom of the project's web page.

We've also started an online forum for users of the software,
please feel free to ask questions or report bugs there:
http://makephpbb.com/phpbb/?mforum=citrisgallery

Best Regards,

Ruzena, Tao & Orion

Collision Refinements & Smalltalk Gripe

First, the smalltalk gripe: The syntax for boolean logic is just ugly.
Compare smalltalk and 'C' here:

(x <= y and: [x <= z]) ifTrue:
  [foo := 10.].
vs.
if (x <= y && x <= z)
  foo = 10;

or, worse horrors, here:

(a < b and: [a < c and: [a < d]] ifTrue:
  [aIsSmall := true.].
vs.
if (a < b && a < c && a < d)
  aIsSmall = true;

in both cases, it's pretty easy to tell at a glance what's going on in the 'C' code, whereas the smalltalk code requires you to actually count the brackets etc.
true, i've only barely cut my teeth on smalltalk and have years of 'C' under the belt, but i think there's no denying that smalltalk obsfucates boolean algebra.

On to Collisions!

So in the previous post i referred to a shortcut i took in assuming that the avatar needed to be pushed out in the local Z direction, which was more or less valid for cubes which are relatively thin in Z. But i expanded it to do the test for which face of the cube the avatar is closest to, and push it out along that face instead, which works nicely for all faces.

I also noticed that the rabbit avatar is *not* spherical in extent, and therefor the amount by which the wall extents are expanded should really take into account the orientation of the avatar, which is achieved via this line:
gex _ geometry extent + (geometry inverseGlobalOrientation localPointToGlobal: avatar extent) abs.

that's all for now.

too much meta can be a bad thing

This afternoon i learned that too much meta can be a bad thing.

In our software, you layout walls, and then add 'items' (think paintings) to the walls. This has all been done with meta-fied collaborativity in mind.

I discovered that when connected, the AddItem method would work as intended on the machine which initiated the AddItem, but on the other machine (or, i presume, machines) a sort of bastard doppelganger of the item would be added in addition to the reglar one.
That is, a nice textured picture would appear on the wall as intended, but an untextured duplicate would appear in the same place.

The correct item and the doppelganger would have the same teaObjectName, and thus of course have strange collaborative behaviour.

After some fooling around i learned that it was too much meta !

Here's the basic code structure which caused the problem:

----------------------------------------------------------
TWall >> addItemWithFileName: fn
"This method gets called from a user event, so it's not currently meta'd"

item := self meta createNewItem.
item meta setUpStuff: fn.
----------------------------------------------------------
TWall >> createNewItem
"This is the wrong way to do it - there should be no metas!"
item := TItem meta new.
self meta addChild: item.
^ item.
----------------------------------------------------------

.. the solution was simply to remove the metas from createNewItem.

- which is easy enough but somewhat intimidating,
as i was under the impression that using meta while already 'inside' of meta was a safe thing to do. Is this not the case ?

getting it

A month or so ago when i had been working with meta for a little bit
i went and tried to meta-fy TEditBox so that it would be collaborative
the way TDragger is. I rapidly fell into a cats cradle of confusion,
hanging images, etc etc.

Last friday i decided to take another crack,
and it took about half an hour and works great!

Here's the changeset for any who're interested:

http://bugs.impara.de/view.php?id=883

Also improved TTorus, giving it a snugly-fitting frameBox and a fun texture Twist parameter.

Another New Version of the Gallery Released

.. I think i need to change the title of this blog to something more like "Release Notices".

In any event,
Tao and i have been working steadily on the Gallery software
and finally decided to let loose with a beta release of what we've got.

You can download it here.

Citris Gallery 2.8.0

Tweak UI

Load & Save to XML

Manipulate lights

Primitives

Change wall & floor textures

Portals to other Spaces!

Improved TEdit Box

Improved VRML Loading

Changeable Avatars

Spinning Objects

Patch for locked-down firewalls

More included Content

.. and so much more!

Collision Detection

Well i was not looking forward to reimplementing collision detection between the avatar and the gallery walls, especially as this time around the walls aren't parameterized as lines on the floor.

Previously i basically just did 2D intersection, intersecting the line on the floor with the line representing the avatar's movement for this frame.

This time i decided to try going at it the 'right' way and it worked great.

The 'right' way of course is to transform the avatar into the wall's coordinate system and do the collision stuff there. It took a bit of flailing around, and the calls i ended up using seem rather like misnomers to me, but in the end it worked great.

Here's the algo i ended up with:

1. convert the avatar's position to wall-space.

a1 _ geometry inverseGlobalTransform localPointToGlobal: avatar globalPosition.

2. extend the wall's extent by the avatar's extent.
(This is actually somewhat inaccurate unless you also transform the avatar's extent
out of the avatar's orientation and into the wall's orientation, but what the heck.)

3. test if the avatar's position (in wall space) is outside the expanded wall extents.
if so, no collision.

4. move the avatar outside of the wall.
- I really shortcutted here. The walls are represented as just Cubes who are relatively thin in their Z component. So i just set the avatar's Z (still in wall space) component to be the expanded Z-extent of the wall. (Taking into account the sign of course). This seems to work really well.

5. convert the modified wall-space avatar position back to global space:

avatar translation: (geometry globalTransform localPointToGlobal: a1).

ta da!

-Also integrated Tao's contentBrowser, improved the menus, and done i don't know what all.

annotating

Annotating seems to be a pretty hot topic lately,
and Tao & i are starting a stab at it.

The big debate for us is how to present the text.

We've argued over it a lot and i think we're going to try a few different methods and see which one(s) we like.

* 2D morphic pop-up windows in screen-space. (external to the whole croquet window)
* TWindows in camera-space. (ala the default croquet HUD pop-up for left-click)
* TWindows in world-space.

Re Collaboration:

* The last approach has a default solution. Just zoom up to the window and edit. (Some tweaks will have to be made to allow an avatar to select thru another avatar when they're superimposed)

* The first two will need some work. We'd like the annotation to be visible only to those folks who want to see it. That is if A, B and C are editing the annotation, and D doesn't care, then the annotation shouldn't take up World or Screen real-estate for D.

Meanwhile,
here's a nifty-looking screenshot of the first pass at the annotation incidators.
This required a small change to TRay>> pickTriangles: list: because that routine did not return a normal. I added some very brutish normal calculation and it seems to work as well as could be expected. (quite well in the four or so objects i've tried it on) Change set is available here.

getting ready for citris open house thursday

After a bit of thought,
Tao and I decided to show the new version of the gallery software at a CITRIS open-house this thursday. While the newer version does not have the media support quite in place, it does feature actual collaborativity and a more intuitive and sexy user interface.

Today i got the bulk of Tao's mpeg player into the new version,
along with the usual control buttons, but still have a bit of work to do.

Loading VRML2 files still needs a bit of work and we'll be faking it a little (but truly only a little) at the demo. One problem we're facing here is collaborative manipulation of 3D objects with the TEditBox. TEditBox is a wonderful interface but hasn't been meta-fied yet, unlike TDragger. I may take another stab at bringing meta into the TEB now that i'm a little familiar with how meta works.
Also the texture field of a VRML2 file seems to be being ignored, which i plan on trying to just fix, but i may have to do some work-around like assigning a texture w/ the same name as the file.

gallery mark 2 demo available

http://citris-uc.org/hosted/projects/ith/gallery/mark2demo.html

Tao and I felt like showing the new version of the gallery in its current state, in hopes of getting feedback etc. This demo is of more interest i think to the Croquet development community than to the actual target users of the software, which are humanities academics.

We're especially looking for feedback in these areas

* does it run ?
* what sort of framerate (and system description)

* does it run collaboratively ?
* what sort of framerate (and system description)

* how's the interface ?
* menus
* overhead view ('!' button | views | dual view)
* manipulating walls

any thought you have are highly welcome.
please email starbow@eecs.berkeley.edu or oxe@eecs.berkeley.edu.

CInputFieldWithReset

I seem to be writing small Tweak classes lately.

This afternoon added "CInputFieldWithReset" to allow users to easily reset the values in the primitive properties editor dialog.

This object is available here: http://bugs.impara.de/view.php?id=1598.

Go Here, Primitive Properties, SkyBox

There's a new partial release up at:
http://www.citris-uc.org/hosted/projects/ith/gallery/downloads.html

- Added a pop-up dialog for Primitives allowing you to
manually edit their position, size, and other properties.
This seems to work with save & load,
but i'm a bit nervous about it,
especially the extent of cubes and squares.
(well, formerly cubes and squares ;)

- Added 'go here' item in the pop-up menu for most items,
under options.

- Fixed skybox problems, added 'none' as an option.
(Still need a 'background color' option tho!)

- various other small changes.

Navigation Buttons

We've been kicking around the idea for a while of putting some heads-up buttons on the screen for navigation. That is, buttons to press for 'forward', 'back' etc.

Watching a new user yesterday struggle with the QWE/ASD keyboard navigation (mouse navigation was even harder) i decided to add it in sooner rather than later.

So there's now 6 floating overlay buttons which mirror the layout of QWE/ASD.
When you mouse-click a button, the expected thing happens.

But what's really good, i think, is that when you press or release a key on the keyboard, these buttons reflect that. It's a very nice visual feedback.

mmm donuts

As a quick aside in the pursuit of point-clouds,
i generated some point clouds which are points 'near' the surface of a torroid.
The nifty part is that the points are evenly distributed on the donut surface.
That is, if you were standing on the donut, you'd perceive the average point density around you to be pretty much constant no matter where you were standing.

This is actually non-trivial.
Consider the traditional simple mapping of wrapping a rectangle around a donut via theta = x , phi = y. This mapping contracts the map on the inner wall of the donut and expands it on the outter.

Similarly with a sphere, theta = x, phi = y contracts at the poles.
For a sphere this turns out to have a simple analytical solution which i think is just theta = x, phi = sqrt(y). (I explore this mapping here)

However such an analytical mapping of a rectangle onto a donut turns out to be much more complex. Science News had an article in 2003 or 2004 which talked about a recent solution, but i can't find it.

For evenly distributing Random points however,
there's a fairly simple if brutish approach:

choose a random point inside the rectilinear volume which contains the torus.
if the point is within some threshhold of the torus surface keep it.
optional: project the point onto the torus surface. (this actually introduces a bit of non-even distribution, but it allows you to relax the threshhold quite a bit)
repeat until you have as many points as you want.

Torroid with 100,000 points evenly distributed within 0.01 units of its surface, not projected:

Comparison of filtered and non-filtered projected points:

.. honestly, it barely makes a visual difference, but it's nice to see anyhow.

Actually, after doing some more comparisons with donuts of different shapes,
i've come to the conclusion that the whole threshholding thing is pretty much unnecessary if you project the points onto the donut surface.

Funnily, projecting a point onto the surface of a donut is suprisingly simple and doesn't involve and trig.
Just project the point in question onto the circle which is the core of the donut and then project onto the surface.

New features, Release, Installer

Have finally rolled Croquet into a Nullsoft installer package,
which works great of Windows users. Have continued to release .zip files
for cross-platform users.

New release out:
here.

It notably includes two new sample galleries which are content-lite & -heavy, and a demo of the animated pointcloud tele-immersion stuff.

Just added ability to zoom-to an object, similar to TWindow's (but without facing you "in front" of the object, just close to the object.) it works nicely. Thanks to Ed Boyce for lighting a fire under that one.

Also added ability to put Markers on TPrimitives. This was also thanks to Ed, who is using the Sphere primitives to model a solar system, and i realized that one might want to annotate a planet.

Animated point clouds have been added with pre-calculated geometrical summaries. Am beginning work on networking to dynamically pull in tele-immersion data.

Am at work now on an input dialog for Primitives,
to allow numerical placement. - Will probably generalize that for TGalleryBase objects.

Fond Adieu.

I think this is probably the last post for this blog.

I've taken a new position as a physics research assistant at the south pole of the earth, where i'll be from about mid-october 2005 thru november, 2006.
There's more info (and a blog) here: http://www.elenzil.com/ohpolar.

It's been a pleasure working with the Croquet community, and i hope to stay in touch. I'll definitely continue following the Croquet scene from down there, but i doubt i'll have time to do much more than dabble.

best,
Orion

Cloth again

(related to this previous post)

I couldn't stay away from the cloth,
so i've put together a change set which includes a decent demo.

I added collision with spheres,
and in addition added something which altho i'm sure it's been done, i've never seen, which is: not only does cloth make way for the sphere, it also pushes the sphere around. I've only ever seen fairly static objects which the cloth humbly obeys, but it's simple enough to additionally have the cloth push the sphere.

The changeset files-in to a stock Croquet0.3 image, and is located here:
http://www.citris-uc.org/hosted/projects/ith/cloth/ClothOxe.5.cs.

The changeset includes a pop-up menu with different preset situations.
The presets run fairly fast (20 or 30Hz or so) on my 3.2GHz windows machine,
with the major caveat that performance seriously degrades over time. I'm not sure why this is. I think it may have something to do with squeak garbage collection.

Pretty close to some initial conditions. It's billowing up because of 'wind'.
The cloth is anchored along its four edges.

A bit more billowing.

Holding a sphere. The sphere rolls around fairly nicely.

One of 8 exciting preset scenes: A sphere bowling into a cloth which is anchored only along the top edge.

Primitive Editor

Ed Boyce is interested in using the Gallery software to present solar system simulations. (Is "solar" Sol-centeric ? ie, is there only one solar system in the universe, one solar wind, etc ? or does Alpha Centauri or Sirius produce a solar wind as well ?) To that end, a couple new features are in the worls:

* numerical positioning of objects.
- for starters a simple dialog which lets you edit the properties of a primitive.
i've been wanting to make one of those for a while. It's a relatively generic dialog with fields for position, radius, inner radius, top radius, base radius, segments, wedges, etc, in essence all the potential fields a primitive may support. The fields are only shown if the passed-in primitive supports the methods to set/get those fields. ie via "aTPrimitive class includesSelector: someSelector".
It's a bit clunky, definitely, but works so far.
- I'm not sure if i want to include Texture, Spin, etc in here.
- for seconds, we may work out a table format to input the data, altho this seems to be straying a bit from a general gallery app to me.

* "Go To" feature.
- added a menu item to all objects which reads "Go Here" and simply zooms the camera/avatar up to the object. The behaviour is similar to that of TWindow, but somewhat different in that it doesn't pay attention to the 'front' face of the object. With TWindow, the viewer always ends up aligned facing the front of the object, which is as it should be. However that's a bit unintuitive when you just see some object in the distance and want to go to it. With "Go here" it's as if you simply walked (quickly) over to the object.
- I would like to add a pop-up window listing all the objects (of interest) in the scene and allowing you to select, edit, and of course, go to them.

* Providing hooks to ODE for physics

* Ed would like to see 128-bit numbers instead of 32-bit.
- I think this is somewhat out of the scope of the Gallery project and more in the purview of Croquet or Squeak itself. itselves. themself.

Using Shorts for spacial Coordinates

The teleimmersion project generates huge point-cloud datasets,
with approximately 100,000 points per frame, each point having XYZ and RGB data.

In the interest of increasing the performance of (future) streaming of this data from the source machines into a target machine running croquet, i've been working on simply reducing the precision of the data.

I assume a maximum streaming thruput of 18MB per second, based on tests streaming within my own computer.

Originally, XYZ and RGB were each represented as triples of four-byte floats.
So, 3 * 4 + 3 * 4 = 24 bytes per point * 100,000 = 2.4MB per frame -> up to 7.5Hz.

RGB is an obvious target, since rendering cards at their base level can only handle colors with single-byte components.

So i made an option to represent the RGB values as triples of single-byte components.
So, 3 * 4 + 3 * 1 = 15 bytes per point * 100,000 = 1.5MB per frame -> up to 12.0Hz

I'm nearly finished with an option to represent the XYZ values as triples of two-byte signed shorts.
So, 3 * 2 + 3 * 1 = 9 bytes per point * 100,000 = 0.9MB per frame -> up to 20.0Hz

Here is a screenshot showing three different types of representations.
Random-point placement aside, they look pretty much identical.

Implementation Issues
---------------------

Changing to single-byte color components was relatively straight-forward.

Changing to two-byte spacial components has been a bit trickier.
OpenGL is perfectly happy being passed GLShorts for spacial data;
the card must be converting them to floats before running them thru the graphics pipeline. I haven't yet tested for performance issues here, but i don't expect any.
More complicated however is that Croquet of course works with B3DVector3, which is based on B3DFloatArray,which is based on FloatArray, which is of course, Floats.
Furthermore, Squeak doesn't even have a ShortArray!
What Squeak does have is ByteArray, which has convenience methods for accessing pairs of elements as shorts. (and longs, if you're in to that sort of thing)
So the data can be accessed for purposes such as finding bounding boxes and doing calculations.

Dealing with Scaling is so far definitely the trickiest issue.
Croquet does not use the usual scale feature of transformation matrices; rather it requires the actual vertices to be actually changed. David Smith once explained to me that this is to enable/simplify picking thru portals, if i recall correctly. In any event, i felt that reimplementing scale as a per-point conversion, multiplication, and unconversion would be prohibitively slow. So i'm trying out just putting scale right in the matrix. The sphere on the far right has been scaled this way. So far it's working well altho there must be some remaining issues with bounding box, as a TEditBox no longer works with the byte-spatial-components pointclouds. I'm about to look at this.

Vernet Cloth

Dave Faught pointed me to Thomas Jakobsen's article "Advanced Character Physics", which was used by the guy who made the Falling Woman demo.
Jakobsen writes about particle systems, a subject dear to my heart, and interestingly advocates using Vernet Integration rather than Euler. I've traditionally just gone with Euler because it's straight-forward.

Review:

In Euler,
the basic per-frame per-particle process is something like:


position'     = position + velocity * dt.
velocity'     = velocity + acceleration * dt.
acceleration' = whatever.

With Verner,
instead of storing velocity, you store the previous position. And thus:


position'     = position - positionOld + acceleration * dt^2.
positionOld   = position.
acceleration' = whatever.

- I have to confess i don't understand the derivation of that core line,
but it seems to work.

Jakobsen also gives a nice approximation for square root.

So i thought i'd try out implementing the Cloth simulation outlined in Jakobsen's paper. Basically it's a triangular mesh with every edge a spring. Velocity of the nodes is not stored, but the previous position is.

A very heavy part of the computation is calculating normals.
For every node, i pre-compute a list of 2 pairs of other nodes (4 nodes total) which represent vectors to be cross-producted with each other. Essentially, for most nodes in the mesh, the node is the center of a hexagon and i calculate the normal as the cross-product of two of the hexagon's three obvious bisectors. The edges are special cases and work allright but not great, and i ignored the four corners.
To speed up normal computation, i also only calculate every Nth normal per frame. When N is 3 or 4, this is a significant speedup.

The simulation runs fairly well on my 3Ghz PC with about 25x25 nodes. Fairly well = about 20Hz or so.

Here are the change sets for the classes, and here is an image file if you're in a hurry.

Screenshots:

Byte Color Components versus Floats

The tele-immersion data sets are point-clouds where each point has XYZ and RGB information. Previously, each of component of XYZ and RGB have been floats.
However, since colors are eventually converted to 8-bit components, RGB could be 3*8 bits instead of 3*32 bits.

Below is a comparison of tele-immersion data with 7-bit* color components versus 32-bit floats. Basically it looks fine. The 7-bit file is 2,004,809 bytes, and the float file is 3,207,668 bytes, so the ration is about 5/8!

Future directions:
I'd assumed that OpenGL required float data for XYZ information,
but i just checked and GLVertex3s is a call for specifiying XYZ with 'GLShort' components, which i presume are 16-bit. If we're able to get that to work, the data would go from 64 bits per point to only 24 bPP, or a ratio of 3/8.

Current streaming speeds indicate a theoretical maximum frame rate of about 6Hz with 64bPP, so that maximum could go up to about 16Hz, which is much more appealing.

On the resolution of 16-bit spacial information:
16 bits has a resolution of one part in 65,000.
The tele-immersion "playpen" is approximately 10 feet in each dimension, which translates to a 16-bit resolution of about .002 inches, or about .05 millimeters, which is pretty good.

* For some reason, OpenGL via Croquet interprets byte color components as being in the range 0-127, not 0-255. Values over 127 are clamped to zero. See http://bugs.impara.de/view.php?id=1684.
edit: Bert Freudenberg has clued me in that GLBYTE is a signed value; i want GLUNSIGNEDBYTE or equivelant. Thanks Bert !

Input Validation

This is kinda neat.

With the new Properties editor for primitives,
there's a number of input fields which need to have the user's input validated before being used.

For example, maybe the user types in a word where a number is wanted,
or enters a value outside of the allowed range,
(or, because i thought it might come in handy, the user types in 0 when 0 in particular is disallowed).

Validation becomes somewhat trickier when the fields affect the scene immediately - that is, as soon as the user hits a key, it's reflected in the scene. In this situation, you absolutely need validation.

For example, in the case of TSphere segments, the minimum value is 2 (altho i'm using 3).
A natural and frequent user interaction will be to delete the value currently in the field and then type in a new value. After deletion but before typing, the value of the field is invalid, and so must be handled.

I subclassed CNumberConverter and added members for min, max, zero disallowment, as well as a pointer (?) back to the CInputField itself, and some helper variables.
When the input goes invalid, the CInputField background is changed to lightRed (the man's pink!) and the last valid value is reported. The text content of the input field is left unchanged, however, because changing would interfere with the user's typing.
When the input goes valid, the background color is changed to the CInputField's container's background color, and the current value is stored as the last valid value.

Basically, it works fairly nicely.

The file-outs of the new classes are here.

Small new release - Good Stuff

There's an image/changes-only release up at http://www.citris-uc.org/hosted/projects/ith/gallery/downloads.html

Most notably there was an old bug around which was causing a dump to the log file at least every frame in some situations, which pretty severely impacted performance, to say nothing of filling up the harddrive ! Folks should download this version just for this.

Also included are the heads-up navigation keys described in the previous blog post,
which are really pretty nice,

and some other improvements:

Citris Gallery 2.8.2

Fixed bad bug that was often dumping ~4KB/second to log file.

Added heads-up navigation keys.

Cursor changes according to which part of EditBox it's over.

Various other improvements/fixes.

one megapixel

We're looking at combining (live) tele-immersion data with the croquet gallery project.

The tele-immersion data comes in the form of a huge point cloud: xyz, rgb per point,
with millions of points. (~ 640x480x20 or so per frame at about 10Hz.)

I did some initial tests to see if there's even a remotre feasability and discovered some interesting things:

1. you can send at least a million points straight to openGL in an array.
2. openGL can render at least a million point at slow but interactive rates, say 13Hz.
3. openGL rendered big points faster than small points!
- with pointsize at 1, i got 9Hz, with pointsize at 15, i got 13Hz, very consistently.
Weird!

some screenshots.

Humanoid PointClouds

Towards bringing together the gallery project and CITRIS's tele-immersion lab, we've taken some data from Sang-Hack Jung and imported it into croquet.

The data is simply lots and lots of points with XYZ & RGB info.
Each frame is approximate 150,000 points, with a framerate of about 12Hz.

Below are preliminary results showing simply getting some of the data in to Croquet.
Next steps are reading in approximately 50 frames from 50 files,
followed hopefully by networking.

Qualitative observations:
The data reads in from disk nigh instantly via AsyncFile, straight into a B3DVector3Array.
Additionally it scales quite fast, which surprised me because the actual points are scaled rather than having the scale in the matrix.
Very slow however is computing the bounding sphere/box of the cloud.
I'll probably pre-calculate this and include it in the data files.

Heirarchy between gallery objects

you asked for it and now you almost get it!

There's a new image/changes file here:
http://www.citris-uc.org/hosted/projects/ith/gallery/downloads.html

Primitives and VRML objects now have a new menu called 'heirarchy'
which lets you make one object a child of another.

This way you can group things together,
like a vase on a table,
and work with them conveniently.

How to do it:

this is admittedly real clumsy for now but:
1. find the object you want to be the parent.
2. heirarchy | select
3. find the object you want to be the child
4. heirarchy | make child of

there's also "make me a child of nobody",
orphanize children (makes them children of their grandparents).

it seems to work with saving and loading of .ctrgal files,
but that could use some testing..

Stripped XO

Early in January, my laptop was the star of a photo shooting for the German issue of MIT's Technology Review. We took off the plastic enclosure of the "brick", it was pretty interesting, for example to see how the whole display in its metallic housing is carefully held by rubber mounts.

This photograph was published in the magazin's current issue (02/07), along with a shot of the main board (which sits behind the display). The accompanying text not only provided a description of the parts, but also highlighted some design decisions that makes it unique hardware-wise. OLPC's educational goals were already reported on in the previous issue.

Image courtesy of http://www.heise.de/tr/magazin/

The colors are off for some reason after uploading to blogger - they were fine on my disk. Sorry.

European grassroots meeting

I went to Brussels last weekend, meeting with folks from OLPC Europe, OLPC Boston, and some other European grassroots (me representing OLPC Germany e.V.). We mostly discussed how to implement the new Give-1-Get-1 program as well as Give-manyhere in Europe. Some notes are available.

And, while sitting together at a nice Cafe on Sunday I made this little Etoys project to celebrate OLPC Europe. Just click here if you are on an XO or have the Squeaklandplugin installed (as everyone should of course). For those who were there and took the huge file home on their USB drives - this is a fixed version that does not keep growing indefinitely while animating.

For the Etoyers out there - if you put a copy of a player in one of its own variables repeatedly, this creates an evergrowing "linked list" of player copies. Bad idea. Reset the variable first (by assigning dot for example) then do the copy: see my example.

OLPC review now online, English too

The extensive OLPC article by c't magazine is now available online in both original German and an English translation. It's a thorough review (they had a B1 machine) with some interesting photographs in it, like the Squeak Etoys screen in reflective and backlight modes with microscopic images revealing the working of the XO's incredible LCD.

Peaceful Holidays ...

... and a Happy 2009 to everyone from me and my family.

Presented by my XO-hugging USB men (who seem to have more memory capacity than me at times).

Featuring a seriously tree-infested Etoys project, with snow (for those living south who cannot enjoy the white fluff this time of the year).

And see you at 25C3 I hope!

Emulating the latest stable OLPC XO software

Even with XO laptops readily available now there are quite a lot of reasons why one would want to emulate it on another machine. One being to hook up a projector. Unfortunately there are quite a number of hoops (*) one has to jump through to make it work.

Anyway, I made a virtual machine that allows me to emulate the XO in VMWare on my Mac, running Sugar in the XO's native 1200x900 resolution, scaled down to a nice physical size in a window on my regular screen (fullscreen works, too). Sound works (even Tam Tam), Browse works (so networking is good), and after setting a working Jabber server I do see other XOs in the neighborhood view (Chat worked fine). Camera and mic are half working (Measure crashes, Record shows blank picture, but reportedly does record video), and a "Sugar restart" does not actually restart Sugar, but apart from that it seems fully functional, and much nicer than the emulations I had used to date.

Click to see actual screenshots (calibrated to match the XO's physical extent using the Ruler activity on my MBP's 110 ppi screen):

And here you can get that virtual machine (665 MB, 2 GB unzipped): VMWare-8.2-767-bf.zip

I made this using VMWare Fusion, which I found to be much better at running Linux clients than Parallels Desktop (I had been using that for 2 years). Give it a try, it's free as in beer for 30 days. No, I don't get paid if you buy it.

Update: Reportedly it does work in VMWare Player on Windows and Linux, too (see comments). And maybe someone can make an appliance for even easier use?

(*) Now to the hoops:

I started with the 767/ext3 image from http://download.laptop.org/xo-1/os/official/
extended to 2 GB by appending /dev/zero
(jffs2 compression gives roughly 2 GB too)
enlarged the partition to full 2 GB
(using fdisk and ext2resize)
mounted that in a Fedora 10 virtual machine
copied over the F10 kernel, initrd, and modules
(olpc kernel wanted AMD instructions)
edited grub.conf to use that kernel
and appended a root=/dev/sda1 kernel arg
(the fedora kernel wants to use LVM otherwise)
unmounted
created new virtual machine
(that disk, 1 CPU, 256 MB RAM, NAT networking)
booted into that new system
installed Perl
(for vmware tools installer)
installed vmware tools
(to get the X driver)
(but none of the kernel modules, would need make/gcc/etc.)
deleted Perl
(to restore the default sw environment)
copied the existing xorg-vmware.conf to xorg.conf
(to get 1200x900 resolution w/ 200 dpi)
booted into Sugar
(looks really nice so scaled down)
installed activities
(took a long time, maybe it's my DSL)
tested a bit
rm -r ~olpc/.sugar
(to remove my personal data)
should have deleted sshd host keys, too, but didn't
shut down
zip
upload
...
...
...
still no profit? ;)

Enjoy.

Croquet SDK 1.0 released

Get it while it's hot from the equally new Croquet Consortium web site.

Interactive OLPC XO Display Simulation

Many people still have not seen the innovative display of the OLPC project's "XO" laptop. It has twice the resolution of a regular LCD (200 dpi), and works in bright daylight in gray-scale reflective mode. It's impossible for me to increase your screen's resolution by software, and I cannot make your display reflective, but here is an interactive simulation of the backlight mode with its interesting color pattern. This pattern is the source of a lot of confusion about the "color resolution" of the display. The LCD has 1200x900 square pixels, but the backlight puts a full color through each pixel. It is not made of red, green, and blue sub-pixels like a regular LCD, but the first pixel is full red, the second green, the third blue, and so on. The DCON chip (Display CONtroller) selects the color components from the full-color frame buffer.

My simulation of the DCON achieves the same effect by selecting either the red, green, or blue color component in each pixel. Just move the mouse pointer around to see how different colors are reproduced. You'll notice strong diagonal patterns, but remember, on the actual display the pixels are only half as large. Note that the actual DCON optionally applies a bit of anti-aliasing in hardware which is not simulated here. It helps reproducing fine structures and depicts colors more accurately. Additionally, the simulation shows a magnified image to better illustrate the principle, but it is not accurate because the reflective area of each pixel is not depicted. Maybe I can add this in a later version.

I made the simulation using Squeak / Etoys, which is one of the programming environments on the OLPC machine, but also works on Windows, Mac OS X, Linux, and many more systems. If you run the simulation on the actual laptop (download the project, place it in /home/olpc/.sugar/default/etoys/MyEtoys, run Etoys, choose Load Project), then you should close the small simulated screen and just leave the magnified view open.

For the interactive simulation, download Squeak (this version installs both, a regular application and a browser plugin), then click here to run the simulation in your browser, or download the project file, launch Squeak, and drop the project into it.

Intel-Mac users beware, the plugin is not supported directly yet. To see the project in Safari, you have to quit Safari, set it to open in Rosetta (select Safari in the finder, press Cmd-i), and reopen. Or, use the download method, Squeak itself is running fine on Intel Mac, it's just the browser plugin that's making problems.

OpenGL in a Workspace

On some modern Linux systems, Croquet does not work anymore because OpenGL failes to initialize. Now, I originally wrote that code, and it worked fine for years. So it can't possibly be buggy, right? Jens Lincke of impara tracked it down to the "Composite" extension that is enabled by default nowadays. With Composite disabled, it works, enable it, and it does not.

So I turned to NVIDIA for help, thinking their driver might be buggy. Had to give them an easy way to reproduce the problem, this is the snippet I came up with:

| ogl green |
ogl := OpenGL newIn: (0@0 extent: 100@100).
green := 1.
[[
        ogl glClearColor(0, green, 0, 1).
        ogl glClear(16r4000).
        ogl swapBuffers.
        Sensor waitClickButton.
        green := 1 - green.
] repeat] ensure: [ogl destroy]

Beauty, eh? ;-) I guess nobody has done this in a workspace for a long time. Stop it with Alt-.

Anyway, NVIDIA could reproduce the problem, and found our bug:

[...] the app is trying to create a depth 24 child window of a depth 32 parent and the app specifies neither a border pixel nor a border pixmap.

Doh! I forgot to specify the border! We were just lucky that this did not happen before. Jens and y.t. made a patch, should be in the next VM. And big thanks to NVIDIA developer support!

In-depth review of XO in German c't magazine

There's a glowing review of the OLPC project and its XO machine in the current issue 07/2007 of c't magazine. The in-depth article by Dr. Jrgen Rink describes the project's history and educational ambitions as well as its current prototype hardware and software. One very interesting detail is a comparison of the XO's novel dual-mode display in low light and bright sun light, at normal size and magnified:
On the left, under indoor lighting, the colored backlight shines through holes in the reflective layer. On the right, when brightly lit outdoors, the reflection is so strong that the backlight is not even visible anymore, thus creating a gray-scale image. The photographs show one of the example Etoys projects.

The magazine is available now at kiosks until next week, or via mail order. In a few weeks the article should be available online via click&buy.

Croquet for Business: Qwaq Forums

So Qwaq came out of "stealth-mode" and reveiled what they have been working on for a while now, Qwaq Forums:

Qwaq Forums, the company's first product, is a secure virtual workspace application that significantly increases the productivity of distributed teams by bringing critical resources together in virtual places, as if they were in an actual physical location. A highly interactive and persistent environment, Qwaq Forums enables users to work, collaborate with others, and identify and solve problems.

And I'm proud to say I contributed a little, which most probably will find its way into the next Croquet release.

Update: Here's a few nice stories of fellow bloggers who have seen Forums already.

From Steve Borsch's Connecting The Dots:

Qwaq will get traction only because they completely understand that giving someone a semi-trailer truck (i.e., an engine like There or Second Life) doesn't do much good if the person has a small garage and needs a vehicle to go get groceries and tool around (90% of collaborators). Qwaq Forums is a powerful, easy to use and navigate, co-creation space that the rest of us can use.

Glyn Moody writes on Open dot dot dot:

One of the benefits of using Croquet as the basis of its products is that the protocols are open, and this allows Croquet-compatible products to interoperate with Qwaq's. This means that the dynamics of the Croquet ecosystem are similar to that of the Web, which is never a bad thing.

And in The Culture of Collaboration, Evan Rosen writes:

Unlike most traditional web conferencing which works only while a session is underway, Qwaq Forums is persistent. This means authorized users can access the virtual space any time. Team members in another time zone may wake up to find the results of real-time collaboration that occurred while they were sleeping.

Tasks

I am working on a new implementation of tasks that will make creating new UIs much simpler. Basically, there is a new base class, called a TTask which handles all events from the CroquetHarness. Even the default interface in Croquet is implemented this way.

An event is interpreted and redirected by the task object. The default task simply forwards the event to the initially selected object, which is just what happens now.

Ultimately, any portal will be able to reinterpret the events via their own task objects.

Updates

Lots happening. The Croquet release is doing well. Remember that this is very much a developer release, so don't expect it to change your life today. Still lots of loose ends, the UI needs LOTS more work, performance is sub-optimal, still a number of complex problems to solve, but the underlying architecture looks like it is in great shape.

Julian Lombardi and I attended the Metaverse Roadmap Project where we had a number of opportunities to demonstrate the system. Response was quite positive. See the following:

http://metaverseroadmap.org/index.html

http://scobleizer.wordpress.com/2006/05/06/wow-3d-operating-system-open-croquet/

http://www.ethanzuckerman.com/blog/?p=537

Tasks

Qwaq

We finally announced Qwaq. I am sure one or two of you were wondering why this blog went silent for such a long time. I had some good excuses - I was busy, and I didn't want to say anything about what I was doing anyway.

Qwaq was founded by a group of us that believe Croquet can have an impact on the business world. Even an open source project like Croquet must have a revenue stream to drive it, and Qwaq is the first of what I hope will be many companies that will focus their efforts around making Croquet even more valuable. You can read more about the company here: http://www.qwaq.com.

Alan Kay and David Reed are advisers to Qwaq and Andreas Raab is a cofounder so we are still working together. In addition, Greg Nuyens, our other co-founder is the Qwaq CEO. I met Greg at a previous company I co-founded, and was extremely impressed by his intelligence, drive, and in particular his interest in the customers.

Why Qwaq? I wanted a short word that was easy to remember and easy to type. Look at the top left three keys of your keyboard - QW are next to each other and the A is directly below these. I also thought that it sounded fun.

There is evidently quite a bit of interest out there in what we are doing. Typing Qwaq into Google and you will see an amazing amount of coverage just since we announced the product a few weeks ago. I should mention that Remy Malan is our VP of Enterprise and did a terrific job with this.

Finally, what impact will Qwaq have on the continued development of Croquet as an open source project? A very positive one. We are still extremely committed to this project and if anything have accelerated the amount of effort we have put into it. Croquet continues to improve - much of what we learned in building Qwaq Forums was directly incorporated into the next Croquet release (imminent) and I think it is better than ever. I plan to continue using this particular forum to keep people up-to-date on where Croquet will be going.

Thanks for checking back - it is a really exciting time for Croquet (Qwaq is just half of the story), so watch this space and the Croquet Project home for more details to come.

Croquet Consortium Launched

Industry and Education Leaders Launch The Croquet Consortium, Inc., a non-profit Foundation for Open Source Software Development.

DURHAM, N.C. March 27, 2007 HP (Hewlett-Packard), Duke University, The University of Minnesota, and Qwaq, Inc. have jointly announced the formation of The Croquet Consortium, Inc., a 501(3)c non-profit foundation dedicated to promoting the continued development and widespread adoption of open source Croquet technologies for use in education, research, and industry. The launch of The Croquet Consortium coincides with the Consortiums release the open source Croquet Software Developers Kit 1.0 -- as free software under the Croquet Open Source License.

The Croquet Consortium provides an organizational base for the Croquet community of developers and users. Open to institutional and individual members, the Consortium offers an avenue for academic, corporate, and individual members ensure the long-term viability of the community by federating their Croquet software development projects mobilizing distributed resources on their behalf.

With the launch of The Croquet Consortium, Inc., the development and adoption of scalable Croquet-based applications for use in education, research and industry enters a new, expanded, and highly-inclusive phase of multi-institutional collaboration. The Consortium 1) establishes a legal home for the Croquet community, 2) coordinates the management, definition and release of core interoperable Croquet architecture, 3) provides a clearinghouse for the collection and distribution of freely available Croquet open source software artifacts, 4) supplies a management structure for the solicitation and mobilization of distributed development resources, and 5) creates a focal point for outreach activities, including the Consortium Website, Annual Conference, training workshops, fellowships, and sponsored projects.

Qwaq and Croquet at HASTAC

We will be demoing Qwaq Forums at the HASTAC conference at Duke next week.

From their site:

"A consortium of humanists, artists, scientists, social scientists and engineers from universities and other civic institutions across the U.S. and internationally, HASTAC ("Haystack") is committed to new forms of collaboration across communities and disciplines fostered by creative uses of technology.Since 2003, we have been developing tools for multimedia archiving and social interaction, gaming environments for teaching, innovative educational programs in information science and information studies, virtual museums, and other digital projects. HASTAC leaders have served as consultants to U.S. and international organizations and governments on grid computing and cyberinfrastructure.Our aim is to promote expansive models for thinking, teaching, and research. To view a presentation on HASTAC, please click on the presentation attached."

Check it the conference here:
http://www.hastac.org/informationyear/conference

Croquet SDK 1.0 Released

Nonprofit Croquet Consortium Releases Open-Source Software Tool Kit to Promote Collaborative 3-D Virtual Environments

DURHAM, N.C. March 27, 2007 A nonprofit consortium of academic and corporate partners announced Tuesday the release of a free software tool kit for developers to use in creating 3-D "virtual environments."

"Were seeking to enable the creation of a rich series of interconnected Croquet worlds where people can engage in productive collaborative interactions in support of learning and commerce -- worlds that can be created, maintained and continually modified without the constraints of proprietary computer code," said Julian Lombardi, assistant vice president of Dukes Office of Information Technology.

The Croquet Consortiums new "3-D Virtual Environments Software Developers Kit" (Croquet SDK 1.0) will promote collaboration among far-flung research teams working on everything from cancer cells to hurricanes, as well as active learning among students and their instructors. These networked 3-D teams from research, education and industry will be able to work together across a variety of computer platforms and devices, from laptops to cell phones.

"This will change the way people think about software and computation, from todays device-oriented perspective to a perspective of computation as a persistent, pervasive service," said Patrick Scaglia, vice president of research and development at HP Labs.

Croquet 3-D virtual environments can support live discussion among worldwide collaborators who come together in "real time" within a 3-D virtual space. They may view, manipulate and revise documents, dynamic visualizations or large amounts of data from sources such as laboratories or supercomputing centers.

Added Greg Nuyens, chief executive officer of Qwaq Inc., "We have found Croquet to be a compelling platform technology for developing very large scale, richly featured and interlinked virtual environments. With the release of the Croquet SDK, we are excited about the new possibilities for using Croquet in our products and see benefits for developers everywhere."

For example, public health officials and epidemiologists across a country could use the Croquet environment to track the spread of an infectious disease by sharing a dynamically changing display of infection data. Similarly, architects and engineers could collaborate on a building design, or chemists and biologists could prototype different chemical compositions for a new drug.

The kit provides developers with a flexible tool to create virtual spaces with built-in networked telephony and a "late-binding object-oriented" programming language that allows multiple users to jointly create, animate or modify 3-D objects and dynamic simulations. Developers can also import and share resources, such as 2-D web applications or multimedia content, from their own systems. Working together across multiple locations, they can change simulations while they are running and work together to create new applications -- all in real time.

3D Worlds and Interoperability

I attended a working lunch this week at Harvard to discuss 3D interoperability. It was an interesting discussion. I think the biggest problem was simply the definition of interoperability. For some people at the conference, it meant as little as reconstructing someone elses content in another 3D environment, or maybe being able to somehow copy 3D data sets from one place to another. Others viewed it as being able to reuse and dress-up your personal avatar for shopping or for role-playing.

We even discussed the possibility of hooking Croquet up to Second Life via Croquet portals. This should be relatively straightforward to do - it would require a compound application of some sort, but since Croquet is already designed to hand off rendering to the adjacent Island (Croquet Islands and Second Life Islands are different kinds of things) when rendering through a portal, handing it to the Second Life client would not be much different. Coming back the other way might require a bit more finesse, as we would have to add some portal support to SL, and would have to call into an image based system. We have been doing something similar recently, so it is quite possible.

I think David Reed (one of my fellow Croquet architects) really nailed what 3D interoperability should be. When we share 3D objects, we also need to share their behaviors. In most ways, the visual representation of an object is its least interesting aspect. What it can do, and how it interacts with the users and the worlds around it, however is REALLY interesting and very valuable.

This is also really hard to do. Everyone uses different languages and scripts, and some - like Croquet - use a very different mechanism for enabling behaviors. Croquet has TeaTime and the concept of future replicated messages to manage its behavior. This enables a peer-to-peer approach to designing interactions, which otherwise would be near impossible. The only other solution is what everyone else has to do, which is maintain a central server and replicate the results of the computations.

Internet2 Conference

I am in Arlington, VA to be part of a panel on Virtual Worlds (Wednesday at 1:15pm). I intend to do a live demo of Qwaq Forums. I think that is a lot more interesting than a PowerPoint presentation. I have always tried to do demos to set the context of my talks, because I think being able to show people what I am doing and interested has a bigger impact than just talking about it. It does get a bit too exciting sometimes - Internet access is not always what it should be. One presumes that a conference about Internet2 will have a reasonable connection though.

Croquet and the Perils of Open Source

Croquet is Open Source. This has had both a positive impact on the project and in some ways a decidedly negative impact. The positive is the positives that most open source projects enjoy - lots of interest and creativity building around the system, visibility, strong academic relationships - it even helps allay concerns of larger enterprise customers knowing that there will not be a Microsoft-type lock-in with a single vender.

From the start Croquet was developed completely out in the open. Even the very first, barely useful versions of the system were readily available to download, deconstruct, and criticize. Nothing wrong with this - we invited it, and the project profited from it. The big problem we had to deal with is people were disappointed with how much of the system was or wasn't working. I have heard people say "Yeah, I tried Croquet a few years back, but it.... " (you can fill in the blank with a number of choices). I can understand why people would be irritated. Some critical problems in Croquet took much longer for us to solve than we ever thought they would, we had spent a minimal amount of time on UI, back-end infrastructure, performance, etc... Getting something like Croquet to work at all was a monumental task. We didn't exactly have a model to work from. We were inventing - not reverse engineering.

Of course, anyone that has ever developed a larger project has seen these kinds of issues. I certainly have dealt with them many times. The big difference was no one saw any of my project's warts except my colleagues and me. And we worked hard to remove, or at least hide them before we unveiled the final polished application. Croquet was different - people have been able to randomly sample the state of the project and critique it based upon that sample. Even today, the Croquet API is not quite a user-centric architecture. It is much more akin to the Linux kernel, looking for a front end to empower the user and a back-end to help users find each other and provide additional services. On the other hand, it is doing almost everything we said it would - and it really works well. We have even started a company Qwaq, Inc. based upon the same open source system that you can download today. We are getting great reviews for our first product Qwaq Forums, even though it is till in beta today.

What is my point? I have enjoyed this very open development process. I have learned a lot, and made a huge number of new friends and colleagues. Overall, it has been fun in spite of certain comments from people. I do think that next time - if there is one - I will probably hold off releasing a new system until it is a bit more mature and robust. In some ways that is sad - I think people that have stayed with the project from the beginning have learned a lot about how a complex system gets built and how it evolves. Most of this would be missed if you were to jump into a more complete end-user experience. On the other hand, it would probably increase the probability of success. In marketing, you only have one chance to make a first impression. Qwaq Forums is making a GREAT first impression. It would have been nice if Croquet had the same opportunity.

Julian Lombardi's Blog Has Moved

I've moved my blog to another address and will no longer post here. Please go to julianlombardi.blogspot.com to see all my posts, both old and new.

-Julian

Another KMZ Import

Another test of the new KMZ importer from Aik-Siong Koh. Note that the textures are mapping nicely onto the relatively complex model! Soon we will be able to import lots of content from Google's 3D Warehouse into Cobalt. That will be nice...

VNC in Cobalt!

Rajeev Lochan has just been successful in getting VNC to work within a shared Cobalt space! VNC is a graphical desktop sharing system which uses the RFB protocol to remotely control another computer. This is a big breakthrough for our open project. It means that a Cobalt-based VNC client can connect to a VNC server on any other operating system. Cobalt users will soon be able to view and interact with remote applications (including full featured web browsers) or even collaboratively access remote desktops within the Cobalt application. Because the VNC protocol can use a lot of bandwidth, we still have some optimization to deal with - but this progress is great to see. Thank you Rajeev!

Croquet Simulation Work

This new video by Willi Griephan of Bremen, Germany shows the operation of two Croquet simulation spaces that he created using the Croquet SDK. The first is a falling "Domino" simulation that leverages the Open Dynamics Engine for its physics. The second scene depicts swarm behavior in an aquarium simulation where two members of a swarm can pair, and by doing so, spawn new offspring. The Swarm algorithm that Willi used is described here by Craig W. Reynolds.

Strangely Attractive

Matthew Chadwick has been exploring the creation of GPU-computed chaotic attractors of dynamical systems using the Croquet SDK. The code he is using is based on David Faught's procedural textures code. In this implementation, the cube to the left defines a parameter space for controlling the system. Matthew says that the same code he is developing could also be used for other things like in-world physics simulations. Matthew will make all of this available for public release once the code is ready.

Immersive Workspaces

Linden Lab has announced that its now going to be moving into the enterprise 3D collaboration space. It recently announced a new product called "Immersive Workspaces" which is basically an area in Second Life set aside for corporate meetings. That more secure area represents "a completely exclusive and secure experience, with no connectivity to the Second Life mainland." Their intent is to develop a complete collaboration experience for the enterprise. I guess that is Linden Lab's attempt to try and ensure that business meetings are not disrupted by griefers or by unwelcome barrages of flying penises. Looks like the enterprise virtual worlds space is getting a bit more crowded. It will be interesting to see how this all plays out.

Collaborative CAD in Cobalt!

Thanks again to the work of Aik-Siong Koh and his team, Cobalt now makes it possible for users to work in a deeply collaborative CAD environment. This video shows how two Cobalt users on separate computers can work with relatively sophisticated CAD capabilities over a LAN. This newly-implemented collaborative CAD capability in Cobalt opens up a wide range of possibilities for engineers and others at a distance to develop sophisticated simulations and architectures in Cobalt worlds. The ability to develop animated content within a full-featured virtual world CAD environment sets Cobalt apart from other virtual world technologies in a very significant way.

Better Avatars!

Better avatars for Cobalt are almost ready! Here is a video showing an early test implementation of a motion-cycle enhanced avatar in Cobalt. Peter Moore has been doing a wonderful job with this and in getting the Ogre3D XML importer to work with models developed in Maya or exported from Blender. That means that we will all soon have at least two art paths for getting avatars and other animated meshes into Cobalt worlds. It'll also be great to finally retire the stilted Alice and Rabbit avatars. This particular video also provides a sneak peak at some of the texture and environmental/directional lighting work that I hope to have make its way into the next update of the Cobalt code-base.

The Colony Videos

I finally got around to posting the videos I made of The Colony. I had to borrow an old Macintosh from David Easter (who also did the ports to the PC and the Amiga) to make these, and I used a video camera to record them. This demonstrates the game, and I talk a bit about the technology behind it and why I designed the game play the way I did. Let me know what you think. I will also be posting some videos of Virtus ICE (Interactive Collaboration Environment). This was where the ideas for what became Croquet and then Qwaq Forums began.

The Colony videos are in two parts and you can see them here.

Part 1:

Part 2:

Croquet Priorities

Mark McCahill and I have been discussing the top priorities for Croquet moving forward. Here is the list of the top six things that we will be doing for 2008. The main theme is interoperability. This is interoperability at many levels. First, ensuring Qwaq Forums and Open Croquet worlds are interoperable. Looking beyond that is allowing Croquet worlds and avatars to interoperate with other platforms. This will be a large effort, but many of the technical hurdles have already been jumped.

- XML space description: a common space description file format in XML to allow the open source and QWAQ clients to read stored copies of each other's worlds.

Minimizing the size of objects being replicated is important so that spaces may be saved compactly and new user joining the replicated space can do so quickly.

In practice this means meshes and textures should be referred to by name in the replicated space, and fetched by each client
independently of joining the space. By fetching these large objects independently of the replicated space, clients can maintain locally cached copies which speeds joining the space. An XML description of the space also simplifies programatically generating space descriptions, and aids in integration with various search engine technologies.

Moreover, an XML-based space description also allows for the possibility of a croquet browser written in another language or based on a different code base. However, this implies changes to the rendering engine since we would be moving textures/mesh definitions outside the replicated space. QWAQ's forums have shown that this approach has many virtues. Ultimately we might want to use an extended version of Collada - but the first step would be to align the Open source and QWAQ code bases so we can read each other's world definitions.

- robust Jabber client: SSL TLS support ( OpenSSL plugin?)

This work can happen in the open source arena and is relatively independent of changes to space description formats. The current Jabber client does not support SSL transport level security and needs to - since most Jabber servers require SSL TLS. Supporting an open standard IM/Chat is a key for interoperability with the chat world, and ideally would allow cross world chat with other environments (such as Second Life) should those worlds decide to do the right thing and support a standards based chat protocol for inter world chatting. We also need this work so that we can advertise presence outside Croquet using an open standards-base approach.

- message router/timestamper: optional message router/timestamper as an Apache plugin?

The microserver is a message router/timestamper for sites that want a standalone message router to augment the croquet client built-in router. We can leverage the support that the apache server codebase has by providing an option to externalize the message router function.

This also opens the possibility of simplifying access control/authentication integration with existing enterprise AuthN/AuthZ
systems. By creating a microserver that plays in the apache space we can leverage existing Apache web server authentication/access control modules.

- plugin API for extending space definitions: various browsers will extend functionality of spaces by adding new features, we need a definition for how this happens

We expect that various browsers will extend functionality of spaces by adding new features. We need a standard way to describe these plugins that allows less well endowed clients to at least display a placeholder for content they cannot render and point to how to get the required extension. This is analogous to plugins for web pages.

Note that these plugins may affect both the replicated space -and- the non-replicated inside-the-helmet user interface of a croquet client.

- scripting for user-defined behaviors: Javascript, Lua, panels, roll-your-own, and all that jazz

If we have a common XML format for describing spaces we have half of what we need. The other half is a common way of describing user-created behaviors, so a scripting language - like lua or javascript - would allow for actions to be stored along with models and textures. This implies that browsers will all need to support the scripting language.

- avatar definitions: enabling Akbar 'n Jef's Avatar Hut

Users of social spaces care a lot about their representation in-world
- we need to converge on avatar standards so that each implementation of croquet is not re-inventing this particular wheel. That, and a good babyfur avatar should be a lifetime investment.

On/off world

Brandon Boyer at Boing Boing Offworld was kind enough to post a link to the Colony videos I made. You can see it here:

A Look Back At the Colony

Interoperability

I have been spending a large amount of time talking to people about interoperability in virtual worlds. One problem is defining what it means - and why it is important. From what I can tell, the main thing people are looking for is a way to easily traverse from one virtual world to another. It would be great to be able to jump through a portal from Second Life into Qwaq and back. We already support URLs as links between Qwaq spaces. Adding a Second Life island would be a bit tricky, but I think it could be done.

There is also mention of having one's avatar go along for the ride, but it turns out that this is not that important, and may not even be a good idea. One way to think about it is people already have multiple identities online. I have a work email address, personal email, and a number of random older email addresses that I still get mail from. I don't like mixing them, and I have different expectations for the kind of mail I get from them, and people have different expectations from me depending on whether it is a work or personal email. That doesn't even begin to address the difference in security requirements.

Avatars are context specific artifacts. My avatar in World of Warcraft makes no sense in my business world. An obfuscated name model like Second Life makes no sense in business either - good business practice is built upon a strong trust relationship. If I don't even know who you are I can't do business with you.

On the other hand, if you like how your avatar looks in world A, it would be nice to have a similar version in world B. I like having the same name for my email addresses at gmail and at Qwaq, even if my role in each is different.

Qwaq in WSJ

We were in the Wall Street Journal - with a picture! Check it out here:

Virtual World Gets Another Life

It includes an image of the new "Business Avatars" which have not been release yet, but look wonderful.

Alan Johnston - BBC

Click here to show your support for Alan.

Hydra!

Andreas Raab wrote:

In its ongoing commitment to Open Source, Qwaq has decided to release
the first multi-core capable Croquet VM under the MIT license.

Hydra VM is a virtual machine capable of running multiple Croquet images
side-by-side, therefore being able to effectively utilize multi-core
CPUs. Hydra VM is still in an early phase of development, but given the
(very successful) early results, Qwaq has decided to make it available
to general public in the hope that other people will help Igor to make
further progress in developing Hydra VM.

The offical release is available here:

http://www.qwaq.com/HydraVM

and contains the following files:

* HydraVM-bin.zip - A prebuilt Windows version of Hydra VM.
* HydraVM-src.zip - The (C) source tree for building Hydra VM.
* HydraVM-pkg.zip - The (Squeak) packages needed to build Hydra VM.

More Scripting

I am sure everyone has their own opinion about scripting inside of Croquet. Here are mine:

- The scripting we use should be a popular language. Javascript is the obvious choice. Lua gets high marks for coolness, but most people have never even heard of it. It would be great to include any language, but getting the first one to work is a big enough project.
- It needs to work INSIDE of the Island. That is, it should offer the exact same guarantees of determinism that Croquet Islands provide.
- It must utilize the same numerics package that we have added to Squeak/Croquet. (Otherwise the previous will fail.)
- It must be enhanced to support #future messages directly. You MUST NOT loop to simulate in Croquet. Bad bad bad.
- The interface for editing the scripting language must be INSIDE of the Island. In other words - extreme programming on steroids! Scripting is a form of communication. When we came up with the idea for Croquet the intent was not to have a virtual mall and hang out. It is intended to be a high bandwidth communication medium. This includes the ability to dynamically express a simulation as part of the conversation! Hence the expression itself is a part of the communication. The editing is part of the argument between the participants.

This is probably more important to me than others, but until this is available, it ain't Croquet.

Scripting

I have been spending a great deal of my time lately thinking about scripting issues. Most people are a bit wary of diving into Smalltalk to get things done. Of course, it is really a marvelous scripting language in many ways, but people tend to find it a bit difficult. I think the reason for this is the same reason Lisp is a bit difficult. Both Smalltalk and Lisp have extremely regular syntax structure. In Smalltalk, even the traditional control structures (if/then, while, for) are just normal object messages that look the same as any other object messages. Most other languages have "exceptional" syntax, in that they have a number of reserved key words, and often have specific non-regular syntax to support these "exceptions". This makes it easier to visually parse, as most developers also tend to format their code around this non-regular syntax. This is especially useful to new programmers, because they can use this as a way to understand the code they are looking at.

Smalltalk and Lisp programmer usually format their code in a way to hilight the flow of control as well, but since every line of code starts with an actual object followed by a message, even this is still harder to immediately recognize.

Scratch is beautiful visual scripting language developed by the Lifelong Kindergarten group at MIT where they have moved very strongly in the direction of hilighting these very same control structures by using multiple shaped and colored tiles. What is nice about this is it makes it very easy to understand the structure of a program at a glance, and the program itself is simply "assembled" like you might put Lego blocks together. Interestingly, Scratch is built on top of Squeak - a version of Smalltalk.

We have been looking at a number of scripting languages over the past year, and have even integrated Python directly into Qwaq Forums. We are also looking very closely at Javascript and Lua. In particular, I love Lua, as it really gives me a lot of the capabilities I miss in Smalltalk - functions are first class objects and it has full closure support. This allows for some very interesting capabilities in code. I have been saying that I was thinking about building Wicket in Python in the past, but I believe Lua would be a much better choice.

Qwaq + Intel = Collaborative Mirimar

Qwaq and Intel just announced that we will be collaborating to bring Mirimar technologies that were developed at Intel to market. This is exciting for a number of reasons. Mirimar is a beautiful and seamless interface with the users desktop, which will make Qwaq Forums even more of a compelling experience. And of course we get the opportunity to work directly with Intel and in particular with John David Miller, one of the principals behind Mirimar to develop and integrate this technology. JDM is definitely one of us - and we have had a lot of fun working with and learning from him over the last year. It will be fun to roll this product out the door.

Press release here:
Intel-Qwaq Press Release

Official video of Justin Rattner's keynote including a guest appearance by Greg Nuyens. This seems to require IE and a PC:
Intel Developer Forum Webcasts

This is just the video part - no slides, but seems to work everywhere:
Intel Developer Forum Video

Bank Teller Machines and 911

I just had a crazy idea and had to write it down somewhere. Why don't bank teller machines respond to 911? They have a numeric keypad, and their users are also a target for potential victimization. And they are everywhere. They also include video cameras. Knowing that a teller machine was also directly wired to the police might make criminals reconsider violent attacks near them. Of course if your pin number is 911x, there might be some problems, but I suspect these are easily changed. Nothing to do with Qwaq, Inc or Croquet... but so what?

My Internet2 Talk ... in Color

I participated in a panel at the Spring Internet2 members meeting and a video of it is available online. For those of you wanting to get a demo of Qwaq Forums - check it out. Beware, there is about 3-5 minutes of nothing happening at the beginning of the video. Don't give up. I am the first speaker, but it is well worth watching Sandra Kearney at IBM and Robert Gehorsam of Forterra Systems and the excellent questions at the end of our short presentations.

Go here: Internet2 VR Panel

The ICE Videos

ICE stands for Interactive Collaboration Environment. This is the real proto-Croquet architecture I built at Virtus. The ideas were strongly influenced by Apple's OpenDoc architecture and conversations with Alan Kay. There were two versions of this, one with some really neat recursive drag and drop capabilities. This system was collaborative from the start, including voice and video. The "avatars" were flying TVs with video images of the other users on them. The video was from some special cards that are long gone, so I could not show that in this demo. Once again, thanks to David Easter for providing the machine I used to record this demo. David also designed much of the component architecture that we built here. The second video is in some ways even more interesting than the first. We actually made the entire ICE system itself a component which meant that we could drag and drop ICE into a 3D window in the space. Early portals!

Enjoy it.

ICE Version 1

ICE Version 2

Croquet Road Map

A draft of the Croquet Road Map is now available here:
Go here: Croquet Road Map.

There are three critical items: Island Classes, Two Dimension Infrastructure, and Documentation. These are the essential elements of the next big Croquet release, which I will discuss a bit later.

The first item probably needs some elaboration. Island Classes are classes that are part of the replicated Island's definition. They can be edited like any other class, but only exist inside of a particular Island. The code can be reused only by copying the classes between Islands. This goes beyond a uni-class framework, turning Islands into complete encapsulated development environments. This may raise more questions than it answers, but it is a critical aspect of what we were after when we created Croquet - the ability to share even complex simulations between users in a protected space.

When worlds collide

Tue, 30 Jun 2009 16:03:38 -0500

Interesting juxtaposition between these two from overnight:A Rocketboom syndicated TV-babe declares our virtual worlds as one of three reasons for her to go to California(!) among the far-from-product stuff at Intel Research Day.Appalachian State ...

What's New?

Mon, 29 Jun 2009 00:08:14 -0500

People are often pretty good at walking into a room they are familiar with, and instantly knowing what has changed. That's pretty useful for 3D operations team rooms. But what if things have been “redecorated” — moved around for...

NOW they get it. NOW they don't.

Sun, 21 Jun 2009 12:56:10 -0500

I find two of Microsoft's current ad campaigns interesting. One asserts that computer technology is all about connecting people, particularly synchronously (as opposed to asynchronous stuff like email, file sharing, and wikis). If you replaced th...

QRLs are not SLurls but they play that role on the 'Net.

Sun, 14 Jun 2009 14:58:04 -0500

We've created ordinary http URLs that teleport you to places in-world in Qwaq Forums, Being programmers, we could not resist the pun of calling them QRLs. The most common uses today are:meet me here telling someone where to meet, in IM, ema...

Places, Everyone!

Sun, 7 Jun 2009 22:56:37 -0500

Related to the URL addressing concepts discussed here, there is the question of how to denote places within a 3D world. I really like having names for these.A typically engineering way to map out locations in a model is with coordinates. There...

Being Seen

Thu, 4 Jun 2009 15:14:00 -0500

I'd been wondering whether anyone on our company's Board of Directors knew who I was. I know a couple but it turns out most didn't. But just before the last board meeting I ran into a director that I'm sure I had never been introduced to. He said...

3D vs 2D for Legacy Applications

Tue, 2 Jun 2009 21:40:00 -0500

When Alan Kay's team at Xerox created the overlapping window user interface, they were working for a document company. Everything was organized around documents mimicking paper, sitting in folders except when being operated on by one application o...

Drum Machines

Sun, 31 May 2009 15:47:00 -0500

There weren't any effective drum machines when I was in high school. Except, of course for Neil Peart.Compare Animusic:

Being There

Sat, 30 May 2009 14:25:43 -0500

We've all seen the cartoons of people sitting next to each other in silence and texting each other. I just picked up my daughter from a concert where she did exactly that. At work, we meet for a few hours in-world at least twice a week. Usuall...

Goal!

Fri, 29 May 2009 12:03:00 -0500

How do we improve the breed of collaborative programming tools? Should we have spectator programming competitions on the Internet? (The people who like those things only watch for the crashes!) I don't think there's a good commercial driver ...