What they’ve done is make it so you have to buy back your privacy. I blogged about this back in 2010, although I predicted it would be Facebook who would create the Privacy Marketplace. I should have seen that it would move further upstream to the ISPs. I mean, it makes sense… Your ISP knows everything you’ve been up to (including Facebook activity), so that’s where the most valuable data is going to be. What Congress did this week was essentially grant ownership of that data… YOUR data… to your ISP.

AT&T used to offer a plan at a reduced cost if the user opted to allow their data to be used. Now, they don’t need to. Congress has given them the right to use your data without your permission. Now, they can charge you to keep your data private. To me, this seems tantamount to renting a hotel room and when you get there, they tell you that it will be extra to get drapes and a door.

A more productive structure would be to establish personal ownership of browsing data and make it so providers have to buy access to it. It only makes sense that you own the digital exhaust that you create. If that’s worth something to someone, there should be a fair market value for that data – and you should be compensated for it.

What you can do about it

You could use something like the Tor Browser or DuckDuckGo for searching and this keeps your activity somewhat more private, but your ISP knows every site you hit as well as any URL encoded parameters you pass (like a Google search query for “kittens”: https://www.google.com/q=kittens, and the DuckDuckGo equivalent: https://duckduckgo.com/?q=kittens). DuckDuckGo won’t track you or sell your data to marketers, but your ISP will have that URL to know you searched for kittens and market Fancy Feast to you. Tor is a bit better in that it does quite a bit to obfuscate your activity, but your ISP could still track the initial traffic through the cable modem in your house.

Until (and unless) Congress puts protections back in place to make your data your own, your best bet to keep your activity private by setting up your own VPN. That way, your ISP will only see traffic to one URL. Beyond that, your VPN will control your internet traffic beyond the prying eyes (and sales departments) of your ISP. It might seem intimidating, but if you follow the directions it’s actually pretty straightforward to accomplish.

The biggest thing we can do about it is to keep up the pressure on our legislators and let them know that we don’t approve. No matter your political affiliation, there are ways to find your Representatives, and Senators, like this one. Make sure to call them to say that you’re not in favor of the government granting ownership of your data to the ISPs.

If we don’t fight to keep our privacy, the financial interests will certainly take it.

A while back, I wrote about a super-powered cloud-based search, Algolia. I loved it while I was able to use it, but my trial expired and the price tag was abit steep for a personal blog. I reverted to Dave’s WordPress Live Search, which did a great job, but didn’t have all the bells and whistles of Algolia.

Today, I received an email from the Algolia team announcing Algolia Search for WordPress. This made me happy. I wasted no time installing the plugin. After logging in to my Algolia dashboard, I copied and pasted my API keys into the Algolia Settings and it kicked off an index. The results were available almost immediately.

Algolia gives you control over several aspects of the behavior:

Autocomplete gives you control over the types of items that are included in the typeahead behavior: Posts, Pages, Categories, Tags, etc.

Search page allows you to use default WordPress behavior for the results page. You can use the Algolia backend which corrects typos, but doesn’t allow filtering. Or, you can use the full Algolia search functionality which provides instant searching and filtering.

Indexing allows you to select which aspects of your site you would like in the Algolia index.

Logs let you see how people are searching your site, and Settings are where you manage the connection to the API.

Check it out on this site. The typeahead and instant search are pretty sweet.

I did manage to find an improved tactic to the statistical confidence path I went down using only a Raspberry Pi and LIRC to decode. The hero of this story is really Michael Flaga, who extended Arduino-IRRemote to include Magiquest wands as remotes. His awesome library can be found on github.

But, first things first…

Wiring Up The Arduino

None of this will work without an IR sensor. So, the first task is to get that wired up.

It’s only important to remember that the Ground goes to ground, the Voltage goes to +3.3v, and the Signal goes to Pin 11. You could use a different pin, but the default configuration should work fine. I used a SainSmart Mega 2560, but you could use most any Arduino you have laying around. You’ll be wanting to connect your Arduino to a machine to receive the decoded output, so a USB cable will help. I ran my USB cable to a Raspberry Pi so the whole unit could sit on top of my kids’ dresser.

Talk To Me, Goose!

With the decoding of the Magiquest wand being handled by mflaga’s library, the critical component of the system becomes communication with the downstream platforms. First, make sure you have the Arduino-IRremote-master Library loaded into the IDE. While in Arduino, select Sketch > Include Library > Add .ZIP Library and select the zip file downloaded here. After that, make sure you’ve gone to Tools > Board > Board Manager and selected the right board. Mine compiled best under Arduino AVR Boards 1.6.9. That should avoid most of the compile errors I saw under other versions.

I began by loading IRrecvDump onto the Arduino and writing a basic Python program to read the output.  The Python code looks like this:

import serial

ser = serial.Serial('/dev/tty.usbmodem1421', 9600)

while True:
	s = ser.readline();
	print s;

Note: you may be operating on a different tty. To find the exact location of your Arduino, type

ls /dev/tty*

and look for the unusual usb port. That’s the one you want. Also, if you haven’t already, you may need to install pySerial by typing

pip install pySerial

At this point, you should be able to fire up the Arduino, start the python script shown above, and get a response when you flick your wand at the IR sensor. But, it probably comes out “Decoded – Magiquest, magnitude = X, wand_id=Y…”, etc. The challenge is to be able to do something with it.

Now, You’re Speaking My Language

So, you could certainly parse what’s being returned from the Arduino as is, but in order to make it more useful, let’s get the Arduino to output something more universal, like JSON. So, back to the Arduino sketch.

We’ll need to teach the Arduino some new tricks to construct our JSON. Fortunately, there’s a library for that, too. Benoit Blanchon has written the ArduinoJSON library that you should go ahead and download. We’ll import it the same way we imported Arduino-IRremote above. Make sure to include it in your project so the top of the Arduino sketch looks like this

#include <ArduinoJson.h>
#include <IRremote.h>

Next, we need to set a buffer for our JSON and create the JSON object. Add this just below your declarations

StaticJsonBuffer<200> jsonBuffer;
JsonObject& root = jsonBuffer.createObject(); 

Since we’ll be decoding the output as JSON on the receiving end, the next thing to do is update the “Starting…” message to be formatted correctly. Update your setup() block to look like this:

<code class="language-cpp">Serial.begin(9600);
Serial.println("{\"message-type\":\"initialize\",\"message\":\"starting...\"}");
//Serial.println('starting...');

Next, we want to remove the extraneous printing from the ENABLE_MagiQuest loop and let the Python code know a wand message is coming through, so update that code to look like this:

#ifdef ENABLE_MagiQuest
  else if (results->decode_type == MAGIQUEST) {
  #ifndef IS_AVTINY
    root["message-type"] = "wand";
    //Serial.print("Decoded MAGIQUEST - Magnitude=");
    //Serial.print(results->magiquestMagnitude, HEX);
    //Serial.print(", wand_id=");

Notice I commented out the Serial.prints and changed the message-type to “wand”. Now, the actual data dump happens in the ENABLE_RCMM block, so that’s where will update next. We want to stop all the raw code printing and construct the rest of our JSON object. Update that block to look like this:

#ifdef ENABLE_RCMM
  else if (results->decode_type == RCMM) {
     Serial.print("Decoded RCMM: ");
  }
  root["owner"] = "Undefined";
  root["message"] = "";
  if(results->value==0x10CF2401){
    root["owner"] = "Ellie";
  }
  if(results->value==0x1B9BA421){
    root["owner"] = "Edison";
  }
  if(results->value==0x11911A81){
    root["owner"] = "Dad";
  }
  root["wand-id"] = String(results->value, HEX);
  root["bits"] = String(results->bits, DEC);
  root["magnitude"] = results->magiquestMagnitude;
  root.printTo(Serial);
  /*Serial.print("Raw (");
  Serial.print(count, DEC);
  Serial.print("): ");

  for (int i = 0; i < count; i++) {
    if ((i % 2) == 1) {
      Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
    } 
    else {
      Serial.print(-(long)results->rawbuf[i]*USECPERTICK, DEC);
    }
    Serial.print(" ");
  }*/
  Serial.println("");
#endif //ENABLE_RCMM
}

I set the owner to undefined up front, but update it if I find the HEX code for a wand I know. I got this from printing the values from the dump and just put in if statements. You could probably do this on the Python side or even register them in a database and pull them from there, but this was quick and dirty. I set message to an empty string, but you could potentially pass other things as well, if you needed to. I appended the wand-id, the number of bits in the signal, and the magnitude of the flick, which is passed with the remote signal. After that, I commented out the block that was the raw output from before.

The last thing to do is to update the loop() block to spit out our JSON rather than the raw code. Update it to look like this:

void loop() {
  if (irrecv.decode(&results)) {
    //Serial.println(results.value, HEX);
    dump(&results);
    delay(250);
    irrecv.resume(); // Receive the next value
  }
}

That’s it. Compile the code and upload it to your Arduino. Next, the Python.

I Hear Ya

Now, we need the Raspberry Pi to listen for the wand codes and do something in response. I decided for testing sake, to open different web pages based on which wand was being used. User your favorite text editor and create a script like this:

import serial
import json
import time
import webbrowser

ser = serial.Serial('/dev/tty.usbmodem1421', 9600)

while True:
	s = ser.readline();
	#print s;
	#print len(s);
	j = json.loads(s);
	print j['message-type'];
	if j['message-type']=="wand":
		print j['owner'];
		print j['wand-id'];
		if j['owner']=="Dad":
			b = webbrowser.get();
			b.open_new('http://devinhenkel.com');

		if j['owner']=="Ellie":
			b = webbrowser.get();
			b.open_new('https://scratch.mit.edu/users/ScratchUser/');

So, I’m just parsing the JSON and printing the message-type. If the message-type is “wand”, I check to see who the owner is. If I recognize the owner, I’m opening different URLs in the default browser. I saved the file as wands.py and ran it from the terminal with the command

python wands.py

Once I did, I saw the “initialize” message-type print to the console. Waving the different wands at the Arduino opened different URLs in the browser. Success!

Beyond The Browser

What I ended up doing was buying a WeMo Switch and setting up a WeMo Server on the Raspberry Pi. Using curl, I was able to ping the server when I recognized the wand and used it so the kids could turn the Christmas tree on and off with the wands. The possibilities are really limited only by your imagination.

I’m working on setting up multiple sensors and giving them each an ID. That way, I can pass the JSON to a Node.js server and have it centrally manage the interactions. I recently got an Amazon Echo for my birthday, and I’m thinking about setting up an Alexa skill to cast a spell. That way, the kids can tell Alexa what spell they want to cast which will set a property in a cloud database, then when they flick the wand the Raspberry Pi can read that property and react differently depending on the spell cast.

Sorry it took me so long to post this. I’ve put the full Arduino sketch and Python script here if you want to use it as a starting place.

will turn the sprite toward the top of the screen and move it 10 steps. You can actually create pretty sophisticated software using these tools.

For the robotics piece, I bought an OWI-535 Robotic Arm Edge kit to put together with the kids. We worked on it 3 nights in a row, but got it assembled. Using the 5 switch controller, I was able to use it as a utensil to eat a breakfast sausage. Innovation! Putting it together was a great experience because the kids got to see and understand the inner workings. The only downside was that the switches were a bit fiddly and sometimes require adult-strength fingers to control it.

So, I did some research and found a USB adapter for the arm. Installation was easy, but the software that comes with it only runs on Windows. I could have run a VM and installed the software there, but since my goal was to get to the point where my kids could program it, I decided to find a more open source way to control it. Some Googling unearthed a python package designed to do just that: Roboarm. So, I fired up the Raspberry Pi 3 and opened the terminal. Installation was as easy as:

pip install roboarm

It automatically handles the connection to the OWI and the syntax is pretty straight forward:

from roboarm import Arm
arm = Arm()
arm.wrist.up(1)
arm.grips.open(1)
arm.led.on(2)

This will move the wrist joint up for 1 second, move the grips open for a second, and turn the LED on for 2 seconds then turn it off. You can view the documentation at the git site. This took care of the connection from Python to the OWI, but now we needed to connect Scratch to Python. Fortunately, the offline editor comes pre-installed on the flavor of Debian installed on the RPi, otherwise, you can follow these instructions to install it on Linux.

Google to the rescue again! I was able to find a Python library for communicating with the Scratch offline editor. You can find scratchpy on github. Once again, installation was a breeze:

pip install scratchpy

was all it took, and we were off and running. We did the tests outlined in the readme, then it was time to put it to work. First, we created a Python script to listen for broadcasts from Scratch and execute whatever actions Scratch fed it:

def listen():
  while True:
    try:
      yield s.receive()
    except scratch.ScratchError:
      raise StopIteration
for msg in listen():
  if msg[0] == 'broadcast':
    exec(msg[1])

Saved this script as roboarm.py and, then, we just needed Scratch to tell Python what to tell the OWI:

Would fire off a bunch of broadcasts in the form of {“broadcast”: “arm.base.rotate_counter(1)”} that roboarm.py was listening for. When it received them, the exec() command would execute them as if we were typing them into the python prompt.

Now, I’ve challenged the kids to come up with clever ways to use this – maybe a game that involves the robot arm moving something, maybe a robot dance… I’m leaving it up to them, but we’ll find something cool to do with it.

There was a time where we were trying to think how we could use Squeak as an enterprise tool. Alan agreed to spend the day with us to think it through. We didn’t end up doing much with it; mostly because we didn’t have the time to invest. But, he brought Dave Smith with him that day who was really freaking smart himself.

Fast forward a number of years and I saw his name pop up in conjunction with a kickstarter project. It was for an affordable, portable VR headset that was focused on quality, the Wearality Sky. So, being a longtime fan of VR and knowing what a freaking smart guy Dave was, I was an early contributor.

Virtual Reality and I go a long way back. My first degree was heavily focused on 3D animation and I was an early adopter of VRML. At the time, I thought I was a pioneer of “experiential poetry,” where words were mixed with environments that the user could navigate through. The only issue at the time was that the interface was a bit clunky and it took a really powerful computer just to render the environments (complete with 3D audio). Now, with Unity, Google Cardboard, and ubiquitous broadband, the time is ripe for VR and AR. Just ask Pokémon Go players.

In fact, I wrote about the evolution of Viewmaster last Christmas. The device did a great job of melding the Viewmaster experience with VR/AR content. However, the quality of the VR felt a bit like a toy.

Enter Wearality Sky. My unit just arrived yesterday.

It’s only been 24 hours, but I can safely say this is the best VR headset I’ve used – and it folds to fit in your pocket! At the heart of Wearality are high quality Fresnel lenses (courtesy of Lockheed Martin).  The lenses provide a 150 degree field of vision, which is significantly more than the standard 90-100 degrees from other units. The difference is substantial. The experience is far more immersive than other headsets I’ve used.

It works with Cardboard apps, so there’s plenty of content out there. But, you’ll be able to enjoy that content more because it fills in your peripheral vision more completely. At first, the image quality didn’t seem that great to me, but I realized that wearing my glasses fixed that. It fits comfortably over glasses, too.

If I have a complaint about Wearality Sky, it’s that the documentation is a bit sparse. It took me longer than it should have to figure out that what I thought was the carrying case, was actually the fabric shroud to block out side light. It comes with a snap-on headstrap that is easy to install.

Here’s how freaking cool you’ll look wearing the unit:

Registering the unit to work with Cardboard was as easy as pointing it to a QR code. After that, I could open any of my Cardboard apps and see it in a new way. Personally, I recommend checking out Revolt by Muse – it’s like being inside a music video, but there’s enough content out there to keep anyone entertained for a long time. With companies promising to deliver sports content in 3D, the body of content is constantly growing.

If you’ve been dying to experience VR and want to do so in the most shareable way, I recommend the Wearality Sky as an option.

So, in short, somewhere in Facebook’s data lake, there was a connection between my coworker liking a Facebook page at a festival, and me browsing the site for that product. So, let’s dig into the creepy…

Ultimately, for my coworker/friend, the linkage is pretty straightforward. Because he wanted an EpiServer tee shirt, he executed an explicit task to Like their Facebook page. As a result, a node was created (coworker:Person [:LIKES { company: EpiServer }]). For me, the tracking is a little (well, a lot) more insidious. The culprit, as it turns out, is the Facebook Like button on EpiServer’s home page. I used Abine’s Blur plugin for Chrome and saw that 10 requests for information from 3rd parties were being executed when I visited EpiServer’s site. If you’d like to learn more about how 3rd parties track your activity, there’s a pretty good primer at Business Insider. At this point, a node was created (devinhenkel:Person [:VISITED {company:EpiServer}]). In order to create the mapping that spawned the Facebook suggested post, it was really just a matter of finding all relationships between :FRIENDS who had a relationship with company:EpiServer. Doesn’t really seem all that creepy until you consider the scale of the graph.

So, Facebook maintains a graph of not only the actions you’ve taken on Facebook (like my coworker), but also the actions you’ve taken elsewhere as a Facebook user (like myself) and has the capability to surface the relationships between those actions. By comparing those interactions with interactions of the overall Facebook population (which numbers ~1.65 Billion users, at this point), they can make some fairly qualified predictions about you as a person. I’m reminded of the time Target was able to predict a teen daughter’s pregnancy before her family knew.

What can Facebook predict about you based on your online behaviors?

I kid. It was actually a great event.

My company had a booth on the floor of the Community Pavillion and people would stop by to discuss their concerns or just see why a company like mine (which is better known for accounting) would have a booth at a Creative/Marketing event.

One person who stopped by worked for a major sports and entertainment company. He had seen some of our social traffic talking about personalization and decided to see if we had anything to offer. “I’m having a hard time personalizing sports content. I feel like sports fans will get the content without me personalizing it for them,” he said. “I’m a Syracuse fan,” he continued, “and I know where to go to get the good content”

I said, “I’ve been to your site. I’ve flipped the switches that identify the Blackhawks and Cubs as my favorite teams. I think what ends up happening is that it constrains the content based on that.” He nodded and said that he didn’t feel like that was personalizing the content.

I recommended taking a look at one of the big coffee merchants. Much of what they personalize is adjacent to coffee. They suggest music and apps, and adjust the experience in their stores based on who you are. I suggested he could experiment with creating the “Syracuse Playlist,” or figure out what food pairs well with Syracuse. I would love for a brand to help me find local Beer Nuggets to have during an NIU bowl game.  Personalization is about delivering the right experience, not targeted content. Too many of us do the latter.

We think, “How can I tailor my content for specific users?” When we do that, we immediately make it about the content and not the person. This is inside-out thinking. The more appropriate question would have been, “How (and, more importantly, why) does a person engage with a sports team or content provider? What can we do to improve that experience?” Is that person a Chicago ex-pat living in Los Angeles? How do we get them to the bars where Bears fans gather? How do we get them Chicago-style dogs to eat? How do we play Chelsea Dagger to get them pumped for a Hawks game?

When it comes down to it, the best personalization isn’t about us, it’s about them. It’s about figuring out how to get people what they want, and sometimes what they don’t realize they want, yet. This isn’t easy. It requires deeper research than a handful of personas or segments. It requires some deep analytics to predict things no room of strategists would ever uncover. It’s about leveraging technology in altogether new ways to deliver experiences that are unexpected, but much more compelling as a result.

Given that I was fielding online orders, I set up a Google Sheet to track orders. Since I had the data in a spreadsheet, I decided to add a visualization to see which kinds of cookies were performing better than others. The chart seems to reflect what my gut would tell me anyway, but it’s still interesting to look at. I’d be interested to see how much the overall cookie numbers compare.

Next year, we’ll see if we can’t find some more creative ways to boost sales.

Collection: Ensuring that you have the right stuff in your bucket while keeping the wrong stuff out. Most search experiences could be improved a great deal by simply removing all the crap that nobody’s interested in from the index.

Selection: Being thoughtful about how you are pulling items from the bucket at query time. This is far and away the most difficult facet to get right. It means building a platform that anticipates user needs as it translates the user request into a response made up of items from the bucket in Facet 1.

Inspection: Giving the user the right levers to pull to refine the response from the platform. Where the platform’s ability to anticipate user needs stops, we can turn control over to the user to create a result set that is more satisfactory based on their specific needs.

Now that we have pithy names for each facet, let’s dig into each:

[inlinetweet prefix=”RT” tweeter=”devinhenkel” suffix=””]”Search relevance is driven by collection, selection, and inspection.”[/inlinetweet]

Collection

The first thing to do is to make sure that the information you are searching is as clean as possible. Claude Shannon called this “signal to noise.” Many times, the thinking is that better technology will do a better job of managing the same ol’ pile of crap that the last “better” technology failed to manage. But, it’s not just removing stuff from your indices. Cleaning house is good, but the problem is often that there’s no good description of the information to help the technology understand it. Segmenting your content into rational collections is a good start. Don’t just organize by where it’s stored; organize the content by purpose.

A solid metadata strategy is helpful, but difficult to maintain and ensure consistency. Semantic technology and machine learning can be leveraged to ferret out the relationships between unstructured and structured data to create dynamic metadata. As much as you can do any of these, it will only help.

More than anything, a solid model for your knowledge domain will help create a rational pool of information. I work in professional services, so the kernel of the knowledge graph is “People doing Work for Companies.” In a retail company, it may be “Sales Reps selling Products to Customers.” Whatever the primary function of your organization is, use that as the core of the knowledge model, and thoughtfully add information in a way that it can hang off that structure. Having explicit entities defined within the knowledge domain not only make the information segmentation more effective, but it allows for more specific requests for information.

Selection

Once you have a well-organized collection, having an algorithm that is tuned to pull the most relevant information is the next step.

Parsing: Understanding what the user is asking for is critical to being able to respond effectively. Natural Language Processing allows you to parse the user query to understand what it is they are asking for. Mapping entities found in the user input to nodes on the knowledge domain graph allows you to reach into the pool of data and return the most relevant information based on where it hangs off the knowledge domain graph.

Who’s askin’?: There are a number of data points about a specific user that can help determine how to tune the algorithm in order to present the most relevant results. If the user is logged in, you can use profile data about that user to help determine what is most appropriate. With mobile, it is possible to determine where and when the question is being asked. It is also possible to incorporate “I/me” as a query concept (e.g. “What’s my vacation balance?” or “Who have I worked with?”). The more you know about the user, the more effectively you can return the results.

Biasing: In certain cases, some sources of information will be more important than others. In other cases, it may depend on who’s asking the question or when/where they are asking for it in order to determine information priority. In still other cases, priority of information may be based on specifically what is being asked. It’s important to note that, just like security, biasing can be early- or late-binding. A mix of these approaches will yield the best results. It is also important to bias thoughtfully, because prioritizing one source up, by definition, means prioritizing another source down.

Inspection

No matter how clean you keep the pool of data you draw from, and no matter how intelligent you make the algorithm to reach in and grab information for the user, you will never be able to fully predict the context in which the user is asking the question. The best you can do is provide them with what seems to be the most relevant materials based on the way they phrased the query. At this point, it’s best to turn control over to the user and let them fine tune the relevance of the result set.

Our research showed that users, overwhelmingly, want information discovery to be a dialog. Users were perfectly fine if you didn’t get the result set perfect the first time, as long as you provided them with the affordances to refine the result set on their own. This means all the usual clustering/filtering of results, as well as the ability to search within results to get at precisely what is desired.

It was also important to respond with different kinds of results: a specific data point, a pointer to a source of record, or even tools to continue to explore information possibilities (e.g. a break-even analysis tool). Returning a list of links to documents is not enough anymore. We enhanced this capability by providing the ability to perform computational analysis of the underlying data in order to provide answers that were derived from (rather than stored in) the source data.

Conclusion

Thoughtfulness is at the core of a successful and relevant search experience. Begin with a thoughtful model that describes the knowledge domain. Next, thoughtfully incorporate data to the pool of available information in a way that relates to the knowledge model. Next, be thoughtful in the way that items are selected from the information pool so that the best possible starting point for information discovery is returned. Finally, provide thoughtful levers for the user to pull to further drive specific contexts to refine the returned results. If you manage to hit on all of these aspects, the resulting information is more likely to satisfy the user’s needs.

I’ve been involved with VR since the mid 90’s when I was coding “4D poems” in VRML. It seemed like every couple of years, VR would makes some noise and then fade back into the background. But recently, it seems like VR has reached a bit of a tipping point.

Starting most recently with the Oculus Rift‘s Kickstarter campaign, VR has been back in the headlines again. The promise of an affordable way to pump HD video into each eye to create stereoscopic vision got people excited about the possibilities again.

At the same time Oculus was making noise, there was a parallel effort to create a low cost version of a VR headset leveraging existing technology. I have been a participant in a kickstarter for just such an effort, the Wearality Sky. Basically, it’s a pair of high quality fresnel lenses and a frame to hold a smartphone. They have been focused on the optics because they realize that the technology you slip into the frame will keep improving, but they’ve done a good job of creating a flexible platform for phone-based VR.

Another example is an initiative that focused on driving the cost down to achieve a VR platform. In fact, it is so low cost that the platform is constructed out of cardboard. Google Cardboard is, at its core, a software platform. The cardboard frame was simply the cheapest fastest way to get the software into people’s hands (and onto their faces). They have SDKs for Android and Unity, so anyone with the specs can create Cardboard apps.

As with any good innovation, people will innovate on top of it. Enter Viewmaster. What viewmaster did was create a (relatively) kid friendly VR solution on the Cardboard platform. After a little bit of confusion figuring out what needed to be installed on my phone in order to get started, we were enjoying the Viewmaster Experiences within minutes.

Viewmaster still ships “reels” to enable the product, but these serve mostly as AR launchpads for the different apps. Pretty soon, we were jumping from biome to biome looking at 3D animations of animals in their natural habitat. We also explored some destinations with informational pop-ups over points of interest.

We were able to step outside the Viewmaster sandbox and enjoy pure Cardboard functionality, as well. We took the Cardboard “Urban Hikes,” saw some cool demos, and rode a rollercoaster through some ancient ruins. After downloading the Google Street View app, we were able to enter our old address in Los Angeles, click on the Cardboard icon, and take a 360º stroll around our old neighborhood.

With oculus focused on improving the display, companies like Wearality focused on premium optics, and Google driving a software solution with ever-increasing market penetration, VR seems to be becoming less “virtual” and more “reality” every day.