admin's blog
Opensim/Drupal integration for education - proposal and call for help
June 24, 2008 – 11:05 pmWell… i’m finally getting my teeth back into opensim and finding that there are a couple of things i’d like to get built over the next couple of months. We’ve already gotten a good start on the automated installer for opensim, but what i’d really like to do now is attempt an integration with drupal. I’ll be keeping my running requirements list for that integration on the openhabitat project page and will hopefully pop a few updates into here from time to time.
What I need
I need two things.1. I need a good drupal/opensim programmer. Someone familiar with both platforms who can spearhead the drupal integration (or, if you like opensim integration).
2. I need some sense that there are other folks in the British Higher Education community who would find this integration compelling for an application to the emerge community for extra funding.
I have been working on 'Being Here Now.'
I've determined, this deceptively simple strategy is probably the most effective. When you notice your thoughts wandering astray, say to yourself
"Be here now"
and gently bring your attention back to where you want it.
You may notice that your mind often wanders (as often as several times a minute). Each time just say "Be here now," and refocus.
I also recommend watching this video:
So it took me awhile to truly understand JavaScript closures. There is limited documentation of the subject on the web, but here is a list of the resources I used to finally grasp not only what specifically creates a closure, but also why we would want to use them.
- JavaScript: the Definitive Guide
- Douglas Crockford: Private Members in JavaScript
- JavaScript Closures for Dummies
- jibbering.com/faq/faq_notes/closures.html
First, let's define closures:
- A "closure" is an expression (typically a function) that can have free variables together with an environment that binds those variables (that "closes" the expression). - Jim Ley
- ...JavaScript has closures. What this means is that an inner function always has access to the vars and parameters of its outer function, even after the outer function has returned. This is an extremely powerful property of the language. - Douglas Crockford
- Things are different if you save a reference to the nested function in the global scope. You do so by using the nested function as the return value of the outer function or by storing the nested function as a property of some other object. - JavaScript: the Definitive Guide
- Simply put, a closure is a variable, created inside a function, which continues to exist after the function has finished executing. - Patrick Hunlock
I should preface the more detailed explanation below with a few prerequisite concepts. If you don't truly grasp these concepts, then you may get hung up when trying to understand JavaScript closures. Fortunately, your quest to understand closures should force you to understand these concepts on a deeper level first.
- global object and global scope
- reference types and primitive types
- lexical scope and the scope chain
- the call object or the ECMA activation object
- idea of persistent data
- private variables
- using return
To begin, we want to create a reusable function containing data that persists across invocations.
We don't want to hard code variables into the reusable function, and a local variable will not persist.
From what we have learned by our 'Responsible JavaScript for the Enterprise' guidelines and through our understanding of the call object, lexical scope, and namespacing: we also know that we want to greatly limit global variables in our global scope.
So instead, we want the developer to make two calls: One, to set up or 'configure' the function, and two, to invoke this 'pre-configured' function.
The power is in the first call. I like to refer to it as the configuration call.
During the configuration call, we 'freeze' the inner function by setting a reference to it in the global scope.
So this data persists. Why?
We have an external reference to this inner function.
The inner nested function retains its reference to the call object of the outer function.
The outer function's local scope resolves and the reference to its inner function remains.
This is an example from a friend that helped me finally wrap my head around the power of the technique.
function configEquation(A,B,C){
//The equation: Ax^ex1 + Bx^ex2 + Cx^ex3
//The exponents are ex1, ex2, and ex3
//The coefficients are A, B, and C and are set
var ex1 = 2;
var ex2 = 1;
var ex3 = 0;
//The exponents constitute a quadratic equation.
function theEquation(x){
var result = A * Math.pow(x,ex1) + B * Math.pow(x,ex2) + C * Math.pow(x,ex3);
return result;
}
return theEquation; //notice we return the reference not the invocation of the function(no params)
}
var myEquation = configEquation(2,3,0); //the configuration call
alert('myEquation, x = 2: ' + myEquation(2));
alert('myEquation, x = 5: ' + myEquation(5));
var myEquation2 = configEquation(1,1,1); //a 2nd configuration call
alert('myEquation2, x = 2: ' + myEquation2(2));
alert('myEquation2, x = 5: ' + myEquation2(5));

I know it is fairly well documented around the web that some of the old 'ROR up and running' tutorials are a bit difficult to digest with the new features in in Rails 2.0. So, I wanted to document my findings. And provide links to the resources that have helped me.
Here's a couple of resources to get started:
akitaonrails.com
weblog.infoworld.com
Stay posted for more of my findings.

So I am calling it Generic American with a splash of Modern Vintage...I guess. I'm having one of those moments as a designer when the 'correct' images are present in my mind's eye, but for various reasons they haven't formulated on the canvas. Yet...but what the heck - I'm in no real hurry. I want to savor the taste of this one.
I absolutely love working on peacefield.info. It is a designer's dream, absolute creative freedom. An opportunity to shine, explore, create and innovate.
So what do I have to work with? Not much yet, and that is ok in some respects, because I don't want to ever steer away from my built in 'open source' aesthetic: championing the best of free fonts and hacked, and neo-Dadaist imagery. This new concoction hopes to blend cinematic urban cityscapes, with an adaptation of the ever trendy rustic earth tone color palette.(see my post on the the Neo-Green Aesthetic)
Actually, keyboardist R. Bruce Phillips says it best:
Peacefield isn't so "Pleasantville." It's grittier, even darker maybe -- or at least it has that side. Kind of like in the face of the ubiquitous B&W photo of the old man who lives on the street. He is generic, he is vintage. His face tells who knows what variety of stories? Some lovely, and some horrific, to be sure.
But there is peace still. His old weather face still attracts us.
Some may not see readily the quality of peace about this town. They might think it a contradiction, or irony, that the gritty, mysterious town has such a "nice" name as "Peacefield." Of course, America is full of contradiction and ironies, and people who don't get it when others do.











