Credit: slwtf.com

How Bad Was Second Life Enterprise?

This is the first post in a series about Virtual Reality in an Enterprise environment. I expect to talk about more positive experiences in future posts but I need to start somewhere, so why not with what did not work for us?

My (and my company’s) experience

Second Life for Enterprise was a failure, in my case, for several reasons. Note that this experience is my own, maybe other beta users had a better one. Linden Labs announced the end of the experiment in August 2010.

Let’s see what really did not pan out despite the promises of the platform.

Ideal conferencing – not.

Features that would really have brought it closer to the ideal conferencing tool were still far in the future:

1. Face capture and video feed embedded in avatar: this would allow other users to measure one’s state of mind through their facial expressions. We were sold on the idea through a cool video of Ashton Kutcher’s face mapped to this avatar’s “head” showing him interact with Second Life and expressing obvious delight at what he was seeing.
2. Seamless Office documents integration: what a leap in the future this would have been! The only alternative available when giving a presentation using Powerpoint was to take screenshots of every slide, convert them using suitable jpg settings, then map them as textures to wall surfaces in Second Life. Supposedly this painful exercise was about to become a thing of the past “anytime soon.”

Not worth the cost

“cost” can be interpreted in – at least – two different ways, both of which apply here.

Firsly, the entry cost to simply be a part of the beta, was between $50,000 and $100,000. For the first year.

For that money, you would receive two servers and access to an online help desk. Tickets only.

Secondly, the ownership cost was just too high. So many prerequisites would pop up as we progressed through the setup process that I reached a point when I became quite convinced that the Linden people had never talked to anyone who works in a big company. I could not imagine a use case that their process would satisfy.

To wit:

• the customer did not have root access to their machines; that part I can understand. However, in order to perform simple configuration, I needed to be able to get our IT department to poke a hole for incoming SSH sessions in our firewall at the most random times. The Linden gremlins would then come in through this wall and type whatever one-liner was required.
• software upgrades were performed by swapping the existing hard drives with new hard drives they sent in the mail. In order to perform the swap successfully, I needed to work with our IT guys to have unfettered access to the data center for two days. Alternately, I could ask for an IT guy’s time to be dedicated to this task for two days. The Linden people expected us to have someone continuously available to be on the phone with them as the upgrade went through. Note that, even if I did the upgrade myself, basic security rules require for IT personnel to be present in the data center at the same time as a non-IT person (me!) We originally thought this would be a non-issue as the tool was being marketed as a “turnkey” solution.
• support tickets could go unanswered for days and in some instances weeks. After several weeks of this frustrating dance, I finally realized what was going on: they were using the same ticket system for both enterprise customers and public grid Second Life users. Now, I do not know what their triage policy was but considering the delays in getting any kind of reply, I suspect it was not what an enterprise customer would have expected.
• I was not trying to do anything fancy; simply getting the servers up (which I eventually did) and run a few grids. Some of my basic questions left them dumbfounded. Questions I would have expected other beta testers to have asked as well.
• No tool was available to automatically export our existing public grid area and import it to our private grid. Instead, we had to compile a full inventory of every single prim, mesh, texture, animation, etc., and send them this list along with proof that we had all the copyrights cleared for all of them. They would then, after an indefinite period of time, send us an archive containing, hopefully, our stuff. That’s when I started looking into the banned tools that some enterprising users had created to “steal” content and transfer it to OpenSim (or sometimes for quite shadier purposes)

Irony

An important aspect of owning our private grid was using it to provide training to our customers. We already had at least one major account asking for virtual training since it would allow us to train geographically dispersed technicians. We were also considering the potential for internal training and this was obviously the first direction we would have taken the grid’s design.

Unfortunately, educational tools such as (http://www.sloodle.org/moodle/)[SLoodle] were only available for OpenSim, the free and open-source competing virtual world package.

Worse, Linden Labs added a paragraph to their “leasing agreement” (I do not remember what it was called exactly) that stipulated that we could only use the grid internally, which meant keeping customers’ employees off the grid. I talked to the salesperson about my concern with that clause and got verbal assurance that we would not have to worry about it. The agreement was not amended, though.

Unfortunately, that’s when I decided that it was definitely “not worth it.”

The aftermath

It is now obvious that Linden Lab’s proverbial heart was never really in the whole endeavor. Unfortunately, this means that the technologies I listed earlier, such as real-time face capture and seamless office integration, were never deployed in the enterprise.

Instead, we spent time and resources attempting to set up a product that did not offer the minimum set of features that would have benefitted our company. The vendor, likely realizing that they had waded in quicksands they knew or cared little for, threw the towel not long after I had decided to cut our losses.

An interesting take away lesson here is that, had we gone with an open-source alternative, we would now be working with a product that’s more current, was not end-of-lifed and for which plenty of support is available. And the return on investment would be, in comparison, astronomical.

Let me begin with pointing out that there are no Parallel Tools for Arch/Chakra but you can still make this work.


What you need

• Parallels 7
• Chakra Linux
• Kernel 3.2

Let’s do this

1. On your host, select Install Parallel Tools

2. Shell time! You may first need to mount Parallel Tools manually.

su
mount /dev/cdrom /mnt

3. Let’s make a copy of the tools and patch it for kernel 3.2.

mkdir -p ~/Tmp/PT
cd ~/Tmp/PT
cp -r /mnt/* .
cd kmods
tar zxvf prl_mod.tar.gz
vi prl_eth/pvmnet/pvmnet.c
Replace .ndo_set_multicast_list with .ndo_set_rx_mode
tar zcvf prl_mod.tar.gz prl_eth prl_fs prl_fs_freeze prl_pv prl_tg dkms.conf Makefile.kmods

4. And finally, let’s run the installer (cross your fingers!)

cd ..
export def_sysconfdir=/etc/rc.d
./install

You may or may not have to set correct the resolution in /etc/X11/xorg.conf. Personally I added “1920×1080″ logged out, logged back in…it just worked.

Note that all the host’s shares can be found in /media/psf/

So, here is my solution:

Create a short script

tell application id "com.devon-technologies.thinkpro2"
	set docInfo to the content record
	set docPath to get the path of docInfo
	tell application "Marked"
		activate
		open docPath
	end tell
end tell

Save this script as /Application\ Support/DEVONthink\ Pro\ 2/Scripts/DTInMarkdown.scpt
Note: your actual DEVONthink folder name may differ based on which version you are using.

In DT, select Script menu (icon)Update Scripts Menu: you should now see your new script.

From the System Menu, open System Preferences… then:
KeyboardKeyboard ShortcutsApplication Shortcuts

Create a new entry for DEVONthink Pro (or DEVONthink Pro Office); enter Menu Title: DTInMarkdown and enter a keyboard shortcut. I personally use Cmd+Shift+Return.

Now, next time you are editing a plain text/MarkDown document in DT, that keyboard shortcut should open the document in Marked.app for instant preview. Note that the preview is updated every time you save your document.

Atelier Teee

< rant alert! >
Like many of us who own somewhat traffic-friendly websites, my inbox has filled regularly with unsolicited SEO-related emails.
Of course, these offers are worthless. They will only get you links in traffic farms, which Google has learnt long ago to carefully avoid.
Due to this game of cat-and-mouse between these SEO companies and Google, they have been desperate to find new venues as well as new customers and that’s how I end up receiving the weirdest solicitations.

The latest funny comes from Manon, who works for strategiesreferencement.com, a french SEO outfit.
She sent me an email offering improved ranking for boyunderwear.clicdev.com. If you visit that website, you will see that it’s one of the tends of thousands of sites hosted by ClicDev (which I own) and that said site was suspended long ago for being a spam site, of all things.

I really wonder what, of the multitude of sites hosted by ClicDev, prompted such enthusiasm for one that sounds like it would host “tasteful pictures of young boys.”

Please note: not all SEO companies are run like clown cars. If you go with the right guys, you sites will likely enjoy a nice ranking bump.

Who are the right companies, then? I would say:

• the ones that come recommended by existing customers
• and who never sent you unsolicited emails

Unfortunately, keeping Shelves updated with Delicious Library’s information is too involved a process: select export, check all the correct variables, select separators, rename the exported file, etc. This is not a good process for the procrastinator in me.

So, I wrote a small application — a compiled Apple Script really — that queries Delicious Library’s database and exports the relevant information to a file placed on my desktop. This file is already called ‘Delicious_Library_Books.txt’ and I only need to copy it to my phone and re-import it every time I add new books to my collection.

I could of course work on it some more to, for instance, handle other types of collections, but it fits my needs as is. If there is a request for a more complete script, I may modify it accordingly.

In the meantime, if you think it could help you, you are welcome to download it!

Slider by Yamanaka Tamaki

A few months ago, needing an Android widget that would let me select values “naturally” using one or more sliders, I found Daniel Berndt’s excellent DateSlider.

I added a few functionalities to it:

1. Cohabitation of sliders in a tabbed interface
2. An “Enumeration” type of slider (so, not necessarily dates anymore!)
3. Sliders can now belong to a dialog or be embedded in an activity (ala progress bar)
4. Now truly self-contained in a jar zip file.

For more information on the new features, have a look at the additional readme file I created.

For those of you who have tried to play with these concepts, you will immediately identify a few painful items here:

1. How can a component be a dialog’s content, or not, at will?
2. How can a single component automatically persist its values, for instance over an orientation change?
3. How do you include all assets in a jar file when the SDK dislikes that?

These are the challenges that I had to address. I exchanged a few emails with Daniel about pushing these changes back to DateSlider’s main branch but I guess we’ve both been working on other things since July.

The source code is, of course, available on GitHub so for in-depth understanding, I would recommend having a look at the commit history.

Regarding the three annoyances mentioned above:

How can a component be a dialog’s content, or not, at will?

This was the easiest one. I simply refactored the parent class (DateSlider) so that it is now a child of LinearLayout rather than Dialog.
This object is now instanced normally, and two methods, asDialog() and asEmbed(), allow you to get the component properly wrapped.

How can a single component automatically persist its values, for instance over an orientation change?

The idea I had is a bit appalling but not too bad, in my opinion: dialogs come with their own onSaveInstanceState() method, which is automatically invoked when your application is about to be paused. That is, as long as this dialog was displayed using showDialog() rather than directly realized in your code. This takes care of dialogs.
Components found in a regular activity, however, have no such method. So, what to do?
My approach is to use an inner class representing an invisible dialog — conveniently called FauxDialog — that sits next to the slider, and that dialog is the one whose methods get invoked for saving and restoring your component’s state.

That invisible dialog’s style is:

    <style name="dateslider_InvisibleDialog" parent="android:Theme.Dialog">
        <item name="android:windowBackground">@null</item>
        <item name="android:layout_width">1px</item>
        <item name="android:layout_height">1px</item>
    </style>

and its save method can be as simple as:

        @Override
        public Bundle onSaveInstanceState() {
            Bundle savedInstanceState = super.onSaveInstanceState();
            if (savedInstanceState==null) savedInstanceState = new Bundle();
            savedInstanceState.putSerializable("time", getTime());
            return savedInstanceState;
        }

How do you include all assets in a jar file when the SDK dislikes that?

This one is actually VERY simple, thanks — again — to the guys at CommonsWare.

They provide an incredibly convenient file called ParcelHelper.java
This file allows developers to invoke a package’s resources through a class called, obviously ParcelHelper.

Therefore, all I had to do to turn DateSlider into a usable jar library, was:

1. Create a class called SliderController, that uses the singleton pattern to return an instance of ParcelHelper (I know! A singleton! Where is my pitchfork?)
2. Replace direct references to resources, such as

R.styleable.ScrollLayout_childWidth

with their helper counterpart:

SliderController.instance().getParcel().getStyleableId("ScrollLayout", "childWidth")

3. Rename the resources, prefixing them a string specified in ParcelHelper’s getParcel() method
4. And finally, after generating the jar file, store it into a zip file along with its own resources (i.e. icons and layouts)

Now, any developer who wishes to use this “library” can simply extract this zip file at the root of their project and the jar file and the renamed resources will be made available to their own code.

As usual, feel free to ask questions if there are things that make little sense to you in this fairly succinct write-up.

So, why this post? It’s for you, my friends, budding entrepreneurs who wish to bootstrap your business and know that every cent counts. Maybe you feel that you could host your product’s web site on a home computer. Maybe you need more control over what happens on that server. Or maybe you want to be able to log on to your development machine from anywhere in the world.

Whatever your reasons, you’re still here. So let’s get started.

1. NTP

First, for DNS updates to be accepted by BIND, the client that sends updates needs for its internal clock to be closely in step with the DNS’ clock. This is, of course, achieved by running the network time protocol (NTP) at both ends.

On RedHat:

yum install ntp

On Debian/Ubuntu/Mint:

sudo apt-get install ntp

OS X comes with NTP pre-installed.

Your NTP client should come with a configuration that will work with the distro’s own NTP servers. Check the content of /etc/ntp.conf. If no server is provided, you can still test your configuration against 0.pool.ntp.org. It is nowhere near as nice as adding your own ntp server to the ntp system though.

Start the NTP daemon; this is typically done using:

/etc/init.d/ntpd start

Install this daemon so that it will always be automatically started:

chkconfig ntpd on

In OS X, this is a much easier configuration: open System Preferences > Data & Time and check ‘Set date and time automatically’

On Windows, various options are available, including the open-source NetTime.

2. BIND

Here is a bit of info that you need to know: dynamic DNS will generate zone files that will not be human-readable. Therefore you are not going to want to maintain files that mix dynamic and static DNS information. That is why I typically make a subdomain dynamic while leaving the domain itself static. For instance, if you own the domain mydomain.com, I would recommend that you create a new zone for d.mydomain.com and only that zone will be dynamic.

If, on the other hand, you do not need to maintain both static and dynamic IPs, you obviously can make the whole mydomain.com dynamic.

OK, so that’s where I’m lying. By omission. After all there is nothing preventing you, as we shall soon see, to maintain a set of static addresses alongside the dynamic ones in your update script.

Let’s declare a dynamic zone in /etc/named.conf (or /var/named/chroot/etc/named.conf if running BIND in a chroot environment):

zone "d.mydomain.com" {
        type master;
        file "/var/named/data/d.mydomain.com.db"; 
        allow-update { key host1.d.mydomain.com.; };
};

This tells BIND that a client providing the correct key ‘host1.d.mydomain.com’ is allowed to update this zone file (d.mydomain.com.db)

This key needs to be present in named.conf as well:

key host1.d.mydomain.com. {
        algorithm hmac-md5;
        secret "< your public key here >";
};

We will see very soon where we get this key from. Note that you could decide that you wish to be cleaner and store that key in an external file.

So, that was easy. However, this approach gives access to a full domain (d.mydomain.com) to a single user as long as they have the correct private key in their possession.
What if you wish to share a domain among multiple users, each only allowed to modify their own host name?

That’s where ‘update-policy’ can be useful.
Here is your updated named.conf file to allow two different users to update their respective host info:

zone "d.mydomain.com" {
    type master;
        file "/var/named/data/d.mydomain.com.db"; 
 
    update-policy {
        grant host1.d.mydomain.com. name host1.d.mydomain.com. A TXT;
        grant host2.d.mydomain.com. name host2.d.mydomain.com. A TXT;
    };
};

Of course, the keys ‘host1.d.mydomain.com’ and ‘host2.d.mydomain.com’ need to be present in the same file.

OK, we’re almost there. Just one last bit of preparation will go a long way, though: make sure that the user BIND is running as has write-access to the zone hierarchy! Keep in mind that BIND will end up generating zone files, unlike with static zones.

3. UPDATES

Now, to update these zones remotely, we will rely on a traditional BIND tool known as nsupdate.
It is available on Linux and OS X. Instructions for installing on Windows can be found here and, of course, as usual Cygwin provides its own version.

Let’s generate a key for our host1.d.mydomain.com. host:

dnssec-keygen -a hmac-md5 -b 128 -n USER host1.d.mydomain.com.

This will output two files:
Khost1.d.mydomain.com.XXXXX.key
and
Khost1.d.mydomain.com.XXXXX.private

Get the key from the first file (just the segment that ends in ‘==’) and use it to replace ‘< your public key here >‘ in named.conf.

You can now focus on the client.

Here is a sample script I wrote that will perform a very minimal update every half-hour. This script lives in /home/< your home dir >/DNS_KEY along with the Khost1.d.mydomain.com.XXXXX.private file.
Obviously you will need to modify < your home dir >, < master DNS name >, host1.d.mydomain.com and Khost1.d.mydomain.com.XXXXX.private:

#!/bin/bash
 
# Servers: http://dynupdate.no-ip.com/ip.php, http://www.antedes.com/getip.php, ..?
# Less straifghtforward: http://checkip.dyndns.org/, ...
IPS=http://dynupdate.no-ip.com/ip.php
 
DNSP=/home/< your home dir >/DNS_KEY
 
while true; do
 
# First, retrieve IP address
	CURIP=`curl -s $IPS | awk '{ print $1 }'`
	OLDIP=`cat $DNSP/oldip`
 
# Compare to previously saved IP
	[ "$CURIP" == "$OLDIP" ] && continue
	echo $CURIP > $DNSP/oldip
 
# If different, tell DNS
	echo "server < master DNS name >" > $DNSP/zone
	echo "zone d.mydomain.com" >> $DNSP/zone
	echo "update delete host1.d.mydomain.com. A" >> $DNSP/zone
	echo "update add host1.d.mydomain.com. 14400 A $CURIP" >> $DNSP/zone
	echo "show" >> $DNSP/zone
	echo "send" >> $DNSP/zone
	/usr/bin/nsupdate -k $DNSP/Khost1.d.mydomain.com.XXXXX.private $DNSP/zone
 
# Sleeeeeeep I tell you
# 1800 = 30 minutes
	sleep 1800
done

You can install this script on Linux as your own daemon or run it manually using ‘nohup < scriptname > &’ or get rid of the loop and use crontab.
On OS X, I ask Lingon to start it early on.

Do not modify the 30 minutes sleep time; be polite to these services that provide your IP for fre.

CONCLUSION

Of course, you want to remember to restart BIND so that it will read its new configuration. It will not need to be restarted again; it will automatically integrate all dynamic updates.
Hope this helps and as usual if you have questions I will try not to ignore them for too long

What’s new in RootTools 1.5?

Mostly build improvements: a new AndroidManifest.xml file for easier building in Eclipse; example version number is now taken from the manifest file; new makejar.ant for building and zipping the library.

This version also offers a new function: isNativeToolsready(). This function does a silent install/check for correct install of the nativetools binary (you could conceivably use your own binary as you provide your resource id to the function)

What is NativeTools 1.0?

It’s the piece that has been, until now, missing from the equation. I recommend reading readme.md for more information but the short version is that NativeTools provide C/C++ functions in a convenient package that you can invoke to perform all sorts of operations (retrieve partition size, get file content, etc) without having to worry about the current device’s shell idiosyncrasies.

Its other advantage is that is runs much, much faster that performing the same operations recursively in Java.

Also somewhat dangerous: the notion that your status bar’s height will be (your visible area’s height – zero). Google never made any commitment that the status bar will always start at pixel zero.

So, here is how I do it:

        Rect outerRect = new Rect();
        Rect usableRect = new Rect();
        Window window= Home.getInstance().getWindow();
        window.getDecorView().getGlobalVisibleRect(outerRect);
        window.getDecorView().getWindowVisibleDisplayFrame(usableRect);
        statusBarHeight = usableRect.top - outerRect.top;
        // Sometimes, status bar is at bottom...
        int bottomGap = outerRect.bottom - usableRect.bottom;
        if(bottomGap > statusBarHeight) {
            statusBarHeight = bottomGap;
        }

The solutions offered here have a few downsides, not least of them being the copy operations; however they are kept to a minimum.

Upon closer inspection you will notice that this code tries to deal with two-dimensional arrays by storing booleans in a [row][col] array; it is outside the scope of this post but, yes, I am using integers as bit fields to represent these booleans. The memory savings are huge.

Solution #1 — for an array growing linearly
I know that this table will be filled “top to bottom” so I simply double its size whenever I am about to reach its current boundary. If I waited to effectively reach the boundary, a loop relying on size() would not go beyond its original size. Since we are using this boundary, this is not geometric growth but staggered linear growth.

    class GridInfo {
        int mSize;
        int mRow[];
 
        public GridInfo() {
            this(2);
        }
 
        public GridInfo(int size) {
            mSize = size;
            mRow = new int[mSize];
        }
 
        public int size() {
            return mSize;
        }
 
        void resize() {
            int resizedArray[] = new int[mSize * 2];
            System.arraycopy(mRow, 0, resizedArray, 0, mSize);
            mRow = resizedArray;
            mSize *= 2;
        }
 
        void flickOn(int row, int col) {
            if(row + 1 >= mSize) resize(row);
            mRow[row] |= (2<<col);
        }
 
        void flickOff(int row, int col) {
            if(row + 1 >= mSize) resize(row);
            mRow[row] &= ~(2<<col);
        }
 
        boolean isFlicked(int row, int col) {
            if(row  + 1 >= mSize) resize(row);
            return ((mRow[row] & (2<<col)) != 0);
        }
    }

Solution #2 — for a random-access array
Here, the developer using this class may decide to look ahead for a value that may or may not exist. By resizing the array to 2 to the power of (log2(our desired row number’s)+1), we make sure that this yet uncharted territory exists.

    class GridInfo {
        int mSize;
        int mRow[];
 
        public GridInfo() {
            this(2);
        }
 
        public GridInfo(int size) {
            mSize = size;
            mRow = new int[mSize];
        }
 
        public int size() {
            return mSize;
        }
 
        void resize(int row) {
            int l2 = 1 + (int)(Math.log(row + 1) / Math.log(2));
            int pw = (int)Math.pow(2, l2);
            if(pw > mSize) {
                int resizedArray[] = new int[pw];
                System.arraycopy(mRow, 0, resizedArray, 0, mSize);
                mRow = resizedArray;
                mSize = pw;
            }
        }
 
        void flickOn(int row, int col) {
            if(row + 1 >= mSize) resize(row);
            mRow[row] |= (2<<col);
        }
 
        void flickOff(int row, int col) {
            if(row + 1 >= mSize) resize(row);
            mRow[row] &= ~(2<<col);
        }
 
        boolean isFlicked(int row, int col) {
            if(row  + 1 >= mSize) resize(row);
            return ((mRow[row] & (2<<col)) != 0);
        }
    }

Of course, make sure to pick an initial value as close as possible to what you expect your array’s average size to be. “2″ is not a very likely choice in most cases.