Category Archives: Technology

Moving UP with a replacement band

Well, I lost my UP cap recently, but Jawbone has a fantastic, one-time replacement policy. I submitted my claim this past Saturday and received my replacement today. Nice job, Jawbone.

Since I’ve been using my UP band and app since May, I didn’t want to lose any of my data or have a break in my data stream from one band to the next. When you visit the Jawbone forums, “How to sync a replacement UP band?” reveals how Jawbone has continued to improve the transition process.

My process was extremely straightforward as follows:

  1. Perform a final sync with the band to be returned in the UP app.
  2. Confirm upload of data from sync.
  3. Erase data from band to be returned.
  4. Connect replacement band to phone in UP app, having first ensured that the band is fully charged, to automatically sync.
    - The 1.4.2 version of the UP app on Android didn’t prompt me unusually at all. Normal sync just commenced as before. I didn’t have to sign-out/-in to the UP app either; I just stayed signed in.

It’s nice to know that outstanding customer service still exists. Thanks, Jawbone.

Quantified Self

Quantified Self logo

Given the domains that I serve professionally as well as my own desire to better understand aspects of my own health, I decided to start “quantifying myself.” For the uninitiated, the Quantified Self movement involves a group of folks who share an interest in self-knowledge through self-tracking.

This post captures my initial experience using UP by Jawbone–first on iOS and then on Android (same bracelet). There are several other devices to consider; however, I chose UP given Jawbone’s BodyMedia acquisition and its platform direction.

Getting Started

Setup is a breeze and once you’re fully configured the UP mobile app cheerily greets your arrival.

You've joined UP!

Like most software types I know, I just “went for it” and didn’t first study the manual. Besides the little paper-based booklet in the box is vastly superseded by the extended user guide available online as a PDF here (English link).

Fortunately the UI is simple and inviting, and it’s worth exploring given its bias toward more gradual disclosure in context (i.e. drill-in for details, etc.).

Main panel navigation UI in iOS Main activities UI in iOS

Goals UI in iOS

If you’re missing out on something useful, the app may provide a timely nudge in the right direction. For example, since I didn’t bother with the manual, I wasn’t aware of the Lifeline view.

Insight toward Lifeline view

Becoming aware of Lifeline also encouraged my curiosity toward the Trends view.

Lifeline view in iOS Trends view in iOS

If you want to know more detail about your movement of sleep that day, just tap the appropriate colored arrow bar (purple for sleep and orange for movement).

Day's movement summary UI on Android Day's sleep summary UI on Android

The consistent use of color in the mobile app helps develop user intuition.

Slight Mobile App Differences–Same Cloud Service

At the time I purchased my UP bracelet, I didn’t have a viable Android device according to Jawbone’s device compatibility page. So, I initially used my iPhone 3GS–really just an iPod Touch, since it’s no longer used as a cell phone. Thankfully I just updated my Android smartphone to a Samsung Galaxy S4; so, I have the UP mobile app on both devices. More importantly I confirmed firsthand that the mobile app talks to a cloud service after syncing with my UP bracelet.

Notice how the Android UX differs subtlety from the iOS UX…

Main UP UI on Android

Main next-level UP UI on Android

Personally, I think that the Android UX could benefit from improved visual association where next-level pop-up panes are concerned (ala Twitter).

Main panel navigation in Twitter mobile app

In general, the Android UI is a bit more spartan than the iOS UI. The iOS UI seems a bit more playful

Sync on the UP app for iOS

For example, compared to the iOS sync experience (above), the Android sync experience narrowly focused on sync and doesn’t report summary information as a result of sync completion.

Sync (uploading) on the UP app for iOS

The Android sync experience also doesn’t feature the rotating sun and clouds animation.

However, both Android and iOS apps do feature sunburst graphics as a way to reinforce achievement.

Sunburst (animated) to reinforce achievement Sunburst to reinforce achievement

User Experience Bugs (or Features?)

There are a few UX quirks with UP that I’ve experienced in my almost-a-month worth of daily use.

First, I encountered some behavior management in the app that didn’t progress as I expected.

Example of behavior management that didn't progress as expected

While I appreciated the insight “card” encouraging me to beat my current average, once I accomplished that objective, UP didn’t refresh itself to recognize my accomplishment. Perhaps it thought that I wasn’t done being active…after 9pm. Regardless, I expected to at least have the app inform me that I actually took it up on its challenge of me. Since it did not, I may be less likely to drill into future insights, and that is unfortunate and avoidable.

The next sub-optimal experience to share involves my first attempt at what UP calls a Power Nap (see this specific alert above).

Evidence of a blown Power Nap

According to the app, it did try to wake me by vibrating the bracelet; however, I must have been tired since I didn’t wake and continued in deep sleep well beyond the time frame I entered in the app. Fortunately, I wasn’t late for anything critical, but, again, the fact that it didn’t effectively wake me as I directed UP may cause me to use that feature less in the future.

The last frustration to share was when I discovered how the activity editor deals with trimming activity duration. It appears to simply compress the data from the prior timeframe into the new timeframe, and this really makes no sense–given my use case.

Basically I realized about 10 minutes after walking our dog that I forgot to press the bracelet to mark the end of my timed activity. (I appreciate that the UP bracelet can automatically determine your transition from sleep to activity, without requiring you to manually transition the bracelet from sleep mode to activity mode.)

Time shifting inflexibilty

UP does allow you to edit your activity; so, I went into my walking data to trim off the time, bringing the end-of-activity marker in toward the last noticeable movement bar (representing a decent number of steps per minute). Upon shortening the duration, I expected to roughly the same number of steps and a marker as described (at 10:58am versus 11:06am); however, the new graph was shown with the same “lack of movement” gap before the new end-of-activity marker (at 10:58am). Distance and Steps were the same; Pace and Calories dropped.

Since UP keeps track of daily data as well as per activity data during each day, I expected UP to simply take whatever steps may have occurred in the truncated portion of the activity to apply them to the day (outside specific activities). I expected UP to reset the end-of-activity marker as I just described; however, for some reason (a bug?) it doesn’t…

More To Explore

I still have yet to leverage every feature in UP as it currently exists. For example, I have yet to use the diet features of UP–they seem to be too manual for me to give it my time.

Logging diet in UP

I need to recruit other UP’ers to my Team. Flying solo currently…

Insight into Team feature

I also need to visit the Apps experience in UP to give things like its integration with IFTTT a try. If I recall, I think that there may be a nice integration with RunKeeper, which I also have in my app arsenal. Just need to turn the integration on and lace up my running shoes…

If you, my reader, use UP or a similar device, I’d love to hear of your experience and how you’re getting the most from self-tracking. Thanks!

Update 6/17/2013: Further reading:

About open community – a tale of two tools

When you take a step back from a community for spell after being in the thick of it for some time, it’s interesting to see what you find upon return.

In this case, I’m referring to the .NET community and there are two stories that I want to highlight:

  • Documentation automation
  • Decompilation

Town of NDoc

Once upon a time, there was NDoc, a convenient tool to help developers produce reference-level documentation for their .NET assemblies and solutions.

A force from the Pacific Northwest determined that there was much value in NDoc, and Sandcastle was born. (Note: The chapter on NIH isn’t covered here, nor are the alleged actions of an individual in the NDoc “community.”)

Sandcastle was more about the command line than NDoc, and eventually Sandcastle Help File Builder arose:

Sandcastle was originally created by Microsoft back in 2006. The last official release from Microsoft occurred in June 2010. Until October 2012, it was hosted at the Sandcastle project site on CodePlex. In October 2012, Microsoft officially declared that they were ceasing support and development of Sandcastle. The Sandcastle tools have been merged into the Sandcastle Help File Builder project and all future development and support for them will be handled at this project site. The Sandcastle tools themselves remain separate from and have no dependency on the help file builder. As such, they can be used in a standalone fashion with your own scripts and build tools if that is your preference.

Assuming that Kevin Downs and others who originally contributed to NDoc are happily pursuing new ventures (and satisfied to see their initial efforts validated by SHFB et al), it seems like documentation automation is alive and well in the .NET community.

City of .NET Reflector

Once upon a time, Lutz Roeder authored and maintained the most excellent .NET Reflector decompilation tool for the .NET developer community. At its prime, I didn’t know a .NET developer who wasn’t actively using the tool and who wouldn’t readily nominate Lutz for knighthood.

But then .NET Reflector’s future changed

Red Gate will continue to provide the free community version…

Well, until they didn’t!

Other than referencing ZDnet’s coverage at the time, I’ll leave you to Google the rest of the flames that resulted from this decision. Suffice it to say that it got ugly, and the $35 price is now no less than $95 and as high as $195.

The severe curve in price hikes tends to indicate a sharp drop in demand. Furthermore, the original Reflector add-ins portal seems to have been abandoned, which is a shame–lots of solid contributions were made therein that I use to leverage frequently (er, once upon a time)…

So, in the face of a tool that was free but now costs almost a benjamin for the basic version, what to do?

Two potential alternatives quickly present themselves: Telerik JustDecompile and JetBrains dotPeek. Let’s start with dotPeek

I’ve had some experience working with JetBrains in the past to establish a more open stance. Unfortunately, that didn’t result in any great or lasting success:

It’s interesting to see other potential similarities, too, between the Omea progression and the dotPeek progression. For example, JetBrains originally realized Omea by hiring Dmitry Jemerov who authored Syndirella–ironically an open source project. More recently, the first dotPeek plug-in author, Matt Ellis joined JetBrains as a .NET development tools evangelist. Assembly list support is already baked into dotPeek 1.0 directly.

As I remarked on Twitter, I sincerely hope that JetBrains has embraced open development for dotPeek; otherwise, I fear reactions to dotPeek such as this one for Omea.

Switching to JustDecompile, one of my first (positive community-oriented) impressions came from reading the (timely) comments on this blog post.

Even the blog’s first criticism–needs registration for download–has been addressed. I agree that this was a bit heavy-handed, but now you can download JustDecompile straightaway and only provide/create account information if you want support for the free tool (during JustDecompile installation).

Telerik has posted two, free plugins, which installed easily (after I realized that you have to expand the .sflb files for JustDecompile to find the entry points as otherwise instructed). (Telerik, please update your instructions to make this clear.)

Time will tell if the .NET community will rally around this tool by submitting new plugins. It’s clear that Telerik is listening to the community it has (e.g. this feature came directly from the UserVoice site for JustDecompile), and that is a good start.

I wonder if things would have worked out differently if GitHub had been around at the time the original transitions for .NET Reflector and NDoc had occurred. (Lutz is on GitHub, just not including .NET Reflector due to its aforementioned transfer.)

Is it too late for .NET decompilation to become truly open, supported by a vibrant community?

In the tale of two tools, the formative city of decompilation could take some cues from the happy town of documentation.


Integration. This word/concept similar to application, component, data, service and so many other concerns in the software realm: it’s often the case that there are N + M meanings floating around a conversation with N people on the subject. :-)

If you provide a portfolio of products to customers, integration is typically an important aspect of your offering. Do these products play well with each other? Can there inputs and outputs be combined into broader workflow, etc.?

Unfortunately I find that many integrations seems to be merely technical in nature–as if to answer “yes” to “can I technically integrate?” Much like answering “yes” to “do you know the time?” this strikes me as missing the point altogether.

Integrations must be about how should I deliver the right experience to my user. That is, integrations should be experience-driven.

So, what may be some of the signs that indicate a need for focused improvement?

  • Workflows that span across products involve multiple login experiences (interruptions).
  • Users are forced to deal with experiences designed for a persona other than their own.
  • Software concerns are not consistent and therefore are not intuitive (e.g. able to be reused spontaneously in new business contexts).
  • Integration gaps in product must be addressed via professional services, consulting or directly by customers.

Any of this sound familiar?

When I get involved in an integration-related project, I tend to think about the following layered concerns:

This approach involves:

  • an experience-driven focus on key business roles/personas and their workflows – user objective over product feature/function (seamless)
  • data and insight in context for better decisions and actions – mere hand-offs don’t add value (frictionless)
  • social as glue across users (relational) – provide others’ insights in context[1] to facilitate further insight and action

How do you view and tackle integration in your own products?

[1] e.g.

Activity Streams: Queue and Flow

Awhile ago, when I was working with a team on activity stream related experience, I found myself thinking about two distinct concepts: queue and flow.

Until I came across this information stream related article, I had forgotten to share these concepts (e.g. to receive feedback).

So, about queue and flow…

When I say queue I refer to things such as alerts, things that require actions, things that indicate workflow, dependencies, bottlenecks, etc.

When I say flow I refer to context for queued activities (tasks) and also context to realize new tasks.

Feeds and inboxes are simply expressions of queue and/or flow. For example, wiki change notifications, mail list subscriptions, etc. are flow-like. Emails sent to me specifically may be queue-like. Tools like IFTTT make it clear that rules (or recipes) can be brought to bear on activity streams.

Queues can form automatically/implicitly and manually/explicitly. For example, business rules may be met, causing an activity to enter one or more queues. A colleague may signal a dependency to a teammate (need cross-check, need assistance, need answer/insight to take own action, etc.), resulting in a queued activity.

Flow should unfold itself based on need to know. For example:

  • Meaningful default (last X activities, filters apply, time-based, etc.)
  • Ability to expand view–up to a point (e.g. Twitter handles roughly previous 8~10 hours)

As I mentioned briefly above, an activity in the Flow can become an activity in a Queue:

  • Alert someone else (as a notification with no dependency)
  • Alert someone else and subscribe to subsequent activity from that alert
  • Alert and realize own dependency on that task being completed

Anyway, that’s my brain dump on the matter of activity streams. How are you using them in your user experiences (UX)? How are you helping your users avoid information overload?