Instanceof Idea

So that's what happened to Wave

2011-07-20T22:38:00.003-04:00

I tried Wave, was unimpressed, but felt like it would follow the classic hype curve. At any rate, I'm working on my Masters of Science in Information Science at the School of Information and Library Science. It's a wonderful program, though challenging with family + full time job + music gig. I'm holding it together (but procrastinating on some homework right now).

I am interested in collaborative search and sense-making from back in the day at RENCI when I was looking at InfoMesa, and recent research in my summer class has me thinking about this again. Many aspects of collaborative search and sense-making were captured in the original intent of Wave. I never bought that it was a new form of communication, or that it was revolutionary in that respect. What I still think is that it has some aspects of a platform for collaborative search and sense making. I especially like how it can combine time-shifted asynchronous activities with synchronous activities. What's most compelling is to look at what Wave was doing as an application platform. Collaborative search and knowledge discovery could be a great one for Wave.

I guess I've been busy working, because I'd hardly noticed that Wave has gone over to Apache as 'Wave in a Box'. While it appears to be in early incubator stage (they probably don't know what to do with it either), it bears watching.

Working on releasing Jargon-core

2011-07-19T12:58:00.004-04:00

I'm working on a beta release of Jargon core, and all the fun involved in setting up the maven release plug-in for git and Nexus. Needless to say, I've made a few U-turns.

Here's my tip (I'm saving this for myself) on deleting the git tag to tackle some config errors:

http://nathanhoad.net/how-to-delete-a-remote-git-tag

Thanks Nathan!

Recent Jargon Updates

2011-07-16T09:41:00.003-04:00

There's a lot of activity on various types of interfaces, but I wanted to update folks on things at the API level, especially in the jargon-core API.

https://code.renci.org/gf/project/jargon/

This is late beta, we are working on moving to a schedule of releases, frankly, we need to work out maven and git and the maven release plug-in, there is a lot going on and we're trying to get that done.

Some highlights:

The big push has been to put a new public API out that is easier to use and maintain. I think this is shaping up (you can tell me whether that's so). There are plenty of capabilities that have never been exposed outside of the C API that are either in there, or planned.
There are lots of implementing and testing going on in several places, providing a nice amount of friction to help the API come along. As things settle in, we're starting to be able to shift perspective more to optimization. There are lots more places where buffering is implemented, and baby steps to looking at NIO. With the presence of the RENCI team, we're starting to stand up resources where we could start doing benchmarks to help guide optimization.
We will be working to pull the jargon-trunk and php code out of the main iRODS trunk into separate areas for the next release. The schedules are pretty tight, so that's still a tentative plan.
Several key community wish list items are under development, some things that may be of interest are below:

Configuration, setting options for operations, defaulting

With the 'clean code' practice of separating code from metadata in mind, there is a jargon.properties file now. This is where config info is being consolidated over time. The IRODSSession object is the place where expensive stuff like loading configuration properties, extensible metadata mappings, and such occurs. You can access the default jargon properties there, or override them. (So in Spring, you can wire in configured properties at startup for your web app, etc).

When you do transfers, you can call methods like below:

/**
* Put a file or a collection (recursively) to iRODS. This method allows
* registration of a TransferStatusCallbackListener that will
* provide callbacks about the status of the transfer suitable for progress
* monitoring
*
* @param sourceFile
*            File with the source directory or file.
* @param targetIrodsFile
*            {@link org.irods.jargon.core.pub.io.IRODSFile} with the target
*            iRODS file or collection.
* @param transferControlBlock
*            an optional
*            {@link org.irods.jargon.core.transfer.TransferControlBlock}
*            that provides a common object to communicate between the
*            object requesting the transfer, and the method performing the
*            transfer. This control block may contain a filter that can be
*            used to control restarts, and provides a way for the
*            requesting process to send a cancellation. This may be set to
*            null if not required.
* @throws JargonException
*/
void putOperation(
final File sourceFile,
final IRODSFile targetIrodsFile,
final TransferStatusCallbackListener transferStatusCallbackListener,
final TransferControlBlock transferControlBlock)
throws JargonException;

I wanted to point out the 'transferStatusCallbackListener'. You can implement this interface, pass it to the method, and get callbacks like initiation of operation, file transfer update, completion of operation. We are working on also providing a callback for 'messages', like 'starting parallel transfer', or 'computing checksum' so those can start surfacing in UI like iDrop. There are plans soon to provide optional 'intra-file' callbacks, so you could throw up a progress bar for what's going on inside of a file transfer. Look for that soon. Of course, you can leave that null if you don't care.

The 'transferControlBlock' is important. It is the communication pipeline between the thing calling the transfer, and the transfer itself. You can peek at aggregate numbers, set a cancel flag, etc. The point is, there is now also a transferOptions that can be set. The transfer options can include things like 'no parallel transfers', or 'max transfer threads', or buffer sizes, or things like the recently added 'compute and verify checksum'. You can either set a transfer options in that transfer control block, or leave it alone and defaults will be computed based on the settings in the jargon properties. The checksum validation is in there now (a community request), and the rerouting of gets/puts to the owning resource server should be there soon. The checksum and checksum validation functions were just added

Parallel Transfer Pools

Another community request in the optimization department was to set up a thread pool for parallel transfer threads. This has been done in a first implementation, but turned off by default. This should be handy in mid-tier apps, where you might want to cap the number of threads. More testing needs to be done, is it fixed? What are the time-outs, etc.

GSS/Kerberos, etc

There are threads here about security, GSS, etc. This is a high-priority item from the user group meeting, and this is next on the list of 'core' development. Folks who are really facile with GSS, Kerberos and the like who have comments and insight are invited to give input. I think once this part is in jargon-core, we can go to a full-on 'release'. The code is pretty solid, much more so than the older API, we're seeing, and will continue to see, performance gains, and it's much easier to use in mid-tier situations, or if you are 'Spring'-happy. Please let me know your experiences, comments, criticisms, and keep an eye out!

Another undocumented annoyance with testing Grails controllers

2011-01-03T19:02:00.002-05:00

I switched from rendering JSON in my previous post to using a gsp to format an HTML ul tag based on a model containing my list of results. This is because I find it easier when using JQuery to do my AJAX using HTML content. JQuery seems to natively prefer HTML to JSON, whereas Dojo seemd to run on JSON.

At any rate, I changed my controller to something like this:




def loadTree = {  
  def parent = params['dir']
  log.info "loading tree for parent path: ${parent}"
  def collectionAndDataObjectListAndSearchAO = irodsAccessObjectFactory.getCollectionAndDataObjectListAndSearchAO(irodsAccount)
  def collectionAndDataObjectList = collectionAndDataObjectListAndSearchAO.listDataObjectsAndCollectionsUnderPath(parent)
  log.debug("retrieved collectionAndDataObjectList: ${collectionAndDataObjectList}")
  render(view:"loadTree",model:[collectionAndDataObjectList:collectionAndDataObjectList, parent:parent])
 }

I altered my unit test, per the docs, to inspect the model and view. I attempted to get at the model entry for 'parent', which contained the parent dir, like this:


def parent = mav.model.parent

It turns out that that does not work anymore, instead, you need to interpose a reference to linkedHasMap like so:


void testBrowse() {
        controller.params.dir = "/"
        controller.irodsAccessObjectFactory = irodsAccessObjectFactory
        controller.irodsAccount = irodsAccount
        controller.loadTree()
        def mav = controller.modelAndView
        def name = mav.viewName
        assertNotNull("null mav", mav)
        assertEquals("view name should be loadTree", "loadTree", name)
        def parent = mav.model.linkedHashMap.parent
        assertEquals("parent dir not found", "/", parent)
 
    }

Now my Grails controller and test are working again. My next step is to create a decent JavaScript object that can bridge between methods in this BrowseController and a lazy-loadable JQuery JSTree. Maybe the next post can share some developments there.

Testing a Grails Controller - getting the $*&@ thing to work

2011-01-01T11:59:00.008-05:00

I wanted to post on two things. First, of general interest, I wanted to show how I got a working test on a Grails controller. Second, I wanted to highlight some of the new Jargon API and how it can fit into apps written using Groovy and Grails (this should also translate to Jython and JRuby, as well as other dynamic JVM languages).

There is lots of contradictory information on the web, even in the Grails docs, on testing Grails controllers. The biggest issues are understanding the ControllerUnitTestCase, and what it does and does not do.

First, here's a controller I'm developing that will back a JQuery JTree component. The first method will take a parent path name, and return a JSON representation of the iRODS file system for the parent path using some new Jargon methods that are meant to assist in Swing and JQuery tree development.



package org.irods.mydrop.controller

import org.springframework.security.core.context.SecurityContextHolder;
import org.irods.jargon.core.pub.*;
import org.irods.jargon.core.connection.*;
import org.irods.jargon.core.exception.*;
import grails.converters.*

/**
* Controller for browser functionality
* @author Mike Conway - DICE (www.irods.org)
*/

class BrowseController {

IRODSAccessObjectFactory irodsAccessObjectFactory
IRODSAccount irodsAccount

/**
* Interceptor grabs IRODSAccount from the SecurityContextHolder
*/
def beforeInterceptor = {
def irodsAuthentication = SecurityContextHolder.getContext().authentication

if (irodsAuthentication == null) {
 throw new JargonRuntimeException("no irodsAuthentication in security context!")
}

irodsAccount = irodsAuthentication.irodsAccount
log.debug("retrieved account for request: ${irodsAccount}")
}


/**
* Display initial browser
*/
def index = { }


/**
* Render the tree node data for the given parent.
* 
*  Requires param 'dir' from request to derive parent
*
*/
def loadTree = {
def parent = params['dir']
log.info "loading tree for parent path: ${parent}"
def collectionAndDataObjectListAndSearchAO = irodsAccessObjectFactory.getCollectionAndDataObjectListAndSearchAO(irodsAccount)
def collectionAndDataObjectList = collectionAndDataObjectListAndSearchAO.listDataObjectsAndCollectionsUnderPath(parent)
log.debug("retrieved collectionAndDataObjectList: ${collectionAndDataObjectList}")
render collectionAndDataObjectList as JSON

}

}

A few things to note. The new Jargon libraries are meant to provide simple POJO's that represent various domain objects within iRODS. There also is an idea of Access Objects, that roughly equate with the DAO pattern. iRODS is not a database, so the mapping is not the same, but to me, the idea of Access Objects for iRODS at least gives some comfort in familiarity. One access object I'm developing is meant to assist in tree depictions and searching on file and collection paths to support such elements in typical web and Swing GUI applications. We'll use that Access Object.

I've wired in my Spring security objects as described in an earlier post. My interceptor in my controller grabs the saved authentication token from the Spring Security layer and extracts the IRODSAccount object. In the loadTree method, this IRODSAccount object is used with a factory injected into my controller to get a CollectionAndDataObjectListAndSearchAO. My controller uses the method that takes a parent path, and returns JSON objects that represent iRODS files and collections under that parent path.

The approach taken in Jargon seems to map fairly easily into Grails apps, that's a good sign. This shows that quick development of arbitrary interfaces on top of iRODS will become easier with the newer Jargon libraries. Yay!

So, the problems really began with trying to test. First, let me share a working test, then I'll talk about some of the problems I ran into:



package org.irods.mydrop.controller


import grails.test.*
import java.util.Properties
import org.irods.jargon.core.connection.IRODSAccount
import org.irods.jargon.core.pub.IRODSAccessObjectFactory
import org.irods.jargon.core.pub.IRODSFileSystem;
import org.irods.jargon.core.pub.io.IRODSFile
import org.irods.jargon.core.query.CollectionAndDataObjectListingEntry
import org.irods.jargon.testutils.TestingPropertiesHelper
import org.irods.jargon.testutils.filemanip.FileGenerator
import org.irods.jargon.testutils.TestingPropertiesHelper
import org.irods.jargon.spring.security.IRODSAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import grails.converters.*



class BrowseControllerTests extends ControllerUnitTestCase {

IRODSAccessObjectFactory irodsAccessObjectFactory
IRODSAccount irodsAccount
Properties testingProperties
TestingPropertiesHelper testingPropertiesHelper
IRODSFileSystem irodsFileSystem


protected void setUp() {
super.setUp()
testingPropertiesHelper = new TestingPropertiesHelper()
testingProperties = testingPropertiesHelper.getTestProperties()
irodsAccount = testingPropertiesHelper.buildIRODSAccountFromTestProperties(testingProperties)
irodsFileSystem = IRODSFileSystem.instance()
irodsAccessObjectFactory = irodsFileSystem.getIRODSAccessObjectFactory()
def irodsAuthentication = new IRODSAuthenticationToken(irodsAccount)
SecurityContextHolder.getContext().authentication = irodsAuthentication
}

protected void tearDown() {
    super.tearDown()
}

void testBrowseNoLogin() {
controller.params.dir = "/"
controller.irodsAccessObjectFactory = irodsAccessObjectFactory
controller.irodsAccount = irodsAccount
controller.loadTree()
def controllerResponse = controller.response.contentAsString
def jsonResult = JSON.parse(controllerResponse)
assertNotNull("missing json result", jsonResult)

}
}

One of the first sources of confusion to me were documents that seemed to imply that running the grails command create-controller would put the relevant test in the integration tests directory. It didn't, it placed the test in the test/unit directory. Go figure. Maybe I'm missing something, but I'm taking what Grails does at it's word, so to speak. I tried moving the test to the integration test directory, but found that this resulted in the setup methods not running. Fine...I'll just forget this rabbit-hole.

Second, I had the hardest time setting up the params. My controller expects a request param of 'dir', with my test specifying the root '/' directory. I kept getting a "No such property: params" error when I tried doing the




controller.params.dir = "/"

test setup. It turns out that the ControllerUnitTestCase is wanting to wire in and extend your controller for you, creating a 'controller' variable automatically, with the test target controller defined by convention using the test name. So instead of creating my controller in a def using the 'new' keyword, I had to let the ControllerUnitTestCase do it for me.

I also ran into the issue of irodsAccount being null. The ControllerUnitTestCase does not run my interceptor for me. I was getting a null irodsAccount, and realized that I had to manually inject that variable in my test code.

Well, I was almost home, I kept getting a 'null' for my controller variable in my test case. Doh...I had plugged a bunch of code into setUp() in my test case, and I had to go back and add the super() call in my test case so that ControllerUnitTestCase could do it's magic on the controller variable. So now it works! There's still lots of refactoring I want to do in the controller, and I need to do things like parse and test the actual JSON response, but these are the details to work out now that I can get the stupid test cases to run.

Now that's progress...hopefully that will help you avoid some of my own frustrations. Here's to a New Year and new adventures in coding. I think Grails/Groovy feels as immature as most new dynamic scripting languages, but at the same time, I really feel like, combined with the new Jargon libraries, I'm well on my way to a rapid web development stack on top of iRODS. That's a good thing!

Grails and Spring Security

2010-12-29T12:28:00.008-05:00

I'm developing a personal 'cloud browser' application for iRODS based on my Jargon libraries. Previously, I had started looking at a set of Spring Security libraries that could be used in web apps, such that authentication and gathering of roles could be done against the iRODS security, using iRODS user groups for role based access.

My Spring Security library has a custom AuthenticationManager as well as a custom AuthenticationFilter and AuthenticationToken, as iRODS security uses not only user and password, but also zone, resource, host, and port. Because of the differences, I did not find the Spring Security Grails plug-in to be suitable. Besides, since I am already testing a set of custom libraries, I wanted to take advantage of the library and the XML wiring I had already created.

First, here's what my XML wiring looks like:

I had started to re-create this using Spring DSL in my resources.groovy file, but I was finding it difficult to translate (I'm still very new at Spring DSL, and it had more to do with just getting this done).

I added my mappings to the resources.xml file in my Grails app, and started things up just to see if Spring could wire this together. Knock me over with a feather but that worked! The one issue I had was a complaint about the Spring Security namespace, which was corrected by adding these items to my BuildConfig.groovy:

dependencies {
      // specify dependencies here under either 'build', 'compile', 'runtime', 'test' or 'provided' scopes eg.
      compile 'org.irods:jargon-core:0.0.3-SNAPSHOT'
      compile 'org.irods:jargon-security:0.0.1-SNAPSHOT'
      compile 'org.springframework.security:spring-security-core:3.0.5.RELEASE'
      compile 'org.springframework.security:spring-security-web:3.0.5.RELEASE'
      compile 'org.springframework.security:spring-security-config:3.0.5.RELEASE'
   
      //test 'org.irods:jargon-test:0.0.1-SNAPSHOT'
      // runtime 'mysql:mysql-connector-java:5.1.5'
  }

The key was actually the spring-security-config dependency.

Next, I started testing with a browser, only to find that the security was not being enforced. The missing step was to add the delegating filter proxy to my web.xml file. Well...what web.xml file? Like I said, I'm very new to Grails. It turns out that I needed to fire up the grails console and do a

grails install-templates

command. This adds templates for various artifacts to my project. Then it's a simple matter of editing the template web.xml file to add my delegating filter proxy mapping like so:

Now, I have not completed all the testing, but it does seem like I'm on the right path. I'll let you all know how it's going, but I think it'll work out.

Fedora 14 running full-screen on Virtual Box for Mac

2010-12-28T12:11:00.002-05:00

A big shout-out to www.sysprobs.com for this entry:

http://www.sysprobs.com/install-fedora-14-virtualbox-working-guest-additions

As I was having endless headaches mining the Google for tips on getting Fedora Linux 14 to run in full-screen mode on my Mac using VirtualBox. The missing pieces were some yum updates that had to be run, it's now running beautifully.

As is typical, I had to wade through several pages of hits that didn't solve the problem, hopefully this will boost the real solution.

Testing Groovy/Grails with Jargon

2010-12-12T08:09:00.003-05:00

I'm having a great time looking at Groovy and Grails as a rapid development environment for iRODS web interfaces via the new Jargon API I am developing.

Jargon is a pure Java API that encapsulates the iRODS server protocol. I am developing a new version, and one of the goals is to make it more usable in Spring-based apps. I have web projects to develop, and at the same time, I need to kick the tires on how Jargon works with dynamic scripting languages. So far, so good. I'm able to wire together some simple things, and utilize the Jargon libraries quite smoothly. Here's a little bit of wiring together of IRODSFileSystem using Spring DSL:

beans = {

irodsFileSystem(org.irods.jargon.core.pub.IRODSFileSystem) {
bean ->
bean.factoryMethod = "instance"
bean.singleton = true
}

irodsFileServiceWrapperService(mydrop.IrodsFileServiceWrapperService) {
irodsFileSystem = ref("irodsFileSystem")
}

irodsAuthenticationHelperService(mydrop.IRODSAuthenticationHelperService) {
irodsFileServiceWrapperService = ref("irodsFileServiceWrapperService")
}

}

Here's a bit of my hacked auth code (I need to see how to more formally wire in Spring Security with Grails:

IrodsFileServiceWrapperService irodsFileServiceWrapperService

/**
* Validate the user by logging into iRODS under the given credentials. Also retrieve the iRODS user groups for
* use in role-based access
* @param host
* @param port
* @param zone
* @param userName
* @param password
* @param resource
* @return
*/
def authenticate(String host, int port, String zone, String userName, String password, String resource) throws AuthenticationException {
def irodsAccount = IRODSAccount.instance(host, port, userName, password, resource, zone, "")
def irodsFileSystem = irodsFileServiceWrapperService.getIrodsFileSystem()
def irodsAccountAuthenticationManager = new IRODSAccountAuthenticationManager()
irodsAccountAuthenticationManager.setIrodsAccessObjectFactory irodsFileSystem.getIRODSAccessObjectFactory()
def irodsAuthentication = new IRODSAuthenticationToken(irodsAccount)
def irodsAuthenticationToken = irodsAccountAuthenticationManager.authenticate(irodsAuthentication)
SecurityContextHolder.getContext().setAuthentication(irodsAuthenticationToken);
}

I'm certain that this is not the most beautiful Grails code, but it's promising nevertheless.

Ruby on Rails on OSX 10.6

2010-11-13T16:02:00.002-05:00

A bit of frustration picking up Rails again on Mac. It seemed that I could not install rails via the

>gem install rails

command. I kept getting an exception like this:

ERROR: http://gems.rubyforge.org/ does not appear to be a repository

Well, I kept messing with gems.rubyforge.org, when it appear that the gems install on the mac was actually the problem. So I tried gem udpate --system, which, of course, failed because it tries to talk to gems.rubyforge.org.

Solution...go to http://rubygems.org/pages/download and manually download an updated gems..once I did this, gems, now properly configured with the gem repository, seems to work fine.

Back to Rails and Ruby after something of hiatus, delayed for several hours messing with gems. Tolerating frustration is a vital part of the developer's tool-set.

Peeking at iRODS XML packing instructions using icommands

2010-10-26T14:13:00.002-04:00

In working on the Jargon API, I'm often comparing the protocol operations with icommands. A helpful tip to turn on XML logging of the icommands you are executing:

type this at the command prompt before issuing your commands to set some environment variables:

export irodsProt=1; export irodsLogLevel=9;

Hover highlighting for drag and drop in a Swing JTree

2010-10-20T16:26:00.002-04:00

This was a pain in the butt. I am working on a file browser for iRODS that allows easy movement of data from local file system to iRODS resources. I'm implementing drag-and-drop gestures of all sorts, and the Swing JTree is pretty bare-bones, and lacked hover highlighting when dragging.

I found a very helpful thread here, pertaining to Swing JTables, but I found it easily adaptable to JTree, adding an alpha background color to the original code. In my subclass of JTree, in which I implement DropTargetListener, I added this

class {

private int highlightedRow = -1;
private Rectangle dirtyRegion = null;
private Color highlightColor = new Color(Color.BLUE.getRed(), Color.BLUE.getGreen(), Color.BLUE.getBlue(), 100);

...

@Override
public void dragOver(DropTargetDragEvent dtde) {

Point location = dtde.getLocation();
int closestRow = this.getClosestRowForLocation((int) location.getX(), (int) location.getY());
boolean highlighted = false;

Graphics g = getGraphics();

// row changed

if (highlightedRow != closestRow) {
if (null != dirtyRegion) {
paintImmediately(dirtyRegion);
}

for (int j = 0; j
if (closestRow == j) {

Rectangle firstRowRect = getRowBounds(closestRow);
this.dirtyRegion = firstRowRect;
g.setColor(highlightColor);

g.fillRect((int) dirtyRegion.getX(), (int) dirtyRegion.getY(), (int) dirtyRegion.getWidth(), (int) dirtyRegion.getHeight());
highlightedRow = closestRow;
}
}

}

...

@Override
public void dragExit(DropTargetEvent dte) {
if (null != dirtyRegion) {
paintImmediately(dirtyRegion);
}
}

}

}

Sun VirtualBox

2009-10-14T16:12:00.003-04:00

A few quick tips on Sun VirtualBox, their open virtualization platform. I'm runing a host with Windows XP, and I want to host some Linux servers for various purposes (more on that later).

Anyhow, a few quick hits. First, I installed VirtualBox, and immediately went for Fedora 11 from RedHat. Never could get Fedora to see the virtual drives I had created. I switched from Fedora 11 to the latest version of Ubuntu and it works fine.

Second, I was working on creating a shared folder on my Windows host that could be seen by the Linux box, using the provided command:

mount -t vboxsf [-o OPTIONS] sharename mountpoint

This was returning an error that it did not know about vboxsf as a type. I found that the 'missing' step was, once you install the 'Guest Additions', to issue the following command on your guest Linux server...

sudo /media/cdrom/VBoxLinuxAdditions-x86.run

This will let Ubuntu know about the vboxsf type.

I'm liking VirtualBox so far, it appears to be a useful tool in the toolbox.

Google Chrome OS?

2009-07-08T06:48:00.002-04:00

Since forever in web time the chatter has been about a new 'web OS' from Google. With the advent of rich internet applications in the form of GMail, Google Documents, Calendar, etc we're seeing the migration of information to the web, followed by the migration of the application to the web as a service.

Look at the information habits of people around you, we're relying on portable devices to access the bits of information relevant to time and space, and taking much smaller bites out of the apple..search for a gas station with the lowest price, find the number to a good plumber, send a text message to the baby-sitter. It only makes sense to re-think the relationship of all of these types of applications to the traditional desktop or laptop, or at least Google thinks so..

From Google...

So today, we're announcing a new project that's a natural extension of Google Chrome — the Google Chrome Operating System. It's our attempt to re-think what operating systems should be.

The Chrome OS is targeted first towards small notebooks (and probably tablets?) The post makes it clear that ChromeOS and Android are separate concerns, though a good deal of overlap is acknowledged. Certainly the services that would be consumed by Android are the same services that a typical 'notebook' computer would want, and many of us would treat a notebook and smart phone as interchangable for many tasks.

Intermittantly connected (a-la Gears) rich internet applications will be a key application delivery mode, whether in the form of widgets, or in full-blown browser-based applications. Combine this with a growing number of cloud services running on big grids, and maybe a web OS makes sense?

Note to self...

2009-06-08T20:23:00.005-04:00

I just wasted a few minutes on the obvious...Working on a JavaScript with Dojo, going through the excellent Mastering Dojo book from the Pragmatic Programmers.

I'm working on the script, and looking at this bit of code:

dojo.addOnLoad(function() {
dojo.connect(dojo.byId("qform"), "submit", function(e){
//stop default processing and propagation
//(we really don't want to submit the form)
dojo.stopEvent(e);

//erase any previous borders...
dojo.query("*", "fixture").style("border", "");

//set all elements found by the query to have a red border...
var query= dojo.byId("query").value;
dojo.query(query, "fixture").style("border", "2px solid red");
});
});

The error I'm getting is in the 'addOnLoad' method, with a "dojo not defined" error. Looking further up, I indeed have my dojo root specified.

See the problem? Of course not, because there is not a problem with this code. I was looking at the code (mismatched parens? missing semi-colon) when the issue was that I had retrieved the page by putting the file name in the browser, instead of the the http URL, so my code was not being served by my Apache server, therefore making it impossible to find the dojo code. Switch to an http url, and it works like a charm.

Someone is going to make the same mistake, and it's an object lesson (no pun intended) that sometimes there IS a simple solution, but that solution is often overlooked. I hope to save you a few minutes scratching your head.

Come into my office

2009-06-05T19:47:00.003-04:00

This is just a bit of fun....click here to read about my 'office' and visit it via the Unity browser plug-in! Good weekend to all.

While I'm pimping...here's my 'other life', my band Good Rocking Sam.

Updates

2009-06-01T08:06:00.005-04:00

Here's a quick rundown of projects, and some of the technologies I'm working with..

The Social Computing Room at RENCI has been busy...

I'm working on a new media projects that uses Max/MSP/Jitter to create MIDI music using tangible objects with embedded UbiSense tags as the 'instrument'.
I'm working on installing a very cool Flash/Flex based media project that uses all four surfaces of the Social Computing Room. This work has been installed elsewhere, so it's an adaptation. It really looks cool! This has allowed me to learn a bit more about Flash and Flex. As a programmer, I 'get' Flex much better than I get Flash.
I'm working on a virtual worlds project, utilizing a 360-degree Second Life client to stage mock trials.

I'm still looking at the InfoMesa technology demonstrator, and building an application based on WPF technology for the large display environment in the Social Computing Room.

I've been working mostly on the back-end, creating a services layer for storing metadata (the part I'm working on now) and for accessing arbitrary data stores based on the metadata. The metadata service layer is pluggable by interface, and my first implementation uses NHibernate to store metadata on a back end server. Once this done, that metadata layer can have pluggable modules for things like cloud databases.

For the pluggable data stores, the first stores will probably be a mounted file system, then a database, then an iRods repository. After this, in order, it will probably be http, ftp, then cloud databases.

The Social Computing Room will be integrating a multi-touch table later in the summer, and therefore I'm kicking some of the user interface stuff down the road. I want to allow folks to sit at the multi-touch table and interact with arbitrary data stores, manipulating on the touch table, and viewing on the 360-degree display. This would be soooooo cool.

Serious Games

I'm learning about the Unity3d game engine in my 'spare cycles'. We've ported a few Unity projects to the dome, and blogged about it.

Lots of things going on, as you can see. Main technologies I've worked with in the last two months:

.Net, C#, WPF
Java, including some Jetty work, and some socket stuff.
Max/MSP patches
Flex and Flash development
Wordpress and a bit of PHP
Quicktime Streaming Server and Quicktime Broadcaster
Unity3D
Second Life building and LSL scripting.

This is why I like my job...now I busted some solder joints Friday doing some testing, so I've got to play with a soldering iron.

Sitting on Top of the (virtual) world

2009-01-29T12:52:00.004-05:00

With apologies to Howling Wolf, Here's a pic we took in the Social Computing Room yesterday. It's showing an adaptation of the Second Life client that provides a 360-degree view of the virtual world. The development work on the SL client was done by a colleague, David Borland.

The idea is to embed the Social Computing Room within a larger virtual space, so that you can look out in every direction to see what is happening in the virtual world. In the pic below, I'm in the SCR looking at my avatar...

How about looking in? We have video cameras from all angles, so I thought about building a 'fish tank' from the SL perspective so that avatars can walk around the SCR and see inside of it. The bread and butter of two-way audio and video, along with text chat is the obvious next step. Here's a shot from SL looking into the Social Computing Room...

Right now it's just a bare media object, and one interesting question I have is what to build on the virtual side? Do I want to mirror the room, or perhaps the SCR could be sitting on the bottom of the sea? Once the basics are tackled, the SCR and the 4-channel Second Life client make for a unique research space. The SCR is well suited for installation of all sorts of sensors, robotics, and input devices. This is something of a side project, but I've noted how intrigued people are when they visit the SCR and see the first prototypes!

The world of mobile sensors

2009-01-28T16:14:00.004-05:00

I've been sharing around a white paper by Nokia that considers the mobile phone as a sensor. The key point:

As mobile device subscriptions pass the four billion mark, we’re looking at
the world’s most distributed and pervasive sensing instrument. Thanks to an increasing number of built-in sensors—ambient light, orientation, acoustical, video, velocity, GPS—each device can capture, classify, and transmit many types
of data with exceptional granularity. The perfect platform for sensing the world
is already in our hands.

Well, here's a cool example, from OpenSpime, WideNoise is an iPhone application that uses the microphone on the iPhone to measure environmental noise. These geo-tagged reports can then be used to create a noise map.

Rewind a bit, 'Spime' is an abbreviate of 'space' + 'time'. A Spime is defined by OpenSpime as: a technologically enabled device that interacts both with the physical and the digital environment, aware of its location and with an history about itself. OpenSpime is working to create a Jabber/XMPP protocol that allows Spimes to report information about themselves, and has a set of python libraries in development as a first project.

A handful of threads that really are woven together...

Renci featured in Endeavors Magazine

2009-01-16T13:06:00.001-05:00

Cool article on Renci and the power of visualization...in Endeavors Magazine right here.

InfoMesa and Databases in the Cloud - Windows Live

2009-01-15T08:38:00.000-05:00

InfoMesa is a technology demonstrator from Microsoft Life Sciences that I've blogged about previously. I've been working (as time permits) on two tracks.

First, I've forked the code to investigate how the interactive whiteboard/electronic research notebook would work in an environment like the Social Computing Room. I've already had some interesting results, and the product of that work is in actual use by researchers in day-to-day work. The main departure in this case is turning the interface 'inside out', essentially creating a 12,288x768 workspace, while migrating all of the other interface items into context menus. In the SCR port, there's more concern with laying out content around the room than having a free-flowing scrollable palate. Essentially, I'm trying to put this fork 'out there', and then asking researchers what sorts of tools they would like. I'm incrementally porting InfoMesa features to this environment as I can, and am especially keen on adding annotation features.

This brings me to the second track, which is looking at the 'cloud' as the source of data. In this way, InfoMesa becomes a 'browser' of sorts. The InfoMesa database becomes a link repository, a tagging service, and an annotation service. The whiteboards are composed of objects that may exist outside of the InfoMesa metadata repository. The data may be in a database, may be a resource on the web, identified by a URI, or may be stored in a cloud database, such as SQL Data Services in Microsoft Azure, or Amazon S3. The InfoMesa blog has some interesting demonstrations of porting the whiteboard metadata to Azure in the post InfoMesa and Databases in the Cloud - Windows Live.

I think the cloud data idea is useful, making whiteboards accessible anywhere. What I think is potentially more interesting is to think of InfoMesa as a resource browser and annotation platform, and looking at creating pluggable hooks in InfoMesa to be able to retrieve whiteboard objects from different locations, such as the above mentioned cloud data services. Questions to answer include designing such a pluggable architecture, laying out the metadata schema that would be able to store and properly access data in the cloud, and defining the security layer such that a whiteboard can acess data with proper security.

The ability to store and annotate data in these views has other interesting benefits, including 'wall-to-wall' collaboration. I imagine augmenting collaboration sessions with video conferencing between two visualization environments, where some ability to synchronize whiteboards brings remote parties together. I also am interested in the more pragmatic ability to allow a researcher to design a whiteboard that represents the agenda for a research group meeting at their desktop, and be able to walk up to a visualization wall, or an environment like the SCR, and have their data appear, ready to go. Think if this as a more fluid way of developing a presentation, where sequences of slides are less useful than a free-flowing group interaction with imagery, video, and other types of visual data.

You can see that the potential is endless. I'm trying to keep it focused on practical use, making working in the SCR a productive and fun experience.

Working on a blog/website for Renci@UNC

2009-01-07T10:46:00.000-05:00

I'm working on a Wordpress based website and blog for the Renci@UNC engagement center. I've added a Flickr photostream...well at least a start, which should be visible on my blog. I'm using a Wordpress plug-in (FlickrBox) to incorporate this into the new Renci@UNC site.

Lots of cool stuff to talk about, alas, a bit busy actually doing the stuff to blog about it, but will soon (New Year's resolution). Anyhow, back from the Holidays, and glad to be into it again!

Vid from Supercomputing 08

2008-12-04T11:15:00.000-05:00

Here's some Renci Vid from SC08, showing some of the technology in the Renci booth. As stated before, I'd love to put a touch table in as a centerpiece to the Social Computing Room, and have multi-touch applications that interact with the 360-degree viz display. This idea meshes well with the ideas demonstrated by InfoMesa.

Also cool to note is the HoloPanel that can be seen in the corner of the booth. A pair of these was used in the Social Computing Room as a part of the Spectacular Justice installation, and they were stunning!

All that said, really this is just to share some cool technology. I'm lucky to work with such smart and resourceful people at Renci.

Renci Multi-Touch blog

2008-11-17T06:52:00.001-05:00

Here's the multi-touch blog from Renci. There are two form factors that Renci is working with, a large multi-touch wall at Duke, and a horizontal touch-table at Europa.

My hope is that a touch-table will grace the Social Computer Room. A long-term vision would be to extend our Collage/InfoMesa ideas in the SCR, using the 360-degree display to provide visual real estate. Imagine a group working around a touch table, shooting images out to the 360-degree wall with gestures on the touch table.

Putting Google Earth into a WPF window

2008-11-13T09:39:00.000-05:00

This may end up being fruitless, but I was inspired by this multi-channel version of Microsoft Virtual Earth. It looks like they linked multiple version of Virtual Earth with different camera settings, and I wanted to try something similar with Google Earth for our Global Immersion dome. This four-projector rig needs a viewport and four camera views to work right. Can I create a full-screen app that has these four viewports, and have four synchronized version of Google Earth running? I don't know, but the first step was to see if I could create a WPF app that had Google Earth embedded in the WPF window. You can at least do that, and that's interesting in itself, because I can add a Google Earth widget to my InfoMesa/Collage experiments described here...

Anyhow, here's the window in all its (yawn) glory:

It was a bit of a slog to get it right, and I'll share the code that worked. First, I had to get Google Earth, which gives you this COM SDK. I did this using C#, Vis Studio 2008. I added a project ref to the COM Google Earth library, and created a class that extended HwndHost.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Interop;
using System.Runtime.InteropServices;
using EARTHLib;

namespace GeTest
{
class MyHwndHost : HwndHost
{

[DllImport("user32.dll")]
static extern int SetParent(int hWndChild, int hWndParent);
IApplicationGE iGeApp;

[DllImport("user32.dll", EntryPoint = "GetDC")]
public static extern IntPtr GetDC(IntPtr ptr);

[DllImport("user32.dll", EntryPoint = "GetWindowDC")]
public static extern IntPtr GetWindowDC(Int32 ptr);

[DllImport("user32.dll", EntryPoint = "IsChild")]
public static extern bool IsChild(int hWndParent, int hwnd);

[DllImport("user32.dll", EntryPoint = "ReleaseDC")]
public static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDc);

[DllImport("user32.dll", CharSet = CharSet.Auto)]
public extern static bool SetWindowPos(int hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

[DllImport("user32.dll", CharSet = CharSet.Auto)]
public static extern IntPtr PostMessage(int hWnd, int msg, int wParam, int lParam);

//PInvoke declarations
[DllImport("user32.dll", EntryPoint = "CreateWindowEx", CharSet = CharSet.Auto)]
internal static extern IntPtr CreateWindowEx(int dwExStyle,
string lpszClassName,
string lpszWindowName,
int style,
int x, int y,
int width, int height,
IntPtr hwndParent,
IntPtr hMenu,
IntPtr hInst,
[MarshalAs(UnmanagedType.AsAny)] object pvParam);

readonly IntPtr HWND_BOTTOM = new IntPtr(1);
readonly IntPtr HWND_NOTOPMOST = new IntPtr(-2);
readonly IntPtr HWND_TOP = new IntPtr(0);
readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
static readonly UInt32 SWP_NOSIZE = 1;
static readonly UInt32 SWP_NOMOVE = 2;
static readonly UInt32 SWP_NOZORDER = 4;
static readonly UInt32 SWP_NOREDRAW = 8;
static readonly UInt32 SWP_NOACTIVATE = 16;
static readonly UInt32 SWP_FRAMECHANGED = 32;
static readonly UInt32 SWP_SHOWWINDOW = 64;
static readonly UInt32 SWP_HIDEWINDOW = 128;
static readonly UInt32 SWP_NOCOPYBITS = 256;
static readonly UInt32 SWP_NOOWNERZORDER = 512;
static readonly UInt32 SWP_NOSENDCHANGING = 1024;
static readonly Int32 WM_CLOSE = 0xF060;
static readonly Int32 WM_QUIT = 0x0012;

private IntPtr GEHrender = (IntPtr)0;
private IntPtr GEParentHrender = (IntPtr)0;

internal const int
WS_CHILD = 0x40000000,
WS_VISIBLE = 0x10000000,
LBS_NOTIFY = 0x00000001,
HOST_ID = 0x00000002,
LISTBOX_ID = 0x00000001,
WS_VSCROLL = 0x00200000,
WS_BORDER = 0x00800000;

public ApplicationGEClass googleEarth;

protected override HandleRef BuildWindowCore(HandleRef hwndParent)
{

// start google earth
googleEarth = new ApplicationGEClass();

int ge = googleEarth.GetRenderHwnd();

IntPtr hwndControl = IntPtr.Zero;
IntPtr hwndHost = IntPtr.Zero;
int hostHeight = 200;
int hostWidth = 300;

// create a host window that is a child of this HwndHost. I'll plug this HwndHost class as a child of
// a border element in my WPF app,

hwndHost = CreateWindowEx(0, "static", "",
WS_CHILD | WS_VISIBLE,
0, 0,
hostHeight, hostWidth,
hwndParent.Handle,
(IntPtr)HOST_ID,
IntPtr.Zero,
0);

// set the parent of the Google Earth window to be the host I created here
int oldPar = SetParent(ge, (int) hwndHost);
// check to see if I'm now a child, for my own amusement
if (IsChild(hwndHost.ToInt32(), ge)) {
System.Console.WriteLine("now a child");
}

// return a ref to the hwndHost, which should now be the parent of the google earth window
return new HandleRef(this, hwndHost);
}

protected override void DestroyWindowCore(HandleRef hwnd)
{
throw new NotImplementedException();
}
}
}

The main window of my WPF app, in its constructor for the Window, just plugs this HwndHost as a child of a Border control:

public Window1()
{

InitializeComponent();
MyHwndHost hwndHost = new MyHwndHost();
border1.Child = hwndHost;

}

And you are off to the races! I found a lot of different approaches to this all over the web, but none of them seemed to work, as is often the case. Maybe this will work for you, or maybe it adds to the confusion.

UPDATE: can't run more than one Google Earth, so it's a bust, but still has use in my InfoMesa/Collage project. I wonder about Virtual Earth?

Video for Ubisense/MIDI demo

2008-11-12T14:50:00.001-05:00

Here's the video that was described in this post. The point of this experiment was to see if we could reasonably map carpet squares in the Social Computing Room to MIDI notes, and output those notes to the on-board MIDI implementation.

Oh well...off to a Games4Learning event...see ya there!

A bit about the Social Computing Room

2008-11-10T08:00:00.000-05:00

In the last blog entry, I had put down a spot to link to a description of the 'Social Computing Room', and realized that I didn't have one. So I wanted to fill in a few details and fix that link.

The Social Computing Room, (or SCR for short) is a visualization space at the Renci Engagement Center at UNC Chapel Hill. We're over near the hospital in the ITS-Manning building in Chapel Hill. It's one of three spaces, the other being the Showcase Dome (a 5-meter tilted Global Immersion dome), and Teleimmersion, which is a 4K (4 x HD resolution) stereo environment. We're working on some virtual tours for a new web site, so there should be some more info soon on those other spaces.

One of the primary features of the SCR is its 360-degree display. The room is essentially a 12,288x768 Windows desktop. (I've also tested a Mac in this environment, and it works as well). Here's a pic of the SCR...

The room has multiple cameras, wireless mics, multi-channel sound, 3D location tracking for people and objects, and is ultra-configurable (plenty of cat-6 for connecting things, Unistrut ceiling for adding new hardware). The room has so many possibilities that it gets difficult to keep up with all of the ideas. I think of it as a place where you can paint the walls with software, and make it into anything you want. There are currently a few emerging themes:

The SCR is a collaborative visualization space. The room seems especially suited for groups considering a lot of information, doing comparison, interperetation, and grouping. There is a lot of visual real estate, and the four-wall arrangement seems to lend itself to spatial organization of data. As groups use the space for this purpose, I'm trying to capture how they work, and what they need. The goal is to create a seemless experience for collaboration. This is the reason I've been interested in WPF, and the InfoMesa technology demonstrator, as covered in this previous post.
The SCR is a new media space. Its been used for art installations, and it has interesting possibilities for all sorts of interactive experiences, as illustrated by this recent experiment.
The SCR is a place for interacting with the virtual world. We're working on a Second Life client that would have a 360-degree perspective, so that we can embed the SCR inside of a larger virtual enviroment, enabling all sorts of new possibilities.

These are just a few of the areas I'm interested in. Each of the areas can be enhanced by the use of different types of sensors and robotics, and I've been started with Wiimotes, SunSpots, and the Ubisense location tracking hardware.

That's a bit about the SCR, it's a really fascinating environment, and if you are on the UNC campus, give me a shout out and I'll show you around!

Music and Media in the SCR

2008-11-07T14:48:00.001-05:00

UPDATE: delay on getting the video done, should be here by early this week...MC

Here's an interesting prototype that combines the Social Computing Room with Max/MSP/Jitter and UbiSense. Video will follow soon.

The Social Computing Room (described here) has many potential applications, and one intriguing use is as an 'interactive media space'. The idea is that 360-degree visuals, combined with various types of sensors, software, and robotics, can create new kinds of experiences. Two examples that I can point to include the 'Spectacular Justice' exhibit that occurred last winter, as well as student work with Max/MSP/Jitter.

In this case, a prototype was written that uses UbiSense, which provides location tracking in 3D through an active tag. A Max object was written in Java to take the UbiSense location data off of a multicast stream, and push it out into Max-land. A second Max object was created to take the x,y,z data from UbiSense, in meters, and convert it into numbers that match up to the carpet squares on the floor of the Social Computing Room. Given those two new objects, the 'pad' number of the carpet square can be mapped to a MIDI note, and sent out through the Max noteout object.

Here's a picture of a simple patch:

What I'm really trying to show are techniqes for interacting with music and video. I could see using objects in the room that can be arranged to create musical patterns using an arpegiator or a loop player, and this can be combined with video on all four walls. MIDI or other methods can simultaneously control lights and other electronics. You could create a human theramin by having two people move around the room in relation to each other.

It's also interesting to let several people move around in the SCR holding multiple tags, you can create semi-musical patterns by working as a group. It's a fun thing, but points to some interesting possibilities. I've also adapted a Wiimote in the same manner.

Adapting InfoMesa to the Social Computing Room

2008-10-28T07:57:00.001-04:00

InfoMesa is an interesting initiative by Sam Batterman at Microsoft Life Sciences...quoting from Sam's blog:

InfoMesa is a project to allow scientists to do more science and more discovery in a collaborative and data-rich environment. The metaphor that we have elected to use as the underlying fabric of the InfoMesa is a Whiteboard.

InfoMesa allows any kind of data or visualization to be added to the Whiteboard. Far from static, these tools are interactive, allowing data to be absorbed from data sources like Oracle, SQL Server, Excel Spreadsheets, XML or even Cloud-based web services. InfoMesa, when complete will support imagery, video, 2D connected models, 3D models (lit in a photo realistically manner), web searches, results from web service calls, Image Tile Maps, ScatterPlots, Sticky Notes, Ink Notes, Rich Annotations and Associations.

Check the blog link for screen shots, it's a really interesting application, as well as a nice example of the capabilities of WPF (Windows Presentation Foundation). As a died-in-the-wool Java and Ruby programmer, I don't necessarily fit the typical Microsoft bandwagon profile, but I am having quite good success leveraging the WPF framework for the challenging environment in our Social Computing Room, which is essentially a 12,288 x 768 desktop.

A bit of a rewind, the Social Computing Room is part of the Renci Engagement Center at UNC Chapel Hill. The SCR has a 360-degree visual display running on all four walls, with 12 projectors per wall. The relevant model we were already working on was a supporting environment for researchers working in collaborative groups, and considering LOTS of data at one time. The SCR is a great venue for approaching problems that fit the 'small multiples' mold.

One of my colleagues, Dave Borland, had created a prototype called 'Collage'. This prototype used OpenGL and C++ (including some nifty wxWidgets sleight of hand to allow OpenGL to render such a large visual application). Collage handled cool things like letting the mouse, and any images, wrap all the way around the room. Collage could also play videos, and we were looking at adding other capabilities. Another cool part of Collage was the ability to intelligently 'lay out' images. For example, it was a common activity to expand each image to size to one 'projector', avoiding any stitch lines between displays. We were also working on displaying metadata about the images on command, sorting data various ways, and generally assisting 'small multiple' visualization tasks.

The downside of Collage is that it was a bit hard to extend, requiring a lot of OpenGL and wxWidgets prestidigitation to add new features. There were further plans to add Wiimote integration for multi-user input, and the ability to assign functionality to each wall. E.g., have a magnification wall, where thumbnails that were dragged to the magnification wall would automatically size for comparison.

After seeing InfoMesa in prototype form, I realized that many of the ideas we had in Collage mapped nicely onto the InfoMesa concept, and InfoMesa really moved the ball down the field. The first question I had was whether WPF would support, in a performant manner, a 12,288x768 desktop, and I was pleasantly suprised! The thing I've been working on for the past couple of weeks is taking the InfoMesa code, and adapting it to cover the functionality we already had in the OpenGL Collage prototype. I've been concentrating on the visual interface so far, leaving persistance, annotation, and metadata for later work. Here's a short vid of the CollageWPF adaptation of InfoMesa:

I wanted to hit on a few of the 'features' we've added, some requested by researchers who are using the prototype:

InfoMesa is turned 'inside out', maximizing real estate. Wrapping controls and toolbars around the whole display doesn't work on a big wall, so I went with a right-click context menu. It would be cool for InfoMesa to expand full desktop or display the interface! Otherwise, it might be cool to concentrate on partitioning the application such that the host 'window' can be easily customized for various display types.
Ability to automatically lay out and size imagery, which I implemented by creating a SceneManager to describe the environment, and a LayoutManager that can be subclassed for various layouts. The first LayoutManager does a scale and position to get one image per projector. The idea is that SceneManagers could be created for other viz environments, such as a 3x3 viz wall, or a 4K high-def display.
I Started thinking about a base 'widget' that can be subclassed to create other tools. Here I've still got things to learn about InfoMesa! I also started thinking about how these subclassed widgets would keep and share metadata, and allow the host 'cavas', or 'Universe', to know its widgets, and be able to manipulate them for things like layouts.
I added a widget to display 'time series' images in a player. It will eventually work by synchronizing multiple 'time series' viewers so researchers can consider different model runs simultaneously. I also added a widget to digest a power point, break into images, and then lay out those images.
The original InfoMesa zooms the entire desktop. Researchers were really looking to scale individual images.
I added mouse-over tool tips to display image metadata.

There's a good rundown of the use cases for InfoMesa here, and I think they are spot on. I think there's some adaptation that will be needed to get InfoMesa to fit the SCR form factor, and there are several other viz environments that also can serve as test cases, so it should be interesting. I'd like for a researcher to be able to log in to an InfoMesa room, create a white board, provision it, then go into the SCR, log in there, and see the white board depicted and ready to roll. Another angle would be to have some sort of event model that would publish changes on one viz wall to render in another...wall-to-wall collaboration would be way cool!

More later....be sure to vote tomorrow. As a political junkie, I'm sure I'll be pretty tired looking on Wednesday morning.

InfoMesa

2008-10-03T13:37:00.001-04:00

This is cool, a huge, sharable electronic white-board and research notebook from Microsoft called InfoMesa. I'm interested in how this can integrate into our Social Computing Room

http://anirbanghoshscinno.spaces.live.com/

Blender -> Panda via Chicken, finally working

2008-06-27T15:21:00.000-04:00

Mad props to the poster on the Panda forums BrianInSuwon. I had wrestled with getting an animated Actor into Panda3D after creating it in Blender. I think part of my problem was that I was using the newest version of Blender, and using envelopes to warp the mesh that I was putting over my armatures.

I'm really not trying to be a 3D animator, rather learning the mechanics of the animation and art path to better understand game engine development. I'm picking up Blender while picking up Panda. There are alternative methods of doing bone animation in Blender, so you really do have to do it one certain way to get it to work. I won't repeat the instructions, rather link off to the forum post, but this does work using the Chicken exporter plug-in for Blender.

Panda3D in a Global Immersion Dome

2008-06-25T10:01:00.001-04:00

To the outside world (at least the four or five people that have visited my blog), the topics covered must appear seemingly random from week to week. Well, this week is no exception! I really like what I'm doing, because I never know what's around the next corner. Really, my experience is probably not all that new. It seems like deep knowledge of a narrow area has its place (e.g. the hot-shot Oracle DB administrator), but that doesn't seem to be the game anymore. Rather, the ultra-adaptable, multi-lingual (C, C++, Java, Python, Ruby, etc.) developer who can work in any environment or platform, multi-task, and turn on a dime, and work in multiple teams at once seems to be the profile. I'm not saying that I am the best example, but it's what I'm striving to be.

That said, I thought I'd pass along this tidbit from my latest adventure...

Serious gaming is a hot topic on campus. How can we utilize game engine platforms to create new tools for simulation, interactive visual applications, training, and learning? Marry this with unique assets such as an interactive dome, an ultra-high (4K) resolution stereo environment, and a cool 360-degree 'viz wall', and it gets even more interesting. Over the summer, my group is exploring this intersection of game engines, and unique environments, and reaching out to folks on campus to find like-minded 'explorers'.

The true topic of this post is getting Panda to work in our dome, which turned out to be fairly straight forward. The example I'm using is a bit 'hackey', because it reflects a lot of trial-and-error. Python is great for this fortunately. I'll try and annotate what did the trick, using the baked in Panda and scene you get with the download...

# our dome has a 2800x2100 display, create a window at the 0,0 origin with no borders like so...

from pandac.PandaModules import loadPrcFileData
loadPrcFileData("", """win-size 2800 2100
win-origin 0 0
undecorated 1""")

import direct.directbase.DirectStart
import math
from direct.task import Task
from direct.actor import Actor
from direct.interval.IntervalGlobal import *
from pandac.PandaModules import *

# create a function that sets up a camera to a display region, pointing a given direction
# note that we're essentially creating one borderless window divided into four equal regions.
# each region depicts a camera with a precise eye-point and aspect ratio.
#
# NOTE this geometry is particular to our dome

def createCamera(dispRegion, x, y, z):
camera=base.makeCamera(base.win,displayRegion=dispRegion)
camera.node().getLens().setViewHpr(x, y, z)
camera.node().getLens().setFov(112,86)
return camera

# set the default display region to inactive so we can remake it

dr = base.camNode.getDisplayRegion(0)
dr.setActive(0)

#settings for main cam, which we will not really be displaying. Actually, this code might be
# unnecessary!

base.camLens.setViewHpr(45.0, 52.5, 0)
base.camLens.setFov(112)

# set up my dome-friendly display regions to reflect the dome geometry

window = dr.getWindow()
dr1 = window.makeDisplayRegion(0, 0.5, 0, 0.5)
dr1.setSort(dr.getSort())
dr2 = window.makeDisplayRegion(0.5, 1, 0, 0.5)
dr2.setSort(dr2.getSort())
dr3 = window.makeDisplayRegion(0, 0.5, 0.5, 1)
dr3.setSort(dr3.getSort())
dr4 = window.makeDisplayRegion(0.5, 1, 0.5, 1)
dr4.setSort(dr4.getSort())

# create four cameras, one per region, with the dome geometry. Note that we're not using the
# base cam. I tried this at first, pointing the base cam at region 1. It worked, but it threw the
# geometry off for some reason. The fix was to create four cameras, parent them to the base
# cam, and off we go.

cam1 = createCamera((0, 0.5, 0, 0.5), 45.0, 52.5, 0)
dr1.setCamera(cam1)
cam2 = createCamera((0.5, 1, 0, 0.5), -45.0, 52.5, 0)
dr2.setCamera(cam2)
cam3 = createCamera((0, 0.5, 0.5, 1), 135.0, 52.5, 0)
dr3.setCamera(cam3)
cam4 = createCamera((0.5, 1, 0.5, 1), -135, 52.5, 0)
dr4.setCamera(cam4)

# loading some baked-in model

environ = loader.loadModel("models/environment")
environ.reparentTo(render)
environ.setScale(0.25,0.25,0.25)
environ.setPos(-8,42,0)

cam1.reparentTo(base.cam)
cam2.reparentTo(base.cam)
cam3.reparentTo(base.cam)
cam4.reparentTo(base.cam)

# rest of code follows...this works!

Techno-travels and HASTAC Part II

2008-05-09T12:21:00.000-04:00

In brief, here's a demo of a physical/virtual mashup. In this case, UbiSense tracking is used on individuals within a space called the Social Computing Room, and depicted within a virtual representation of the same space.

One can think of a ton of ways to take this sort of thing. There are many examples of using the virtual world as a control panel for real-world devices and sensors, such as the Eolus One project. How can this idea be applied to communication between people, for social applications, etc. What sort of person-to-person interactions between persons in the SCR and remote visitors are possible? I have this idea that virtual visitors would fly in and view the actual SCR from a video wall. Then they could fly through the wall (through the looking glass) to see and communicate with the virtual people as they are arranged in the room. A fun thing we'll using as a demo at HASTAC.

Techno-Travels and HASTAC Part I

2008-05-02T11:06:00.000-04:00

I'll be presenting at the HASTAC conference on May 24th at UCLA. The conference has a theme of 'TechnoTravels/TeleMobility: HASTAC in Motion". I'll quote the description of the theme:

This year’s theme is “techno-travels” and explores the multiple ways in which place, movement, borders, and identities are being renegotiated and remapped by new locative technologies. Featured projects will delve into mobility as a modality of knowledge and stake out new spaces for humanistic inquiry. How are border-crossings being re-conceptualized, experienced, and narrated in a world permeated by technologies of mobility? How is the geo-spatial web remapping physical geographies, location, and borderlands? How are digital cities interfacing with physical space? How do we move between virtual worlds? And what has become of sites of dwelling and stasis in a world saturated by techno-travels?

OK...so how do you take a bite out of that apple? In my case, the presentation is going to center on something called the 'Social Computing Room' (SCR), part of visualization center at UNC Chapel Hill. There are lots of different ways to approach the SCR. It's a visualization space for research, it's a canvas for art and new media projects, it's a classroom, a video conference center, a gaming and simulation environment, and it's a physical space that acts as a port between the physical world and the digital world. It's difficult when talking about interesting new ideas to avoid overstating the potential, but I'll try to use the SCR to talk about how physical and digital worlds converge, using the 'port' metaphor. Thinking about the SCR as a port can start by looking at a picture of the space. Now compare that picture with a capture of a virtual version, in this case within Second Life:

To me, the SCR is a port in the sense that it exists in both worlds, and the ongoing evolution of the space will explore the ways these two sides of the coin interact. Before I go there, perhaps a bit more about the HASTAC theme. In this installment, let's talk about borders in a larger sense, coming back to the SCR a bit down the road.

Techno-travels? Borders? Mobility? Borders are falling away in our networked world, this means the borders that exist between geographic places, and the borders between the physical and virtual world. The globe is a beehive of activity, and that activity can be comprehended in real time from any vantage point. A case in point are real time mashups between RSS feeds and Google Maps, such as flickrvision and twittervision. These mashups show uploads of photos to Flickr, and mapping of twitters around the globe. You can watch the action unfold from your desktop, no matter where you are. Borders between places start to disappear as you watch ordinary life unfold across the map, and from this perspective, the physical borders seem to mean less, like the theme song to that old kids show 'Big Blue Marble', if you want to date yourself. Sites like MySpace and Orkut have visitors from all over the world, as illustrated by this ComScore survey, and social networks don't seem to observe these borders either.

The term 'neogeography' was coined by Joab Jackson in National Geographic News, to describe the markup of the world by mashing up mapping with blogs. Sites such as Platial serve as an example of neogeography in action, essentially providing social bookmarking of places. Google Earth is being marked up as well...Using Google Earth and Google Street View, you can see and tag the whole world. Tools like Sketch-up allow you to add 3D models to Google Earth, such as this Manhattan view:

So we're marking up the globe, and moving beyond markup to include 3D modeling. Web2.0 and 'neogeography' add social networking too. At the outset, I also waived my hands a bit at the SCR by comparing real and virtual pictures of this 'port'. That's a bunch of different threads that can be tied together by including some of the observations in an excellent MIT Technology Review article called 'Second Earth'. In that article, Wade Roush looks at virtual worlds such as Second Life, and at Google Earth and asks, "As these two trends continue from opposite directions, it's natural to ask what will happen when Second Life and Google Earth, or services like them, actually meet." Instead of socially marking up the world, the crucial element is the ability to be present at the border between real and virtual, to recognize others who are inhabiting that place at that time, and to connect, communicate, and share experiences in those places. This gets to how I would define the SCR as a port.

The drawback to starting out with this 'Second Earth' model is that it limits the terrain to a recognizable spatial point. While a real place sometimes can serve as a point of reference in the virtual world, that also unnecessarily constrains the meaning. What is an art exhibit? What is a scientific visualization? What is any collection of information? As naturally as we mark up the world, we're also marking up the web, collaborating, and experiencing media in a continuous two-way conversation..that's a lot of what Web2.0 is supposed to be about. How can we create the same joint experience, where we're all present together as our real or virtual selves sharing a common experience? That to me is the central goal of 'techno-travels', and perhaps expands a bit on the idea of border crossing.

Anyhow, I'm trying to come up with my HASTAC presentation, and thinking aloud while I do it.

Hands-free control of Second Life

2008-04-15T08:12:00.000-04:00

Cool video, though this interaction style still seems a bit awkward. I think the more interesting idea is the capture of gestures, which would be great for speaking to a group via an avatar, for example.

video here...

NetBeans 6.0.1 running like a pig...here's how I fixed it

2008-04-14T12:58:00.001-04:00

Netbeans 6.0.1 was running like a pig on my ThinkPad T60p. I did a bit of poking around, and found this set of config changes quite helpful, so I'll pass them along:

This is in my netbeans.conf, which should be under Program Files/NetBeans 6.0.1/etc on Windows. The critical change was the memory config:
netbeans_default_options="-J-Dcom.sun.aas.installRoot=\"C:\Program Files\glassfish-v2ur1\" -J-client -J-Xss2m -J-Xms32m -J-XX:PermSize=32m -J-XX:MaxPermSize=200m -J-Xverify:none -J-Dapple.laf.useScreenMenuBar=true"

Now NetBeans is running quite well. I'm hacking some Sun code samples to get data from the accelerometer to build a prototype air mouse. This isn't a standard mouse, but rather a way for multiple users to manipulate visualizations in the Social Computing Room. For grins, here's a shot of the space...

Note to Self

2008-04-10T14:59:00.000-04:00

I knew this, forget where I wrote it down, so I'll memorialize it here. I need to add some files to a SunSPOT project (in this case a desktop client), but couldn't remember the property in the ANT script to point to additional classpath entries...viola!

main.class=org.sunspotworld.demo.TelemetryFrame
#main.args=COM1
#port=COM1
user.classpath=lib/log4j-1.2.15.jar

Of course, now I'll forget that I stuck it in my blog. I'm looking at using the spots to create a multi-user input interface to a 360 degree visualization environment (our Social Computing Room), at least as a proof-of-concept.

Android and Agents

2008-03-26T16:09:00.000-04:00

I am able to revive my interest in agent computing a bit with a few projects, especially the development of a Social Computing Room on the UNC-Chapel Hill campus. The whole smart space, ambient computing thing really plays into where I see the web evolving...that is, an always connected web of people and things, with a continuous flow of information shaped by location, presence, situation, and the filtering effects of social networks.

Agents to me are the perfect interface between myself, my devices, my environment, and others around me. Agents can also play a part in mediating between my 'personal cloud', and the larger web. This mediation is two way...I may be life-blogging, sending real-time media, location reports, etc. I may also be watching for events, conditions, or proximity.

Anyhow, I am looking at setting up some agents to automate things in the Social Computing Room, so I popped out to the JADE site to see if I had the latest version, to find that they are working on a JADE agent toolkit for the Anderoid platform:

Version 1.0 of JADE-ANDROID, a software package that allows developing agent oriented applications based on JADE for the ANDROID platform, has been released. Android is the software stack for mobile devices including the operating system released by the Open Handset Alliance in November 2007. The possibility of combining the expressiveness of FIPA communication supported by JADE agents with the power of the ANDROID platform brings, in our opinion, a strong value in the development of innovative applications based on social models and peer-to-peer paradigms. See the JADE-ANDROID guide for more details

That looks really interesting, note their (tilab's) own observation about the relation of Android to social network enabled, peer-to-peer applications.

Incidentally, I note that I have crossed the 100th blog post line, so w00t!

Breaking news, Santa Fe blog covers Hillsborough blues jam

2008-03-14T09:59:00.000-04:00

This is indeed a small world. Ran into a sax player at the Bayou blues jam the other nite, turns out he's really from Santa Fe. His blog covers the jam at the Tin Star Cafe, but since he was in town for a project, here's a few shots and sounds from the last Bayou jam.

Play with a SunSpot without buying a developer kit

2008-03-03T15:46:00.001-05:00

Sun has released, in beta, an SDK that lets you code and run on an emulated SunSpot. Take your mobile Java experience in a new direction, and start learning about sensors!

http://blogs.sun.com/davidgs/entry/beta_starts

Cloud Computing and MSoft

2008-03-03T15:39:00.001-05:00

Speculation here and there about Microsoft versus Google in the emerging Cloud Computing Space from Nicholas Carr.

Getting a Ubisense CellData schema

2008-02-26T13:17:00.001-05:00

I posted this on the Ubisense forum...I'm running into many quandries about getting at different parts of the Ubisense architecture. I'm trying to build a service to age out Ubisense tags. The issue is that Ubisense 'remembers' the last sensed location of a tag. This makes sense when the tag is on a pallet in a warehouse, but causes a problem detecting when Elvis has left the building, in other words, when a person walks out of range of the sensors, he's still 'in the building'. This can cause issues depending on the application.

I am working on code based on this forum exchange..., and it seems to be working, though I'm getting sporadic exceptions:

System.NullReferenceException was unhandled
Message="Object reference not set to an instance of an object."
Source="UbisensePlatform"
StackTrace:
at UPrivate.au.a(Byte[] A_0, EndPoint& A_1)
at UPrivate.am.j()
at UPrivate.am.k()
at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
at System.Threading.ThreadHelper.ThreadStart()

I think this might be for some underlying thread collision, or a subtle bug in my own code, so I'm trying to add additional instrumentation to my code. The current code is using the multiCell and RemoveObjectLocation. I am still working to debug that, but at the same time, I'm looking at addressing the CellData schema directly, using the remove_object method. I want to see if this clears up the problem.

I'm also doing burn-in testing of the code, right now there's a robot running around the Social Computing Room carrying around a few Ubisense tags to drive the system...quite fun!

Sun Worldwide Education and Research Conference

2008-02-25T15:05:00.000-05:00

Here's an item that I'll probably check on this week...

Sun is moving fast on many fronts in 3D worlds - but
focusing on education. I hear they will have an
important announcement this week at their Worldwide
Education & Research Conference in SF:
http://www.events-at-sun.com/wwerc08/agenda.html

The agenda shows SUN Founder Scott McNealy speaking
wedged between the Immersive Education Forum and Lunch
the second day. I'm GUESSING that this placement is
intentional and hints that Sun has BIG news for
educators interested in immersive environments.

I played a bit with MPK20 (the Sun virtual environment).  It still has limited features, but it's open, and among the ones to watch, along with Croquet.  I may put up the feed in the Social Computing Room as availability permits, if anyone is interested in viewing it there, let me know.

Other than that, I'm wrestling a bit with UbiSense again!

Back to better habits

2008-02-13T21:53:00.000-05:00

I've neglected the blog, but trying to do better.

It has been a busy few months, largely spent putting together talks and demonstrations of the Social Computing Room, as well as the other spaces in the RENCI UNC Chapel Hill Engagement Center.

I'm into a lot of different things right now, which I'll describe in greater detail later. I'm:

Working more with UbiSense, which is a real-time 3D location sensing system. I've been concerned with bridging UbiSense using their .Net API to something called VRPN, which is an abstraction layer developed in the Computer Science department at UNC Chapel Hill. Eventually, we'll have a full-blown UbiSense server implementation. I'm working on handling button press signals from the tags right now, having some C# fits.
I began working on a tag ageing service for UbiSense, and ran into some code on the UbiSense forum that got me started (the UbiSense forum has been very helpful).
I've been learning OpenGL and GLUT, which I'll need as we develop new applications for the Social Computing Room.
Between VRPN and OpenGL, I'm having to use C++, which I've dabbled with in the past. It's not been my language of choice in the past, but it's becoming more useful.

Geez, that's enough for now.

Rails to the rescue

2007-12-08T11:31:00.000-05:00

It's good to keep the tools in your box sharp, I'm happy I've been messing with Rails on my own, because I need to knock out a prototype for work really quickly, Rails to the rescue!

A couple notes, NetBeans 6.0 is out, and I highly recommend it as your Rails development environment. I took a few minutes to switch to the new IDE, and it's very smooth. Alas, when I switched, I was having a very hard time getting plug-ins, and getting Rails to upgrade via Gems. I was receiving weird buffer errors. Google to the rescue, there was a simple fix that involved upgrading gems..just run this command:

gem update --system

and you should be in business...thanks to the DRY blog for the heads up! I'm also incorporating the WillPaginate plug-in in this round, and I've got to mash-up with Google maps. I did find a gem for Google maps, we'll see how far I get, but I'll post any findings..

Updates:

Apparently, will_paginate returns nil if your collection is smaller than the per-page. I was having a problem where I was returning an array of results for my 'position log', and it would not show up in the form where I had used

<%=will_paginate @obs_log %>

I'm not sure why, but here's the code for will_paginate..

# Renders Digg-style pagination. (We know you wanna!)
# Returns nil if there is only one page in total (can't paginate that).
#

def will_paginate(entries = @entries, options = {})
#total_pages =

if entries.page_count > 1
renderer = WillPaginate::LinkRenderer.new entries, options, self
links = renderer.items

content_tag :div, links, renderer.html_options
end
end

So this really does me no good, I'm sure I'm missing something obvious, but it should at least render the collection without the paging cruft. I'm just in too much of a hurry, but this was frustrating. I punted and just showed the last 30 or so with a :limit in my find_all.

I want to present a REST-ful interface for my app to accept data from a mobile with a GPS, I ran across this RailsCast on REST, which seems useful...

will paginate

2007-12-03T19:32:00.000-05:00

I've been working on a Rails app as a sort of hobby, it's for a site that I'm prototyping for fun, and we'll see where it goes. I've been off and on, depending on the home schedule, but having a concrete goal helps in my effort to keep my chops up. My areas of focus right now are Ruby, Rails, AJAX, JavaScript (with the Dojo toolkit), as well as CSS and design (never my strong suit). The things I work on lately are quite fun and challenging, but have taken me away from heads-down web app coding for quite a while.

Anyhow, working with the project, pagination turns out to be deprecated in Rails. I grabbed the new plug-in, classic_pagination, but the first thing I got is a notice that it's dead code, and I should move to WillPaginate. I love working with Rails, but the capricious nature of open source does have its drawbacks! Anyhow, I'm working with it, it looks nice. I found a quick jump-start on a RailsCast episode dedicated to pagination, linked here. RailsCast is a fine resource, and I highly recommend it.

One thing I would point out, and something that I'm still working to change, is to wake up to the fact that Rails and Ruby let you pop open a console and work with your code while you code. Try things out, see what responses you get, and if it looks good, copy it into your codebase. As a Java monkey, this is still a foreign mode of operation. The point is, if you're used to coding Java like I am, get used to having that console open, and monkey with your code! Check out the RailsCast, and give WillPaginate a try.

Taking the Social Web into the virtual world

2007-12-03T12:23:00.001-05:00

Here's an interesting article on IBM's efforts to blend social software, identity, and the virtual world through Lotus.

IBM Lotus programmers and engineers from IBM's research groups are currently working on ways to employ virtual reality technologies with Lotus Connections social computing software, said Jeff Schick, vice president of social computing for IBM.

I heard someone describe the 3D web by saying 'people are back', and I think this is the true strength of environments like Second Life. It's not about the graphics or a particular virtual space, it's about the people and experiences that are available. Maintaining and monitoring a social network is Web2.0, the 3D web is about being present with friends and peers in meaningful ways, through virtual experiences.

Building the 'web of things' means breaking some eggs

2007-11-29T12:36:00.000-05:00

I've been writing a lot about the 3D web lately, and I'm still pretty jazzed about what I've seen. Part of the appeal is the way that environments like Second Life serve as a metaphor for the merging of the physical and virtual worlds that is taking place all around us.

Anyhow, way back in the day, I was writing here about the next web, or Web3.0, or whatever you want to call it. Back in those old days, about 12 months ago, I was really thinking more about the new web, and the mobile web, like in this dusty old post. Someone had already fronted Mobile2.0 as a variant of Web3.0, in the confusing cloud of infotech talking heads.

Anyhow, one barrier to 'Mobile2.0' is the fact that networks and devices can't be ubiquitous if you can't get your cell phone to run an app or use the network you want, witness the entire iPhone hacking phenomenon. The subtext of the whole Google Android platform seems to be an attempt to smash through the walled gardens that are your typical telecom, witness the mission of the Open Handset Alliance. Anyhow, the actions of Google, and the recent announcement by Verizon that they are going to open their platform to any app and any service hint at the cracks that are appearing in the walled gardens. Does this hint at a new wave of innovation driven by the availability of an open platform? I'd think so, but at any rate, changes in the mobile space are coming, and they'll contribute to the next 'version' of the web!

Virtual SunSPOT controlled by a real SunSPOT

2007-11-19T10:58:00.001-05:00

Pardon the zapruder-like quality to this film, but this shows the hack I mentioned in my last post. I'm in SecondLife, controlling a virtual SunSPOT from a real one. In this case, tapping into the 3D accellerometer to pick up the xyz rotation, sending it through my framework to rotate the virtual one. It's a bit laggy, and not 100 percent there, but enough to get the idea.

If I ever find the time, the next cool example would be to implement the ectoplasmic bouncing ball demo using one real and one virtual SPOT. Anyhow, it works. The point really is to learn about the SPOT, and why not do something interesting while testing them...?

SunSPOTS talk and demo today at Sitterson

2007-11-15T07:53:00.000-05:00

Paul Jones sent out this note, and I'll be attending for sure:

About SunSPOTS http://www.sunspotworld.com/

Where: Sitterson 014 When: Thursday November 15th at 3:30
Who: A member from the Sun Labs, David Simmons http://blogs.sun.com/davidgs
More:

David has hands-on experience in building applications for SunSPOTs and was instrumental in its design and development, will be on hand to offer his insight into this amazing product. http://www.sunspotworld.com/

The SunSPOT (Small Programmable Object Technology) was developed in the Sun Labs and represents the future of embedded systems. Already used throughout academia, students and professors alike are finding new and interesting uses for SunSPOTs. Each SunSPOT comes equipped with a processor, memory, eight external tri-color LEDs, light sensors, temperature sensors, an accelerometer, and several digital/analog inputs and outputs; offering up seemingly countless practical uses.

At its core, a SunSPOT is an embedded system. But, unlike other embedded systems that must be programmed using a low-level language such as assembly or C, SunSPOT applications are developed in Java. By allowing Java applications to be uploaded and run on an internal Java Virtual Machine, Sun is not only opening up SunSPOTs to more users than many other embedded systems, it is also leaving the final function of each SunSPOT up to the end user. By following a simple API with which to interface the SunSPOT, developers nationwide have created unique uses for SunSPOTs - everything from animal research to rocket testing and much more!

I'm currently working with the SunSPOT developers kit, and have been going through (and hacking on) the demo apps. One of the first things I am trying is to tap into the 3D accellerometer. I took the telemetry example and added tilt to the packets coming off the SunSPOT, and have that available on the host. At the same time I've created a virtual SunSPOT in Second Life, and have scripted that to mirror the pitch, yaw, and roll coming into the LSL script. Just a few more tweaks, and the virtual SunSPOT will be controllable from a real one. This has been done before, but not to Second Life. The lag will probably be pretty bad, but I want to explore how multiple SunSPOTS, used by different people in an immersive environment, can create cool experiences.

Anyway, here's a shot of the virtual SunSPOT, when I get it hooked up, I'll shoot a video. I might have it by this afternoon, if the creek don't rise. Anyhow, see you all at the talk this afternoon!

My good deed for today - UdpClient in C# joining a multicast group

2007-11-13T08:58:00.000-05:00

Why are simple things so difficult! I spent a couple hours banging my head against the wall on this one. All I wanted to do was push out multicast UDP packets and pick them up from a C# program. The UdpClient is not very well documented, and the examples I found didn't work. So simply, this is what I had to do, marked in red. Now this works!

I hope I saved someone a minor headache.

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;

namespace UbiSenseUdpClientTest
{
class UbiSenseUdpListener
{
private static readonly IPAddress GroupAddress =
IPAddress.Parse("224.237.248.237");
private const int GroupPort = 64555;

private static void StartListener()
{
bool done = false;

UdpClient listener = new UdpClient(GroupPort); <- even though the samples show the noargs constructor for UdpClient, you must specify the port you are going to use if you want to receive multicast packets
IPEndPoint groupEP = new IPEndPoint(GroupAddress, GroupPort);

try
{
listener.JoinMulticastGroup(GroupAddress);
//listener.Connect(groupEP); <--- even thought the MSDN examples say to connect, don't connect before you receive, or you will sit and block at the receive below 'waiting for broadcast' below

while (!done)
{
Console.WriteLine("Waiting for broadcast");
byte[] bytes = listener.Receive(ref groupEP);

Console.WriteLine("Received broadcast from {0} :\n {1}\n",
groupEP.ToString(),
Encoding.ASCII.GetString(bytes, 0, bytes.Length));
}

listener.Close();

}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.ReadLine();
}

}

static void Main(string[] args)
{
StartListener();
}
}
}

Turning Turing Around

2007-10-11T13:38:00.000-04:00

I was reading Irving Wladawsky-Berger's blog today when I happened upon this wonderful observation..

I was reminded of the Turing Test recently, as I have been watching the huge progress we are making in social networks, virtual worlds and personal robots. Our objective in these applications can perhaps be viewed as the flip side of the Turing Test. We are leveraging technology to enable real people to infuse virtual objects - avatars, personal robots, etc - with intelligence, - as opposed to leveraging technology to enable machines and software to behave as if they are intelligent.

What intrigues me so much about virtual worlds like Second Life is this ability of avatar-based virtual spaces to allow you to push through the barrier, and cross over. How's that for a bunch of meta-physical BS! This is a different aim then something like Looking Glass, which is trying to apply a 3D metaphor to a 2D interaction...it's about stepping through to live with the data, or the sensors, or the other distant collaborators. As the real world becomes more inhabited by pervasive computing, it only seems natural that we go and visit the virtual on its own turf. One wonders about the definition of an application interface in the future. As machines grow smarter, perhaps we'll pop into the 'living room' of our personal agent to have a chat.

At any rate, there are a couple of fun things I'll be looking at in the near future that can tie in to these ideas. First, the idea of pervasive, wireless sensors everywhere. I'm waiting for a SunSpot Developers Kit, and there will be some sensor applications coming down the pike that could involve these extremely cool sensors. The fact that they use Java is a plus in my book. Needless to say, I'll be brushing up on my J2ME.

The next thing I see coming down the pike is real time location tracking, using the UbiSense platform. This is being leveraged for an intriguing space called a Social Computing Room, and has all sorts of potential uses. Here, I'm going to be doing some .Net programming.

Like the blog quote above, I've had a unique chance to push the physical into the virtual, and with the mentioned projects, there's a chance to work in the other direction. Where these meet is getting to be a pretty interesting space!

Science 2.0 talk on Friday

2007-10-03T09:14:00.000-04:00

I'm going!

Center for the Digital Libraries (CRADLE) presents

Speaker: Bora Zivkovic, the Online Community Manager at PLoS ONE (Public Library of Science)
Date: Friday, Oct 5
Time: 12:00-1:00pm
Location: Manning Hall, Room 208

Title: Science 2.0

Abstract:
The development of the Web has provided new ways for doing science, publishing and communicating science, networking within a scientific community, and teaching science. Blogs and wikis, existing social networking sites (e.g, Facebook), new science networking sites, Open Access Publishing and Open Notebook Science are just some of the many ways that scientists, students and interested laypeople are starting to change the way science (communication) is done, connected, used and archived and the future is difficult to predict - which does not stop us from speculating, which is the fun part, so let’s speculate!

Why Delete?

2007-09-28T08:18:00.000-04:00

Yesterday, I attended a discussion at the Wilson Library posing the question...Storage is Cheap: Why Select? Here's the premise:

Storage media for digital information are extremely cheap and getting
exponentially cheaper over time. The price of a terabyte of hard drive
space is a few hundred dollars, and in a decade it will be less than a
dollar. The cost of the expertise of well-trained information
professionals, on the other hand, is quite high and likely to increase
over time. So shouldn't we stop worrying about selection and just capture
and keep as much material as possible?

There are some drawbacks to keeping everything, including the cost of storage, and maintenance (file formats and media change, for example, moral and ethical questions (do I want this propaganda or hate speech to be available to the public), and impacts of preserving institutional records on liability.

The main point of contention was the value of selection, where the archivist's choice of what to preserve is in itself a valuable data point. In essence, the archivist is applying the values and understanding of material at the time of selection, which can preserve the context of a collection for future viewers. Another key point is that, even if it's preserved, it's not findable. A Google search that returns 5000 hits is great, but if the item shows up as hit 4999, it's not findable.

Fine, but I came away thinking that the game really has changed, and we're relying too much on the present to see how the future is developing. Paul Jones really hit the key point. It's preserved, it is not going away, even if you think you have deleted it...deal with it. There are backups, things leak to the web, or are documented through other channels.

I wonder how much impact an individual archive can have on our understanding of an event, time, or place in the read/write web era! An archive/archivist seems like a throwback idea. This relates to Paul's point, but I see the future of archives as distributed. Storage will be cheap enough to keep everything, search algorithms will improve, and the cost of preserving media will continue to decline (but free the formats!). We will throw the data up on the web in widely distributed formats, and the power of (buzzword points) the long tail, collective wisdom, and the value added by participation will turn the web into a huge, search able, participatory archive of everything. I notice that I've departed from pinning preservation through traditional institutions, because this can be seen more broadly, but I can still see great value in the editing, selection, and context provided by an archivist to a narrow, specialized collection of data.

There are also so many new sources of data, and I wonder how these play into the idea of archives and collections. How about personal archives, life-blogs, uploaded media, records of digital communications, and the coming deluge of data from sensors in the environment. Nobody in the present can imagine how all of these data sources may be used in combination by a future researcher or viewer. Given the emerging participatory web, the way that people use and link information will itself provide context, and assist in find ability, creating spontaneous collections that have nothing to do with the original intent when data was first stored.

So that's a pretty confused picture, and what is surprising to conclude is that being a librarian sounds pretty cool.

A goldmine of information about Second Life and Education

2007-08-23T16:21:00.000-04:00

This came to me via Kathy Kyzer at ITS-Teaching and Learning, who have done wonderful work on Second Life (visit the UNC island sometime).

These are the proceedings of 2007 Second Life Education Workshop (PDF warning), lots of information about experiments and experience using Second Life in an educational setting.

The realities of virtual worlds for corporate sites

2007-08-10T14:13:00.000-04:00

There has been a swirl of hype, and anti-hype around the idea of 'Serious Virtual Worlds'. Of note were the Wired article, as well as a blog posting by Chris Anderson that generated a lively exchange. Even more recent was a Gartner report cautioning corporate America about the risks of doing business in Second Life.

Metaversed, yesterday, held a really nice event in the SAP space on Silicon Island on Corporate Challanges in Virtual Worlds. The panel was:

Craig Cmehil - Community Evangelist, SAP
Fiona Gallagher - SL Project Lead, Sun
Jeff Barr - Web Services Evangelist, Amazon
Jonas Karlsson - Research Team, Xerox

Here's a shot...hardly a 'ghost town' for tech firms in Second Life!

The panel seemed to be in agreement that much of the recent coverage of virtual business was uninformed, or based on misconceptions. As an example, Gartner cautioned that corporations could not control access to their virtual sites. Expectation plays a big part here too. I think it is true that corporations that expect to build a virtual commercial for a product will be disappointed because nobody showed up. Second Life seems driven by events and gatherings, and is very much a socially driven animal around small networks. Increasingly, real life blogs, and things like Twitter are playing the same role in virtual space as they do in real life, acting as an alert system for happenings, and reporting events later to a wider audience.

The virtual medium has characteristics that distinguish it from the web. Instead of an ad that is encountered for a brief few seconds by a wide audience, virtual interactions involve deeper contacts with customers or contributors in small groups. It was pointed out that surveying a corporate office and seeing it empty can be misleading. The vendors represented pointed out the fact that one must understand the point of a particular build, it could be used for various events, could host customers for private exchanges and training, and also has ripple effects in the 2D media that must be counted in any calculation.

This was alluded to by one of the presenters, but I think about trucking out to the Airport Sheraton for Oracle Tech Days, or similar, vendor-driven events. In those cases, vendors ship out their employees, arrange conference space, and put on an all-day show to a small group. How is this any different from the corporate uses described by the panelists? Not very!

Anyhow, the Metaversed podcast carries the content. I continue to be impressed with the richness of these experiences in virtual space, including all of the networking that occurs before and after these presentations, which in itself demonstrates one of the true, unique properties of the 3D web.

I took a tram into the fourth dimension
Cos I had the blues, the blues of throwing it all away
Just gimme a Tequila, I'll slam it the 4-D way
And when I got there you know it had certain similarities

Like no smoking anywhere
And hiding in the khazi to avoid paying the fare
4-D Tequila anyone
And dont think we didn't dance to records by the Fifth Dimension

-Joe Strummer

Interesting SL Event Today...

2007-08-09T10:42:00.000-04:00

I picked this up from Metaversed...this is at 12PM SL time today. People from Sun, Amazon, Xerox, etc...

There's been a lot of negativity in the press of late over the marketing failures of corporations in the virtual world of Second Life. Analyst firm Gartner have even warned companies away from public worlds recently. With all of that in mind, Metaversed has put together a panel of active real life firms in Second Life to discuss their experiences, and lessons learned from being part of the community. The debate will no doubt prove useful to others and be of great interest to anyone involved in the business side of virtual worlds.

JADE, RMI error running JADE Gateway using Glassfish

2007-08-06T12:44:00.000-04:00

Nothing comes up on Google, so I'll throw this out for reference. I was trying to use the new Glassfish server to run a JADE GatewayAgent, on localhost, connecting to a main container on the localhost. Anyhow, it blows off with a MalformedURLException: no protocol yadda yadda yadda when trying to add the child node, blowing off in the RMIMTPManager$PlatformManagerAdapter.addNode method.

This looks like an incompatability with the RMI implementation on Glassfish. In the short term, I punted to Tomcat 5.5 and all is right with the world again.

I'm on J2SE 1.6_02, btw.

A bit part on virtual worlds last nite

2007-08-02T08:19:00.001-04:00

NC-17 news did a piece on virtual worlds last night. See if you can spot the nerd. Link to video here.

I'm working on JADE agents today. I'm somewhat suprised that agent frameworks like JADE are not applied more, especially in this 'come to me web' era. As we get an excess of computer cycles in our individual 'infrastructures', and as we become more mobile, there certainly seems to be a niche that agent computing could fill.

IT Conversations: Faculty Summit Opening Panel

2007-08-01T12:39:00.000-04:00

This week's Technometria features the Microsoft Research Faculty Summit's opening panel, moderated by Ed Lazowska and including a number of leading academics and Microsoft researchers.

IT Conversations: Faculty Summit Opening Panel

Real Agents working with virtual spaces

2007-08-01T08:04:00.000-04:00

It's been a while since I looked at agents, but I was happy to see that Jade 3.5 had been released. That's actually old news for some. I'm working on a project that embeds a physical space within a virtual 'building', and utilizing the JADE agent framework to tie the virtual and the physical worlds together seems like the ticket.

Anyhow, the things that jumped out at me about 3.5 were the ability to communicate between agents using a pub-sub topic model, and a re-working of the web services integration gateway.

In a previous post, I had talked about a small framework to tie virtual space (in this case Second Life) to external applications. The framework uses sensors (and I'm looking at other means) to detect and inventory objects in the virtual space, and gives the facility to pipe messages to those objects from outside. Yesterday, I used that to create a control panel GUI that can run on a small tablet. This control panel uses the framework to send information into the virtual space, causing alterations to the environment.

Over the weekend, I added the facility to push events out of the virtual space to subscribing listeners. Objects in SL can generate events for touch, creation (on_rez), collision, and so forth. By dropping a script in an object, the framework can trap these events and communicate them to a hub. The hub takes these events and sends them to the framework. Here's a pic where the 'pyramid' is the event generator, and the sphere is the hub. I simply 'touch' the pyramid, and the hub is messaged, sending the event to the framework for dispatching to subscribed listeners.

Below is a shot of the 'touch' event in the framework. There is a facility that inspects events coming out of the virtual space, and compares it to subscribers. A subscriber picks the 'region', or island, the object name, and the desired event. The subscriber also sets up a callback, and receives the paramaters associated with each event. I want to add a more flexible subscription, using regular expressions, etc., but that's more than I need right now. It might also be cool to add the ability to specify a script to run when an event is encountered, but for now it can just callback to a subscriber at a given url. Here's the basics of the event as it arrived to the framework. What's not shown is a generic 'payload' field, where I plan on pushing in the variables associated with each SL event.

At any rate, the 'control panel' I wrote for the tablet uses the ability to push messages into the sim by using a known region and object name. The new addition of the ability to push events out of the virtual space to subscribers is next on the plate, hence the interest in using agents on the 'real life' side. I think topic-based subscriptions on the agent side will help me figure out cool things to do given that I can hook into virtual events, plus it is just plain geek-fun.

The first task will be to have an avatar push a doorbell button in the sim, pick up that event, push it to the agent, and have the agent kick off a real-life doorbell chime. A stupid pet-trick, true, but the point will be to exercise this thing end-to-end, and then I'll have established a workable 2-way bridge to interesting things later. So far, the scripting/framework approach works out. Time will tell how well it scales, how lag-inducing it can be, etc. I've gone the approach of using conservative ping and sense rates, and it's been pretty smooth and stable so far.

Something whack that would be a fun side-project would be to wrap virtual devices with Jini, and have discoverable virtual services under a framework like that. This gets back to an idea I had a while back, using virtual spaces, virtual sensors, virtual actuators, and virtual people, to develop and prototype smart, ambient computing services. Given the collaborative nature of these environments, it might make sense!

Sun's open source 3D World, and 3D web as a training tool for WMD management

2007-07-31T11:42:00.001-04:00

A couple interesting links, first is Sun's project Wonderland, open source client and server for their 3D world. This looks like it's in early stages of development, but you can run the client and the server on your own, always a plus!.

The vision for this multi-user virtual environment is to provide an environment that is robust enough in terms of security, scalability, reliability, and functionality that organizations can rely on it as a place to conduct real business. Organizations should be able to use Wonderland to create a virtual presence to better communicate with customers, partners, and employees.

Second, Idaho Bioterrorism Awareness and Preparedness Program, using 3D web (in this case Second Life) for incident management training...

This virtual environment spreads over two islands Asterix and Obelix (65536 x 2 sq. meters), with one island dedicated to a virtual town and the other a virtual hospital. The design of this virtual environment is influenced by dioramas frequently used by emergency services to support their tabletop exercises.

IBM Employees and Second Life Guidelines

2007-07-31T09:42:00.000-04:00

IBM tells employees to behave in Second Life, from Network World.

NCSU, and using 3D environments for learning

2007-07-30T12:56:00.000-04:00

UNC has a lot of interesting projects applying the 3D web to education, visit the UNC island sometime! Here's some info about similar initiatives at NCSU!

I went to an interesting Croquet demo last week, I've got some notes and am working on a write-up of what I heard.

Wired, SL, 3D web, the hype curve in action

2007-07-27T11:40:00.001-04:00

This is sort of fun, the back and forth about advertising and the 3D web based on a Wired mag article, sort of like that previous LA Times article. In the bubble days, businesses thought they could sell sock monkeys and pet food, and just because it was on the web, they'd be millionaires. The corporations that think they are going to sell mac & cheese because they put up a virtual store are as deluded, and the press will be all over that, I imagine. The most useful thing in the back and forth is the fact that sites in virtual space often appeal to the long tail, versus a mass-market appeal. The long tail is ignored in the original Wired write-up, and I think that's the critical omission.

There's that old saw about asking a farmer what would help his farm work better, and him responding a better plow or a stronger mule, rather than responding that automated farm equipment would help. In other words, the farmer only can apply the world he knows to the question. I'd say we're in the middle of a prime example of the phenomena.There's also the old adage that we overestimate change in the short term, and underestimate it in the long term, and this has a lot to do with the shape of the hype curve.

History repeats itself, and at an accelerating rate, it seems.

Using the Wii with 3D Web as a training/sim device

2007-07-27T11:30:00.000-04:00

From Wired...

For Stone, the Wiimote is the key to building realistic training simulators within the virtual world of Second Life. He is helping companies and universities do that through his WorldWired consultancy. Clients include a company interested in training workers for its power plants, a manufacturer of medical devices and pest-control firm Orkin.

The future of virtual worlds, LA Times says it's bleak

2007-07-24T07:57:00.000-04:00

It's odd sometimes, the way backlashes go. I've been blogging a bit, and being somewhat evangelistic about the 3D web. I didn't invent the term, and wasn't among the first to catch on, but I have a gut feeling (me and Chertoff) that the term means something. Lately, especially after the LA Times article about the death of commerce on the 3D web, I've been approached by multiple people who want to explain to me that this is all a tempest in a teapot.

A proper, direct response to the LA Times article about Second Life can be found here, and here, so I won't try to recapitulate the common myths that make up such negative press. I was considering reasons why I am intrigued by the whole topic of virtual worlds, though, and I wanted to jot some of these down. These observations are shaped by my own interests, by past projects I worked, and so forth. You may discover other reasons to pay attention to the 3D web.

Real and Virtual are Merging

This is a drum I was beating well before I delved into Second Life. In this older post, and this one soon after, I talked about Mobile2.0 and Web2.0, trying to relate these terms to this larger idea of real and virtual merging. The main idea was that mobility and the new web were, in part, about the 'web of things'. Sensors and actuators talking on the web, and smarter applications to discover and manipulate this explosion of new information and services. Whole new types of applications stretching the definition of the web. Virtual worlds are important because they are a metaphor for this merging. In a way, our avatars allow us to cross the barrier, and physically inhabit the web of things. That's a bit sketchy, but I see the 3D web riding the coat-tails of the emerging web of things.

There are potential, practical benefits to visiting the virtual world to understand and manipulate the physical too. I've been interested lately in the development of EOLUS One, as described in this UgoTrade blog entry. This is a fairly wide-ranging project, but it does serve as an interesting illustration real world/virtual world merging.

People Make a Comeback

The ubiquitous social networking web site provides many benefits. I'll pick on a few, and tie them to a virtual world experience:

a venue to expand social/professional networks
a tool to maintain connections to existing friends
a platform to shape and present our own identity
a tool to filter and flag important information (use of social networks to compensate for a deficit of attention)
a collective tool to add value, from which we individually extract benefit

All of these points can be extracted from classic definitions of Web2.0, and many of the points are mirrored in virtual worlds such as Second Life.

Expanding Social Networks

The first point, virtual worlds as a venue for expanding social networks, is primarily a function of the ability of a virtual world to create an event, or common experience. Think about where friendships start, it is often based on some shared experience, like a college course, or a conference, or some notable event. Virtual worlds can provide an immersive, compelling experience from which these connections can take root.

Social networking also relies on sharing connections, in a friend-of-a-friend style. Given the existence of shared experience in virtual worlds, the familiar mechanism of meeting new people through current friends has a virtual analogue.

Maintaining Current Connections

It's probably a question for sociologists, but what quality of social experiences can be achieved in a virtual environment? I'm quite sure it's not the same as real life, but I also suspect it's a richer interaction than what one would suspect.

We're using tools like Twitter, Flickr, and FaceBook as a way to keep up with our friends and colleagues when we're separated by time or distance. The function of these tools do not map onto the real-time nature of virtual worlds, but I suspect that virtual worlds can add some unique new tools to serve these ends. One example that comes to mind is the ability to establish 'hang outs' particular to a group of friends and colleagues.

Shaping Identity

People use social applications as a way to shape and present themselves. Virtual worlds such as Second Life have an economy partially based on the customization of personal avatars. People take great care to build an image of themselves. Does this aspect of virtual worlds play into this basic function of social networking applications? I guess this is another one for the sociologists...

Tapping into Collective Power

Successful Web2.0 sites often become so because they provide tools to build something interesting, let the tools loose on the world, and leverage the resulting content. I'd toss out Wikipedia and Flickr as two prime examples. There's a fundamental principle at work there, and a lesson that virtual world developers need to take to heart.

Professional 3D developers really don't like Second Life. I picked that up! I can see why, I think the building tools are crummy. This is something I had observed in a previous blog entry, but it bears repeating...the quality of the tools matters, but more important than professional level, sophisticated building tools are accessible tools, available in-world, suitable for the average Joe to get something done. There are indeed master builders within environments like Second Life that could take advantage of special tools, but I will guess that the vast majority rely on simple constructs, and use the ecosystem to purchase the rest.

I think about how bad HTML is, and how crude the tools still are, and would not be suprised to find out that, back in the day, that the web was dismissed as consisting of poor technology in the hands of unqualified developers. I know there are two sides to the coin, as I still encounter poorly designed sites with flaming clip-art, but I look at how far the web has come based on simple HTML, and simple scripting, and don't think it wise to assume it won't happen again.

It's not there yet!

Don't take this as a Second Life fan site. There are lots of things lacking in Second Life, and lots of other virtual worlds out there. I'm going to a Croquet presentation this afternoon, and have begun looking at that tool, getting used to Blender, and intent on learning Squeak. The dust has not settled on the particulars, but I really do think the 3D web means something.

There are 'virtual natives' coming up fast. Under my watchful eye, my little kids spend a little time wandering around Nicktropolis, and similar sites that approximate virtual worlds. These kids don't even blink, they just jump right in, and they are right at home. It's a mistake to put our own preconceptions and limits on a new technology, based on our own experiences and habits. I liken this to the way that younger people don't have a problem editing and keeping documents out on the web, or in alternative, open-source office suites, versus the old MS Office stand-by. I look at my own kids, and it makes me think that the metaverse is as natural to them as Tom and Jerry was to me.

It's especially clear that issues like identity, security, scalability, and application development support all are lacking in many of the current contenders. The power of open source and standards needs to be applied to this space, but the 3D web is here, and it's going to keep growing, I feel confident in saying, even if everyone wants to observe that this is just a game with no future...heck, I'm still waiting for the death of Java!

Try NetBeans 6.0 Milestone as your Rails IDE

2007-07-20T10:53:00.000-04:00

I don't have a comprehensive analysis, just a general feeling. I really like coding Rails apps using the NetBeans 6.0 Milestone. I love Eclipse, and switch between the IDE's depending on the specific task, so this is not coming from a particular camp.

I like RadRails a lot, but it seems to have stalled a bit. I kept having problems where the IDE would loose my Rake tasks. I found a fix to manually add an Eclipse builder to the project, point it at rake, etc. Even so, I still periodically see the app forget about Rake. A small complaint, really, but it frustrated me enough to switch. What I found in NetBeans is a rather tight-feeling, smooth IDE for Ruby on Rails. No big analysis, just a nice experience. I'm back to coding, and my IDE seems to not forget about rake. Now if only I can remember my anniversary coming up!

Mobile AJAX, then some really cool SL stuff

2007-07-17T18:56:00.000-04:00

I read this blog posting about mobile AJAX with some interest. The main premise was that, due to the difficulty in porting to so many mobiles, even with the efforts of the J2ME specification, large-scale deployments remain prohibitive. The blog concludes:

AJAX offers a potentially better solution in comparison to the incumbents (J2ME and XHTML) due to a combination of fewer potential choke points because of its distribution mechanism. The economic models do not favour J2ME and AJAX offers a superior user experience to XHTML. It has the support of the developer community.

I think the idea is cool, but the one fly in the ointment is the fact that mobile connectivity is still so sketchy, and applications need to really support a 'sometimes connected', or event 'mostly connected' environment, as well as the ability to receive pushed-in data. I suppose there are all sorts of creative ways around this, but for the foreseeable future, web browsing on mobiles still sucks.

To other things, we're working on a really cool idea for physical/virtual mash-ups. Imagine a physical space embedded within a virtual space, where real people can see and interact with avatars, and vice versa. In this environment, the virtual avatars can 'reach in' and alter the physical environment, and real life individuals that inhabit this space can use physical 'things' to alter the virtual environment. Sort of a twilight-zone between two parallel universes!

The pic below shows me standing in the virtual room that surrounds the physical room. Imagine that the virtual walls are projected on the physical walls that surround the room occupants. On the walls are windows that avatars may approach. The avatars themselves see real-time streams of audio and video, so from their perspective they are looking into the real room. This sort of thing has been done before, but I think the context is unique. It'll be a cool place to explore the merging of the physical world and the virtual world. This is being tested right now by pushing a custom Second Life client through four monitors arranged as the walls of the room, and will eventually be projected on the actual walls of the real room. (I didn't write the client!)

It's just the start, a fascinating range of possibilities opens up from here. One SL friend, Uskala, mentioned the idea that the walls of the room could change from a meeting space to an auditorium, so that's something that I just implemented, where the walls reconfigure to reveal an auditorium space, and seating rises from the floor. Imagine giving a SL presentation by standing at a podium, looking out onto an audience of avatars. If time permits, I'd like to program these room alterations into the room control system, so a physical knob or button could select different room configurations. This is really cool stuff! More later as it develops, but the first tries today look promising.

Doooh!

2007-07-12T11:26:00.000-04:00

An obvious point, but do your Rails model validation code before developing your unit and functional tests very far, otherwise, you have to re-do a bunch of test cases....

Doooh!

Way cool video explaining the new web

2007-07-11T07:53:00.000-04:00

This came to me from my friend Joel, at UNCG. In a couple of minutes, this cool YouTube video highlights many of the changes happening on the web, recommended!

3D web as disruptive technology - Mitch Kapor

2007-06-20T12:26:00.000-04:00

I've had the videos of the IBM & MIT Media Labs conference on virtual worlds running in the corner of my monitor all morning, and I was highly impressed with Mitchell Kapor, Linden Lab Chair, and his view of virtual worlds as disruptive technology. He brings up the term macromyopia, which is a nice word that captures the idea that we overestimate change in the short term and underestimate it in the long term.

Anyhow, his talk is entertaining and thought-provoking, and worth the investment of about 45 minutes of your time.

Food for thought

2007-06-20T07:44:00.000-04:00

Check out the prologue to "Everything is Miscellaneous", by David Weinberger. He's an interesting and engaging speaker, and writes in the same style.

Anyhow, I loved this quote, and I think about it in terms of what's happening with the 3D internet...

Those differences are significant. But they’re just the starting point. For something much larger is at stake than how we lay out our stores. The physical limitations that silently guide the organization of an office supply store also guide how we organize our businesses, our government, our schools. They have guided—and limited—how we organize knowledge itself. From management structures to encyclopedias, to the courses of study we put our children through, to the way we decide what’s worth believing, we have organized our ideas with principles designed for use in a world limited by the laws of physics.

Suppose that now, for the first time in history, we are able to arrange our concepts without the silent limitations of the physical. How might our ideas, organizations, and knowledge itself change?

For me this neatly captures a central idea of the 3D web. In a world without limitations, physics, or other constraints, how can we use the tools in a way that feels real, but that doesn't place the limits of physical world, or a static organization of information, into the virtual? This quote highlights both a mistake to be made, and new ways to think.

It also struck me last night that there is a common thread between the (admittedly modest) things I'm doing within Second Life, and past work I did on smart spaces and context aware computing. In some ways, the tools you wish were there in the physical world can be modeled in the virtual, sometimes with the same ends. In each case, physical and virtual, the goal is to respond to each individual, and provide a mesh of services around that person as they navigate the environment. I'm intrigued by the idea that some of these context-aware computing concepts could be applied within the metaverse toward the aims that David Weinberger describes. By the same token, I am interested in how the metaverse could be a testbed for context-aware applications. The whole environment is scripted, you can build sensors and actuators, have location, manipulate the environment, add social elements, etc. Model a smart home, classroom, or office in Second Life...It's certainly faster and cheaper than trying to build a testbed or living lab!

As a note, I happened upon this tidbit from Bob Sutor's blog, links to video now available from the MIT & IBM Conference: Virtual Worlds: Where Business, Society, Technology & Policy Converge which took place on Friday at MIT Media Labs.

Pics from the SL iCommons Summit

2007-06-18T12:23:00.000-04:00

I popped in, and blogged a bit about his event here, and here's a link to some interesting pics from the occasion.

Second Earth in MIT Technology Review

2007-06-18T08:22:00.001-04:00

From MIT Technology Review...

The World Wide Web will soon be absorbed into the World Wide Sim: an immersive, 3-D visual environment that combines elements of social virtual worlds such as Second Life and mapping applications such as Google Earth. What happens when the virtual and real worlds collide?

This is worthy of a read. The basic premise is that 3D worlds as part of a mash-up with real life locations and data will transform the way we view the 'web'. I'm down with that...

IBM Conference on Virtual Worlds

2007-06-15T15:54:00.001-04:00

Coverage...

"We are now at the threshold of newly emerging (Web) platforms focused on participation and collaboration," he said. "The power of collaboration and community are one of the major drivers of innovation as companies figure out the capabilities to accelerate collaborative innovation."

Parris described some of IBM's initial uses of virtual worlds in a business context, including enhanced training, immersive social-shopping experiences, simulations for learning and rehearsing business processes, and event hosting.

Waiting for Lessig at 11:00

2007-06-15T13:34:00.000-04:00

Popped into the iCommons summit in Second Life, waiting for 11:00 SL time when Larry Lessig will be speaking. Here's where I'm at..

Some audio probs right now they are working out.

Cool..things are worked out, watching a short film about the remix culture...

Oh well, looking at a grey screen, having media probs here..

OK, switched computers and I'm able to see, right now Johnathan Zittrain is speaking.

Larry talking about debate with Brett Cottle re copyright. How do people in creative commons movement get respect? We get that respect by demanding it loudly like they (copyright people) do. Who are 'we'...iow creative commons?

CC is a movement of open source for culture. Copyright's power comes from its complexity..it's the command line interface that gets to the core of the machine, great for geeks, not good for most people. For most people, layers are put on top. Think about CC as a gui overlay for the copyright system's power. Another function is as a signal. The people displaying the cc sign send the message that they are part of the sharing economy. Money not part of terms of exchange...instead it's poison. This economy is important provider of value, (wikipedia, flickr). Money is not why people participate.

CC has a role in protecting the sharing economy. CC protects participation in the sharing economy.

"You are helping artists to starve!" as a criticism. Responds that CC can help artists cross over from a sharing economy to a commercial economy when they want to, and when appropriate. New component, beatnick, from creative commons, that allows commercial licensing of creative commons content. Enables bottom-up creativity. You share, and choose when to allow work to be commercially exploited.

We have allowed other side as if this is a debate about piracy. We are fighting for the right to steal, etc...E.g. defense of p2p, as if cc is fighting for the 'right to steal'.

How to respond? This is not a movement about the right to take, it's about the right to create, the right to share in the sense that the artists, creators can be free to choose without the government speaking for them.

General problem, people controlling government is that they only listen to money. (Global warming, healthcare as examples).

CC people need to stand for the movement and make it grow. Standing O.

iCommons Summit in Second Life

2007-06-13T14:42:00.000-04:00

This looks interesting, another SL overlay of a RL conference...

The USC Center on Public Diplomacy, Linden Lab and iCommons are delighted to announce that the iCommons 2007 Summit in Dubrovnik, Croatia, will be run in parallel in Second Life!

The aim of running the iSummit 2007 in Second Life is to mix the real and virtual world for both attendees of the Summit, and for those who are unable to make it to Dubrovnik, thus expanding the community who will be able to learn, collaborate and share their knowledge and experiences of the Summit. The parallel summit will also help to introduce new users to Second Life and to build the global diversity of participants who are collaborating in-world.

The schedule is posted here, looks like some interesting people will be there, e.g. Larry Lessig, Jimmy Wales.

Making Connections, virtual reality, agent computing, robots, and even real human beings

2007-06-13T11:29:00.000-04:00

So I spent a few minutes digging around after reading the Slashdot article about using AI, agents, and 3D visualization to train firefighters. Off on ZDNet is the original article, by Roland Piquepaille.

ZDNet describes the system this way:

The system is currently used by the Los Angeles Fire Department. DEFACTO has committees of AI ‘agents’ which can create disaster scenarios with images and maps seen in 3-D by the trainees. The software agents also evaluate the trainees’ answers and help them to take better decisions.

This is interesting in several ways.

Virtual simulation and training

One of the great potential uses of virtual worlds is the creation of immersive training and simulation environments. I'd anecdotally observe that interacting in a 3D environment with an avatar provides a pretty effective experience. Situations like a fire or a disaster are prime candidates for such an application. Other uses might include immersive language learning, law enforcement, or hospital/medical situations.

Collaborative visualization, ambient data, situational awareness

Collaborative is the key word here, because there are better, higher resolution methods for exploring data through visualization. A simple equation may be to combine your avatar, the avatars of collaborators, and the visualization, so that remotely distributed teams can fly around, point, manipulate, and refer to parts of a visualization as a group. This is somewhat linked to the themes illustrated by multi-touch displays, such as the Microsoft Surface Computer that I mentioned a few posts back.

I'm mostly looking at Second Life, for many reasons. It's safe to say that SL is not a platform for visualizations, but I have tried several small prototypes with the premise that the collaborative nature of these environments yields qualitatively different experiences. Another way of saying this is that it might be useful to look at ways of creating 3D visualizations within virtual environments, not necessarily as the best visualization tool, but as points of reference in virtual collaboration.

Take a look at this image from the DEFACTO page, and imagine how that application, combined with a collaborative, avatar-based environment, could have interesting possibilities, even as far as visualizing and managing an actual event, versus a simulation.

Agents again!

I had a brief run on some earlier projects where I looked at agent technology. At the time, we were looking at the state of context-aware computing, especially as it applied to the development of smarter mobile applications (location awareness, etc). This was mostly using the JADE agent framework, and was based on a research framework called CoBrA. Honestly, I have not been thinking about agents for a while, but this article made me think about agent technology again. Agents are a great model when you have heterogeneous, autonomous, entities that need to cooperate. Especially important is the ability to dynamically form associations, and negotiate to solve a shared task. Web2.0 talks about small things, loosely joined, and agents share that same philosophy in their own arena.

Agents have always struck me as not getting enough play in the whole 'next generation web' yap-space, especially considering the merging of the virtual (web) and physical world through the explosion of sensors and actuators that are starting to talk on the web. Both agent technology, and the physical/virtual merging still seem like blind-spots, when both may play an important part in the post-web2.0 world.

In this case, agents are seen as proxies for what Machinetta calls RAP's. Machinetta is one of the underpinnings of the DEFACTO system, and it is essentially an agent framework that supports negotiation, assignment of roles, and other aspects of team-work. RAP's are the Machinetta term for "Robot, Agent and/or Person". Cool...we got robots too!

Virtual/Physical merging

So this was just mentioned, and bears repeating. The web is not only the information and people, but also the parts of the physical world that are being hooked in. This has gone on for a while, but what is interesting is to see that merging playing out on something suggestive of a virtual environment as well. This is actually something I've been messing with in Second Life, though at a much less sophisticated level. The DEFACTO application seems to suggest some of the same notions, in any case.

Virtual ambient information

The last point I'd make is that this application shares some common characteristics of many of the location-aware mash-ups that are everywhere, especially using tools like Google Maps, Google Earth, and now Google Mapplets. This gets back to the original point about interacting with visualizations in an immersive environment. In a virtual, 3D space, it seems like the potential is there for mash-ups on steroids. Here's a shot from an earlier post of a modest example using 3D symbols on a map...

It might be hard to get the gist of this, but, just like in DEFACTO, virtual worlds can represent ambient information about state and situation by the appearance and behavior of the objects. There is no reason that these objects could not link to DEFACTO RAP's for example, and provide handles to communicate or interrogate the state of the various agents.

Lots of possibilities!

Rails Active Scaffold - from a DHSB

2007-06-11T12:59:00.000-04:00

Saw this come across from my del.icio.us network, an article from IBM about the Rails ActiveScaffold plug-in...

This is a plug in to nicely handle all the CRUD that still required lots of coding using the vanilla Rails framework. The promised benefits include (quoting from the ActiveScaffold page):

An AJAXified table interface for creating, updating, and deleting objects
Automatic handling of ActiveRecord associations
Sorting, Search and Pagination
Graceful JavaScript degradation
RESTful API support (XML/YAML/JSON) baked in
Sexy CSS styling and theming support
More extension points than you can shake a stick at
Guaranteed to work on Firefox 1+, IE 6+ and Safari 2+
Released under the MIT License, the same one as Rails itself, so you can use it freely in your commercial applications.

Worth a try! Of the plug-ins and Rails extensions I've seen lately, this one looks promising.

This plug-in is good for me, as I found I'm a DHSB, from this programmer's test...what are you?

Your programmer personality type is:

DHSB

You're a Doer.
You are very quick at getting tasks done. You believe the outcome is the most important part of a task and the faster you can reach that outcome the better. After all, time is money.

You like coding at a High level.
The world is made up of objects and components, you should create your programs in the same way.

You work best in a Solo situation.
The best way to program is by yourself. There's no communication problems, you know every part of the code allowing you to write the best programs possible.

You are a liBeral programmer.
Programming is a complex task and you should use white space and comments as freely as possible to help simplify the task. We're not writing on paper anymore so we can take up as much room as we need.

Google Developer Days video streams

2007-06-11T07:08:00.000-04:00

YouTube has a wealth of info from the recent Google developer days (gears, mash-up, etc). Worth a look on a slow day.

Bit of vid showing RL/SL mashup

2007-06-10T08:59:00.000-04:00

Willi had captured a bit of video from Second Life showing a campus walkabout with his mobile -> second life reporter. What can I say...it was a nice day on campus!

This afternoon, the band I'm in starts recording a new cd. As we're complete unknowns, (and probably deservedly so), we're all DIY. The first time we did this, about eight years ago, it was to a Tascam 80-8 with one bad channel, using a DBX unit that had 4 good channels. We're starting this one out with capability for about 80 tracks, and all the eq's, compressors, and misc. rack gear that we'd rationally want to use. In addition, we can carry the project between home studios and our tracking 'shed', and do independent overdubs. The whole thing is probably going direct to the web under Creative Commons...the march of technology is changing the lives of anyone with any creative impulse, and the web will allow us to reach the dozen people that would want to listen to us prattle on, long tail indeed!

Next version of SlIcer deployed

2007-06-08T14:18:00.001-04:00

I've been up late a few nights on this, so allow me to go on a bit...This is the next version of SlIcer, which is essentially a utility for hookup up things in Second Life to things in real life. I've seen things like ObjectOverlord that work on the client code, but I wanted to do things that would work within the vanilla client. Good idea? Not sure, but at least it's workable.

What it does now:

Inventories people and objects within a sim using scripted sensor objects that are placed in strategic locations. This inventory can be for multiple regions, and is kept in a database.
Creates a queue for messages bound for Second Life. These messages are stored in a database, and delivered through scripted hub objects (co-located with the sensors). Essentially, the hubs poll the database for pending messages, which come down in a bundle, and are distributed to target nodes.

The test case is a mapping room, with a map on the floor, and 3D symbols that reflect state and position. Messages can come in from external applications, and the objects on the map change position, reconfigure to reflect state changes, and can also display floating text for other messages.

That's a picture of the map floor. The round object floating in air is the sensor/hub. Against the wall is our people sensor that looks for individuals, sort of virtual RFID. The SlIcer web app, which is still very much a work in progess, can show an inventory of everything discovered by our in-world sensors.

That's a screen shot that shows, for example, a rover_counter on the map. The database contains info like the last sense time, the x,y,z coordinates, etc. The cool thing is, there are simple URL's that an external app can call, targeting a region and object by their known name. This obviates the need to keep up with SL UUID's.

I'm an awful object builder, but this is my pitiful truck object in a 'stowed' state..an external source (such as a mobile GPS unit), could send telemetry by calling a URL, this enqueues a message for delivery to the sim...

And bammo...state/position change...

What's next:

I've already got a database of objects, and it will be easy to add a table of arbitrary name/value properties per object. This gives a Silo-like capability to maintain object state outside of the sim. Objects could update their own state, or pick up state changes pushed in from the web. What would be cool is that that state can survive object name changes, and also re-rezzing. The drawback is that objects have to have a unique given name, I don't do duplicates.
Thinking about a pub/sub system for events. For example, do something when an object is rezzed, when an object moves, when a certain person walks into a room, etc. I thought about putting this up in an additional sim, and doing some stupid pet tricks where moving and object in one sim causes a change in an object in another.

From there, I'm not quite sure, but it seems to open a lot of possibilities up. I have some cruft in the database for doing some reliable delivery stuff, but that's not a burning issue right now. The whole thing is done using Ruby on Rails, which I am really keen on these days. This has not taken a huge effort, development can go very quickly one you make the mental jump!

Rails, SL, mash-ups, all in one project...how cool is that...

Cool visualizations of the net

2007-06-07T07:57:00.001-04:00

Nice web interface from Akamai showing visualizations of real-time web traffic info...check it out here.

Progress on acts_as_authenticated and authorization in Rails

2007-06-06T14:51:00.000-04:00

I'm happy to say I fairly quickly was able to implement authentication using 'acts_as_authenticated', a Rails plug-in. Props to the helpful Rubyists of Second Life for turning me on to that. I prefer the plug-in model to the engine model, much easier for me to grok.

So the steps were fairly simple. First, I went and grabbed acts_as_authenticated, per the helpful instruction page. If you have not tried a plug-in, it's worth it to do a bit of background to understand what is happening, I'd suggest the link-fest on the Rails Wiki as a primer. This gives you a basic database user repository. Then you can, in your controller, say things like:

class RolesController <>

before_filter :login_required

This filter will divert to a login page, along with signup, logout, password hashing, and other basic facilities. Badda-bing, badda-boom. Note that you can exclude various controller actions from the login requirement, so you can have guest pages, and other non-critical data in plain view.

Important to note, acts_as_authenticated only does the authentication part, so you need to go the extra mile to add authorization. There are a couple advertised plug-ins that sit on top of acts_as_authenticated, and I took a stab at the acl_system (actually, I grabbed acl_system2 out of SVN). The files and directories from acl_system2 go in your vendor/plugins directory in your Rails application. There are also a few pre-reqs to using the acl_system, as explained in the instructions:

You will need to have a current_user method that returns the currently logged in user. And you will need to make your User or Account model(or whatever you named it) have a has_and_belongs_to_many :roles. So you need a model called Role that has a title attribute. Once these two things are satisfied you can use this plugin.

So I created a role table in MySql, with id, title, and the usual created and updated dates. I added the following to my User model:

class User <>
has_and_belongs_to_many :roles

Along with this, I have a join table to link users and roles. Once this is configured, you can add additional filtering to the above authentication filter, as in this simple example:

class RolesController <>

before_filter :login_required
access_control [:list, :show, :new, :create, :update, :edit, :destroy, :index] => '(administrator)'

Note that this is simple, and the specification of complex action/role mappings looks fairly flexible. At any rate, it works in initial testing. Lots more to go, but this took much less time than grokking and implementing the user engine, YMMV, of course!

Nice Comparison of Ruby/Rails IDE's

2007-06-06T07:32:00.000-04:00

This morning, my RadRails seems to have forgotten about my projects Rake tasks. I've seen that before, somewhat frustrating. Made me look at the grass across the fence again.

Here's a nice comparison of Rails IDE's, as part of my short detour into alternatives. It looks like grabbing the latest NB 6.0 Milestone gives you the Ruby support.

Rails Authentication

2007-06-04T21:57:00.000-04:00

So as I'm working on a couple Rails apps, I'm worried about the best way to authenticate. I had originally done some things with rails authentication and authorization using a rails engine. I pretty much got it to work, but it seemed a bit kludgey. Part of this, I'm sure, is not quite grokking out how the engine was wired in to my app. Chalk it up to a state of perpetual newbie-ness.

So perhaps my feeling about engines is not totally unfounded. I'm not jumping into the whole debate, but there seems to be a split in the Rails community about engines, enough to look for alternatives. Anyhow, I asked a few more experienced rails programmers, and like a chorus they all told me to forget about engines and go with Acts as Authenticated. That's on my plate, I'm going to try this plug in as part of this SlIcer mash-up.

Additionally, I came across this nice review of Rails authorization tools...a good read.

More along the lines of the MS Surface Computer

2007-06-03T20:10:00.000-04:00

I"m linked to a video at Perceptive Pixel, I ran across this from Joho the Blog...It's worth a quick look, and expands on themes that surfaced last week with the little wave in the blogosphere around the Microsoft Surface Computer.

In Joho, David Weinberger makes the point that cool UI's are not necessarily usable UI's, which kind of bummed me out, I can't get past how cool it looked.

I know this isn't the point of Joho, but how would access to this thing make using computers a different thing? That is the question, versus how you would make the UI do what your keyboard and mouse does today. Also, break out of the 2D browser model. What about navigating tag clouds or graphs of links as part of searching...toss something into an RSS feed out to collaborators.

Anyhow, take a look at the video...

3D RL/SL location aware mash-up working...

2007-06-01T14:30:00.000-04:00

Well, mostly...we have some tweaks to line up the RL coordinates and the offset on the map. We might need to re-do the map we use to texture our sandbox.

Anyhow, this image is my avatar on our 3D interactive mapping floor. The green prim represents Willi (approx31) walking around on the UNC campus with a mobile phone/GPS. Check Willi's blog for particulars, but we take the live GPS signal, and send the lat/long to a PHP script. That script converts to x and y offset from a known origin on our mapping table, which is then scaled to the map on the SL object. The upshot is that the map symbol moves in real-time based on Willi's GPS report. After we tighten down the positioning, we'll be looking for more things to instrument. A cool thing would be to outfit various vehicles with GPS transponders, and other status telemetry, as well as various individuals. Then, at any time, you could see the corresponding 3D symbols moving about and changing state. This is really cool to watch.

By the way, this is using the SlIcer framework, which I had originally proposed a few posts back, and which is up and running in it's first pass. I'm busy doing a second pass, with lots of optimizations and new features. Really that next version will be the first 'usable' one, and maybe can be used in other places, such as the UNC Island. One thing that's cool in the coming version is the ability to inventory and message across multiple regions, so you could move a prim on one sim, and have something happen on another...

Google Gears

2007-05-31T11:43:00.001-04:00

This was touted as Google going straight at Microsoft. A framework for going off-line with on-line apps, called Google Gears. It appears that Google Reader and other apps are going to be outfitted with this capability, which is very cool.

One of the most frequently requested features for Google's web applications is the ability to use them offline. Unfortunately, today's web browsers lack some fundamental building blocks necessary to make offline web applications a reality. In other words, we found we needed to add a few new gears to the web machinery before we could get our apps to run offline. Gears is a browser extension that we hope -- with time and plenty of input and collaboration from outside of Google -- can make not just our applications but everyone's applications work offline.

Too many irons in the fire to play with this now, but I'll file it away, sort of today's mini-buzz after yesterday's MSoft Surface Computer wave. I'm also catching that people are complaining about the Google Street View, check out Boing Boing for the blowback on that!

update: Here's another article on Gears.

Microsoft Surface Computing - HCI and UbiComp

2007-05-30T09:28:00.000-04:00

Sometimes, it's hard for me to pin down what my own blog is about. I tend to run many threads at once, and end up thrashing sometimes, as I suspect anyone working in technology does these days. The past few weeks, it's been about Second Life, and that continues, but I'm looking at other areas as well, such as plain old Web2.0, ubiquitous computing, agent computing, mobility, location aware services, SOA, and dynamic scripting languages (specifically Ruby and Rails these days). In the mix somewhere is my original interest in Java/J2EE, along with things like Spring.

Rather than a testament to a short attention span, I think this wide variation in themes is actually a sign of the times we live in. Developers no longer learn one language, and roll into every project with the same set of tools. The evolving web, the evolution of mobility, and the pervasive field of networked information and devices that surround us everywhere we go make for an interesting and challenging time. I'd like to suggest that the disparate topics covered in this blog are on a converging trajectory. Maybe that's what this blog can be about.

Case in point, check out this short video on Microsoft's Surface Computer. I think this is an exciting platform that brings together a bunch of ideas. Essentially, this is a big, touch sensitive display that uses gestures to manipulate data. The cool thing is that it's multi-touch, so you can gesture with both hands, and multiple people can interact with the computer at the same time. In addition, the Surface Computer is sensitive to physical objects. It can sense with these objects, and also interact with other computers placed on the surface.

The 'multi-touch' is collaborative. Technology is getting more and more social. This reality is core to Web2.0, as well as the evolving 3D web. We're not isolated from each other anymore, we Twitter and blog, we IM and message, now we can compute together.
The Surface Computer bridges the physical and the virtual. In the video, they demonstrate placing a device on the surface, having it dynamically connect, and using a gesture to shoot a photograph into the device. The natural action of placing a device of interest on the collaborative surface, and being able to manipulate it, is a step towards useful ubiquitous computing.
The Surface Computer could be an interesting new metaphor for web collaboration in the way that avatar representation in Second Life creates a sense of immersion. I think it won't be long until you could assemble remotely around a common 3D web surface, with remote participants as avatars.

The combination of natural interface, immersion, and the ability to easily incorporate data from the web, or from other devices, in collaborative ways seems like a natural progression.

Google street view

2007-05-29T13:38:00.000-04:00

Just go here...it's amazing. Alas, Franklin Street not available...

Second Life Best Practices in Education - Link Dump

2007-05-29T08:41:00.001-04:00

Here's a nice link dump to catch up on the SLBP confo last week...

WUNC today, the rise and fall of Friendster

2007-05-29T08:15:00.000-04:00

On 'the Story' today..Jonathan Abrams from Friendster.

quote:

Dick talks with Jonathan about what he learned from the success and later failure of Friendster, and how he plans to compete with a new social networking project in what has become a very crowded field.

More of SL Best Practices in Education confo

2007-05-25T13:31:00.000-04:00

A few keynotes this afternoon worth catching...catching the end of the IBM keynote. Place is SRO.

Search IBM and Secondlife in YouTube (do that later) to see some examples of their use of virtual worlds. ? on when virtual worlds truly become mainstream? Mainstream is difficult to argue..what is mainstream? Talk in terms of internet 1 (democratization of access), lots of people connected now took about 10 years. Web2.0 (democratization of participation), took about half the time. 3D internet is about people coming back. People are going to be involved in every aspect of environment, and it will happen fast.

Pirate Shipman, adjunct faculty at Pepperdine, is next keynote. Right brain attitudes important in today's world:

Design
Story
Sympathy
Empathy
Play
Meaning

Basic premise is that we need to focus on these areas, versus left brain logic. Pirate did a class project do develop virtual content reflecting these 6 aptitudes. This comes from the book "The Whole New Mind". Students given a small area and a 150 prim limit for their projects. We watch slides of the building progress on the class island. Students experimenting...Conclusion was that it was a powerful learning experience for all involved.

That's the keynote in progress..

Question...how do we teach in a virtual world? We need to discuss strenths and weakneses.

Strengths:

SL is a spatial experience. Virtual world has physicality. Shapes, sizes, movement, spatial relationships take on deep meaning.
SL is an immersive experience. We can respond as if we are really there...effects emotion and mood to be in a virtual situation.
SL is a social platform. We can craft and present an identity to others. "This makes the us that engages with others easier to become". (Interesting).
SL has tools to connect to and communicate with others. LSL allows us to develop socially aware objects.
SL democratizes the ability to create content and learning artifacts, it's a participatory medium. (This is what I think is the key point, which SL captures well).
SL enables collaborative development of objects. (I think building things with others, and having the tools in-world, is the key...this is why SL works, and why importing from blender, etc is not important, and rather not the point, but that's just me!).

Some talk about the playful spirit that is the game part of the environent...the keynote speaker is wearing a pirate eyepatch.

Weaknesses:

Effective communication of large amounts of data is difficult.
Technological overhead high.
Combo of 2d with SL lacks synergy most of the time. Showing 'flat' images, for example, still easier in a browser interface..
Activities outside of the scope of what second life does can usually be done better outside of SL. "Sometimes, though, the novelty may be enough".

OK...gonna hit some posters, then I gotta go....

Here's a parting shot of one of the posters, this one for the SL Genetics Center. All in all a remarkable day, and an effective use of SL. I've even got an inventory full of junk now I have to sift thru!.

Second Life Best Practices in Education

2007-05-25T08:10:00.001-04:00

Popped into the SL Best practices conference. Hit the registration tables, got my gift bag, off to a discussion about DRM and contracts in virtual space.

Here's the scene at the presentation space...Parallels right now to Viacom v YouTube, discussion of safe harbor provisions as they will apply to Second Life. Real life money is involved in Second Life, real life legal action will follow.

What happens if someone misappropriates my content in virtual space outside of virtual space (outside of the 'rules' in Second Life)? There are layers of rights (game code, copyright) but do they give a practical answer?

Interesting angle...What happens when the players don't like what the game desigeners/owners are doing. Interesting because this could be seen as a game, but significant investments could be made in virtual space. How does freedom of speech, etc play in?

Second Life may be more open source. How about Creative Commons licenses? There are some mappings between the SL object permissions and CC permissions. What does CC give us in SL that copyright does not give us in SL? We need to be careful here about coding or contracting away rights that may be in copyright. Note this is from an Australian perspective.

Next pres, Profiling e-world customers...This is an e-marketing presentation.

personalization of products and services (CRM)
online profiling of customers (what's that)?
all e-world transactions leave traces of data
issues involving trust, accuracty, privacy

Online profiling is practice of aggregating info about consumers lifestyle, product preferences, purchase history. Adds up to info on customer's buying behavior. Now talk about SL specific approaches..

Brands and self image apply in virtual space. Research discussed addressing the issue of online profiling by introducing self-profiling. Capture online ideal self-image via brand personality. What evolving brands traits could be highlighted online? SL objects must be designed in a way to construct an ad-hoc shopt display for each customer, sensing their profile, brand identity, self profile.

Between presentations. It's interesting to watch typical real life confo behaviors play out in virtual space. Small groups congregating, people walking in to check the scene, and deciding to attend the other talk after looking at the boards. Presenters trying to figure out how to get their slides to show, etc. IOW oddly familiar. Also cool is how people linger to associate, and look around to check who else is in the room. Lots of networking going on, and informal off-line talk.

Into a panel discussion now... gonna sneak to the Grind for coffee. Just like a real confo!

OK..came back at the end of the panel..darn..took too long. Off to the vendor area, outreach, etc.

Popped in to a bit of discussion, SL Education is about collaboration and partnerships. Example, various teachers can swap sections to teach content that they are best at, and enjoy teaching the most. The content is the focus.

That's a shot from the discussion area. I'll wander over to the exhibits now. Saw the Moodle Booth, vendors who build sims, libraries. Here's an interesting thing, a booth for the National Underground Railroad Freedom Center, who will be coming to Second Life...

More wandering..

Digital Campfires Foundation, looking at creating thinklets within second life. UTD has an impressive booth, going to have to visit their campus. Some discussion ensued about an open source model within SL. SLForge was one attempt to start this. Perfect for higher ed!

Schome looks like an interesting pilot project. "Schome park was the site of a pilot project during which over 100 memebers of NAGTY (National Assoc of Gifted and Talented Youth) collaborated with staff in Second Life to seek ways to transform educational spaces and practices"

Map of forces shaping future of education, from the Knowledge Foundation...Feed of current projects from My SL Project. Here's their academia edition. Saw Columbia College Chicago has a cool sim, I AM Columbia. I'm going to do a quick tele to their sim.

Checking out the galleries at Columbia College.

Back to the presentation hall. Instead of turning of our cell phones, we are reminded to kill all particles and animations. No SL bling for lag's sake.

Suzi Mazzenga (Xirconnia Morphett-SL) Drawing on Second Life Experiences to Enrich the First Life.

This presentation is being simulcast over the plain old web via SLCN (Second Life Cable Network) now.

Living outside of the circuit box...applying learning about self in Second Life to First Life...Compare your avatar in SL to real life. Mine is a virtual doppleganger. Or is your avatar a subconscious blueprint for making a better 1st life you?

What does your SL interaction say about you? Is your avatar a virtual extension of your personality? What does your SL home say about you? Did you put up a virtual wall to block your neighbor's view? Would you do the same things you do in SL in real life? Is there morality in SL? Various giggles and grins in audience.

Here's a shot of the talk, note the video screen showing the live simulcast.

How many have group meetings in SL? Do you have a traditional board room for meetings? Look at other non-traditional settings. Coffee shops, koi ponds...no walls, no chairs. Restrictions and expectations can be changed by working within SL as groups.

There is no 'back of the room' in SL collaborations. Gonna break out, do some RL work, and hit the IBM keynote...

IBM Promo Video on their new Virtual Biz Center

2007-05-24T15:16:00.001-04:00

The simple thing that stuck with me, back when I heard Dr. Irving Wladawsky-Berger talk at as part of the RENCI Distinguished Lecture series was the observation that the '2D' web was about taking the catalog and putting it into the browser, while the 3D web was about taking the whole store, sales staff included, and putting it in a virtual space. The purely commercial side of the web is not the whole story by any means, but I suspect that the next Amazon or Ebay will rise from the 3D web, and that makes this stuff exciting to watch.

So dig this little YouTube video about the new IBM Virtual Biz center. I took five and logged in, and happened upon the real virtual site, and saw this thing on the Eightbar blog. IBM's Second Life presence is impressive, and I often point people there when they let me know that the virtual web is just a game....

Approx 31 Blogging about moble + SL, Croquet

2007-05-24T08:46:00.001-04:00

Willi's got a bit in his blog about some prototypes we're working on. This one is meant to show on-scene disaster workers walking around assessing damage with gps and camera equipped mobile devices.

I messed with Croquet a bit yesterday. just out of interest, and also a bit because I was miffed at Second Life for deciding to bring the grid down yesterday. Such is life on the front end of the hype curve!

Initial impressions...

Second Life is more like the web, it has the chaotic, random feel that comes from random exploration, searching, and inputs from your social/professional network. Croquet has more of a self-contained, peer-to-peer feel. Right now I see Croquet as a targeted application development platform. I also see Croquet as lending itself to more abstract presentation. I really love the metaphor in Croquet of jumping through portals to navigate to new worlds! I'm quite sure I've only scratched the surface on Croquet, but it seems less collaborative, and more about cool new metaphors for information. In other words, I don't feel as much immersion, or presence of myself or others in the Croquet demos, but I do see more of a free-flowing, abstract experience.

That's not a knock, I see different horses for different courses. I'm even more of a Croquet noob than a Second Life noob, so take everything with a grain of salt. I've got to dive into Blender and Squeak, I think, before I really have a good grounding on the potential of Croquet.

Best Practices in Education Confo in Second Life Tomorrow

2007-05-24T08:35:00.001-04:00

By way of Kathy Kyzer..

Planning is currently underway for the first Second Life International Best Practices in Education Conference!

The conference will be held on May 25, 2007 in venues all over the Second Life world, with exciting presentations, vendors and exhibitors, and everything an educator needs to know to get started exploring the possibilities for teaching, learning, and research in Second Life!

Here's a link with more info

IBM Presentation on Virtual Worlds

2007-05-22T15:42:00.000-04:00

I think IBM has correctly identified the conceptual link between today's Web2.0 formulation and the future 3D virtual web.

Check out this presentation from the eightbar blog, now in my 2D Google Reader. One great point is made in a qute from Ian Davis' blog, where he says, about Web2.0, Web2.0 is an attitude, not a technology. It's about enabling and encouraging participation through open applications and servers.

I have been been asked several times why I'm messing with Second Life, when X, Y, or Z allows you to use your 3D modeling tool of choice to import a CAD drawing, etc. This is a very good question, and I can't claim to know the answer, but here are some observations.

First, I think it's been said that people working in technology A are probably better at predicting the future of technology B, which may be a less familiar field, than in their 'own' field. This could be true. I know that as a hard-core Java/J2EE developer, it took me some time, and distance, to understand the Web2.0 ethos, as well as the value of dynamic scripting languages such as Ruby. I think the same holds true thinking about virtual worlds. My immediate reaction to the questions about various virtual worlds is to try and remove the lens of past experience with 3D technologies.

Second, my reaction is to re frame the question, and to reconsider the 'things that matter' when judging virtual content. I helped (in small ways) as UNC worked on its Second Life campus. The natural first step was to make the UNC island look like UNC by building various familiar landmarks, such as the Old Well and the Bell Tower. Great...Then soon after the island opened up, Intelligirl took one look and pretty much said it can be a mistake to push the real world into the virtual. I took a step back, and had to agree that the virtual space is different, and is neither a game, nor is it real life. It needs to be taken as it is. The true goal in virtual space is not the ability to accurately replicate real life, the goal is to provide content formed by community participation.

Third, remember when Mosaic came out, and all there was was a tour of Amsterdam with some hyperlinked pictures? Anyone looked at any HTML source lately? HTML is crap, I'll go ahead and say it! The most important point is to imagine the end product based on the creative power of the participants, not on the nature of the component tools. Here is where Web2.0 comes into play. The power of Web2.0 is built from simple pieces of technology...RSS, HTML, AJAX, XML, etc. It's the fact that modest tools have been put in the hands of the many, with low barriers to entry, that's made the web a revolution. Comparing the tools in a space like Second Life to those on the workstations of professional designers is not the test! These comparisons lead to faulty conclusions. The real test is, does the environment provide sufficient facility to create compelling content, and enough critical mass to create communities around that content.? To me that's the test, much different than the ability to manipulate sophisticated polygons!

I'm still somewhat skeptical that Second Life is the answer. Its move towards open source gets things moving in the right direction, but if the Web2.0 analogy is to hold, than it implies that a walled garden will fail. Certainly the ecosystem is there, but new generations of web users are fickle, and will jump if a more open, buzz-worthy environment arises. My guess is that alternative virtual worlds will reach hype-parity with the current Second Life buzz, there will be an explosion, and potentially open source will move in to create some standardization. Either way, it's going to be an interesting, and increasingly virtual web.

Second Life controlling Real Life

2007-05-22T10:12:00.000-04:00

We're working with some ambient orbs for multiple purposes. Since we had one handy, I got a developers account for a custom channel, and slipped in a mash-up between the orb, and Second Life.

The basic idea of a custom channel is that you can call a URL for your own orb, and specify the current color and animation. These URL's look something like this...

http://www.theurltheygiveyou/thescripttheygiveyou.jsp
?devID=YOURDEVICEID&anim=0&amp;
color=12&comment=this+is+steady+green

And off you go. From that, it's a simple matter to plug in an HttpRequest in LSL. For this first cut, I just wanted to get the thing working, so I have a display, along with several color buttons. Push the button, the color display changes, and the correct site is called with the correct parms. This took all of a cup of coffee to get through, but I think it shows some interesting potential. One thing I've discussed for quite a while is the idea that the physical and the virtual are merging.

Anyhow, this changes the status of the orb on the ambient site, but I'm having a heck of a time getting the physical orb to respond. Perhaps there's a radio coverage problem, but I'll have to look into it...but this cap from my orb administration page shows that at least on the web site, my orb is the correct color.

The initial concept is to create a DEFCON style alert system. Since the scenario we're playing with is a sort of collaborative disaster management scenario, this SL widget could control a group of orbs for people that need to be alerted when something is going on. Perhaps the orbs on their desks start flashing red, and everyone teleports into the collaborative space...that sort of thing. Another more generic idea would be an app that can change the orb color based on whether anyone is in the sim, showing number of people, for example. If you were a help desk for a retailer running a virtual store, the orb could show the amount of foot traffic, and alert virtual sales avatars to pop in to close a sale.