The Revolution Will Be Wearable - Discover - Designing and Developing for Google Glass (2015)

Designing and Developing for Google Glass (2015)

Part I. Discover

In this introductory part we give you a primer on the Google Glass ecosystem and all it entails as a wearable computing platform. We also introduce the Think for Glass philosophy, and begin to touch on how you should apply it to how you approach Glass as a user and an architect of Glassware.

Chapter 1. The Revolution Will Be Wearable

Forging Glass

Even in a world when smartphones, tablets, and laptops are becoming faster each month and shipping with tons of memory and eye-popping HD displays, the hardware that runs in Glass is impressive, putting the capabilities of Glass on par with that of a Galaxy Nexus. As you’ll find, the lightweight model of the ecosystem ensures that the infrastructural demands for Glassware, the applications that run on Glass, don’t generally require a supercomputer or eye-popping specs.

First, let’s consider the Glass form factor. Gadgetry driving processing capability, hard disk storage, and network connectivity that used to take up entire server rooms is now condensed within the arm of a headset frame less than a half-inch thick and not even weighing a full pound. Put into perspective, this is more raw computing power than was on the first space shuttle and which initially ran the New York Stock Exchange. (OK, we’re totally making this part up…but it’s probably true. Someone look it up and get back to us.) At the same time, it is important to understand how the final physical design reflects a set of compromises between what is possible, what is visually appealing, and a wide range of other diverse requirements.

From the software side of things, Google engineered the Glass sync component of the application framework that manages cloud-based services to do all the heavy lifting—calculations, string manipulation, data transformation—in the cloud, not on the device itself, reducing the need for expensive on board components to handle such processing locally, meaning all that’s transferred over the wire is extremely small payloads of HTML markup. Glass sync manages the complex messaging aspect for you—delivery, queueing, retries for users whose batteries might be dead or without Internet access, etc. Timeline cards, which are the atomic units that encapsulate data on Glass, akin to web pages within a web browser or screens in a mobile app, arrive to the wearer in near real time with information that’s geographically aware, contextually accurate, and user specific.

When you do need to run apps locally, Glass is still capable of executing Android applications written specifically for its user experience. Processing, memory, and graphics cater to microinteractions—a streamlined, perfectly suited form of application interactivity that doesn’t require lengthy usage sessions or attention. Aggressive competition by hardware manufacturers has driven the price for consumer technology down considerably, and innovations in materials engineering have allowed the physical properties of the Glass head-mounted display (HMD) to be light and flexible, yet durable and sturdy. The display prism reflects bright colors and rich video. The embedded camera captures remarkably clear images and video.

It’s truly an elegant system.

The one thing to keep in mind as you approach your own adventure with Glass as an application architect is that at its core, this technology isn’t a new idea. Glass is the result of a concept that’s been floating around advanced computer science circles and egghead thinktanks for the past two decades: wearable computing. This is some pretty hardcore stuff, so buckle up.

Wearable Computing

Straight from the pages of science fiction and echoing episodes of The Jetsons, wearable computing has been envisioned for years—a utopian era when devices would be small and lightweight enough to literally be part of your person and actually mesh with your outfits (there’s a reason Glass ships in five distinctly attractive colors—Charcoal, Cotton, Shale, Sky, and Tangerine). This is the next progression in how we use computers, going from desktop towers tethering us to fixed locations, to portability with laptops and netbooks with wireless connectivity, and then the mobility advantage smaller devices like smartphones and tablets achieved, to finally wearables with intelligent software.

Relatives of Glass in this emerging space are products from Telepathy One, Microsoft, Recon Jet, the IndieGogo-backed GlassUp, Chinese search provider Baidu, and even automaker Nissan; Vuzix’s M100 Smart Glasses; smartwatches like the Samsung Galaxy Gear, Sony SmartWatch, Qualcomm Toq, and the Kickstarter-born Pebble, along with offerings from Apple, LG, and Google; and even do-it-yourself electronic components like sensors that you can sew into your clothing with special conductive thread and program to do all sorts of neat things.

Being designed from the ground up as a platform that frees you from having to constantly fuss with controls or type input or force refreshes, keeping content and the delivery of it out of your way, Glass exists to sit on your head in order to put your life back in your hands. Don’t you just love the irony?

What Does It Mean to Think for Glass?

When you begin to Think for Glass, you begin to think in this new way that Google is beginning to forge. It means thinking about social interactions, personalized delivery, and streamlining interactions—all at the same time. It means thinking about more than just one application, it means thinking about how everything works together to create something greater than the sum of their parts. It means thinking about new ways for how your program should behave, how information flows between services and devices, and how the interaction experience is optimized.

Being able to Think for Glass keeps technology omnipresent yet nonintrusive—a lofty goal achieved only by delivering high-impact usability with minimal cruft. This is a dramatic reinvention of how we’ve come to perceive mobile communications.

Here’s the basic idea: Glass is designed to live in your world, not for you to live in the Glass world. It is meant to adapt to your life, not for you to adapt to how it does things. Your apps are expected to behave the same way. Everything else stems from this basic idea. To be sure, it is an ideal—but that doesn’t mean it isn’t the ideal to strive for. It also suggests that just because something can be done with Glass doesn’t mean that it is a good idea to do so.

It means that anything that works through Glass should be secondary to the world around the person wearing Glass, and that an app should never expect otherwise. With few exceptions, this is what the user expects, and violating those expectations will only cause problems and a poor user experience.

Software that works best with Glass are those programs that require no more than about five seconds at a time. This is the essence of microinteractions. If users are taking more than that time, they will be making a conscious decision to break out of the world they’re in and enter the Glass universe. Sometimes users will choose to do this—to review photos and share them, for example. But even these tasks are oriented toward what users want to do (find a picture and share it) rather than how an app wants them to do it (open their app and process a photo). Apps should accept a wearer’s commands—not narrow a person’s choice into what the app wants you to do.

Of course there are menus and voice commands that limit what a person can do, but app developers should be as aware and open as possible to the full set of commands that are available by default and how people may wish to use the data they provide. It takes a lot of extra thinking, and we’ll be discussing the designs required to do this successfully.

Consider, for example, the desire that everyone has to get on the Glass home screen, or to give their cards persistent presence on a user’s timeline. This is an app-centric focus—we want our applications prominent for the user. But it forces users into our world instead of trying to understand the world that they want to be in. They don’t want to sort through dozens of “pinned cards,” as the Glass terminology refers to it, to find the one they want. They want us to deliver information to them when, and only when, they want it. They want to be able to easily ask for new information. They want to quickly find the data they know is there…somewhere. They don’t want clutter. (And if you’re confused about what this all means, you’ll understand by the end of Chapter 5.)

Sometimes, the boundary between “the Glass world” and “the human world” isn’t clear. Consider an app for running enthusiasts, for example. The runner wants to be able to quickly, easily, and probably frequently see his progress, heart rate, course, and other important information. But, all too easily, this information can become distracting if constantly presented…and the runner could stop paying attention to the physical world he is are trying to traverse, risking physical injury. Perhaps this is a case where a runner can set predetermined alarms (heart rate too high, another mile traversed in the course, etc.) to notify him for important events, but also allow for an on-demand summary if the runner wishes.

This event-driven angle is at the heart of Glass. Glass needs to be a mind reader—delivering the information about events exactly when you want, before you ask for it. It needs to respond, immediately, to the events you wish to capture in the world around you and turn them into online representations of those events.

We have to remember, also, that the world around us isn’t the same as that of Glass, or even the wearer’s world, and Glass tries to address that. As we write Glassware, we need to remember that the public perception of our world isn’t going to adapt to Glass just because we may want it to. This is why Glass requires specific actions to take a picture and why it lights up when recording video—the world around us has certain expectations that Glass tries to meet. Our software needs to respect the social norms, while at the same time nudging it forward. Software that violates these norms (for example, software that does facial recognition or that uses material Google deems objectionable) is discouraged, even if the features it provides could be tremendously beneficial.

Glass is different. Glass is more personal than any computer we’ve had before. Glass is technology that tries to get us away from technology and into our world. Our applications can’t try to drag a user away from that.

By the end of this book, we’ll empower you with the knowledge to Think for Glass so that you respect the following virtues about optimal Glassware construction from three perspectives:

1. Usage

o Understand personal technology

o Appreciate the value of personal area networks

o Know the ecosystem

§ Hardware, firmware, cloud infrastructure, Glassware, administrative tools

o Realize Glass doesn’t replace, but complements, your other gear

§ Smart devices and mobile platforms still have their place alongside wearables

o Get involved

§ Ask questions, share knowledge, submit feedback, participate in the community

§ Demand Glassware from your favorite services

o Live in the physical world

§ Respect the privacy of those around us

§ Use Glass to be part of the moment, not divorced from the moment

2. Design

o Aim for simplicity and brevity

§ Target supporting microinteractions

o Respect the Five Noble Truths

§ Design for Glass

§ Don’t get in the way

§ Keep it relevant

§ Avoid the unexpected

§ Build for people

3. Development

o Leverage the software-as-contact model

§ The evolution of sharing

o Work judiciously with frameworks

§ Mirror API versus GDK

o Build distinctly for Glass

§ Don’t “lazy port” existing Android or web apps

§ Leverage the Glass UI and control system

§ Exploit event-driven existences

§ Context powers content

§ Let users live in the moment