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.

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.).

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.

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

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).

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…

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

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

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.

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.

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.

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).

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.)

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.

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

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:

• Great IFTTT recipes for your Jawbone UP
• Part 1: Can A Fitness Tracker Really Change Your Life?
  Part 2: My Fitbit Flex Hasn’t Changed My Life, But It’s Telling Me What’s Wrong
  - From the post: “I’m not getting much in the way of suggestions. It would be great, for instance, if the Fitbit app on my iPhone let me know when I was spending an unhealthy amount of time sitting, perhaps with a nudging notification telling me to go take a walk. Instead, it just shows a depressing pie chart, making sure to highlight my time spent wasting away in a chair with the color gray.”
  - Perhaps the author would appreciate the UP’s Idle Alert feature: If I’ve been sitting for too long at my desk, I’ve told UP to send a slight vibration on my wrist to gently nudge me toward movement. Certainly the visualization in UP is less drab than what he showed for Flex.
• According to a report released in January by the Pew Internet Project, 69 percent of Americans track some kind of health data, and one in five of those trackers use some form of technology.

I forget who exactly did, but someone not too long ago mentioned Ben Chun’s ilearnedtoprogram project, and I submitted my programming start. Apparently Ben has moved on to other things; so, I doubt that what I submitted with ever be shown at http://ilearnedtoprogram.com/.

Therefore, here is what caused me to learn how to program…

I learned to program…

using a Commodore 64 to replace my 3×5 card based stick figure animations after my Dad told me about sprites–that I could manipulate no less than 8 of them at a time!

Before I started my current position at Oracle, I took a short break from work and entered into one of my Dad’s hobbies: woodworking. Since he retired, he has assembled quite a workshop that has already produced many fine results enjoyed by family and friends. Instead of purchasing a new desk from a store, we decided to design and build my new desk ourselves. After looking over my Dad’s woodworking books on hardwood, I decided that the desk would be built out of the African hardwood Wenge.

The following pictures capture the process from sourcing the wood to realizing the finished desk. They are in chronological order.

The Wenge hardwood for this project was sourced from MacBeath Hardwood‘s Berkeley location.

The finished desk below began its life as a humble set of boards.

Some of the boards became legs.

Other boards were selected for their grain pattern to form the desktop.

I got to learn how to use a new power tool (i.e. a plate joiner) and apply biscuit joins.

At this point, my regular involvement in the project lessened quite a bit as I started my new job, but my Dad kept making steady progress.

My Dad built a custom jig for the legs, which would become tapered along both sets of opposing sides.


Each step involving the Wenge legs was preceded by a prototype in lesser wood.



Before finally glueing pieces of the desk together, a dry assembly was made to confirm fit.

By now you can appreciate why my Dad insights that a woodworker can never have too many clamps (or too many gift cards to Rockler).

The wood for the legs was selected to achieve a particular grain pattern, too.

This shows the overall taper of the legs more clearly.

At this point, it was clear that I needed to treat my Dad to a ØL Beercafe & Bottle Shop visit in order to spark our creativity over a Ægir Natt Imperial Porter and an Upright Engelberg Pils.



At this point, my Dad worked on the desk’s undercarriage.

Here is the desktop grain pattern detail after sanding and before finishing.


Here is how the desk appeared before it was delivered to be finished by Englund Studio in Oakland.

Here is how the desk appeared after it was finished.

So as not to draw attention away from the Wenge, the center pull-out shelf and side drawers were painted in matte black.


Here you can see the detail that my Dad put into the front of the pull-out shelf, which is held magnetically at an angle matching that set by the legs of the desk.

Here is the desktop grain pattern after finishing. It’s what I get to enjoy now every time I sit down to work at home.

Now I am the very proud owner of a custom-built Wenge desk, all the more special since my Dad was essentially its maker. He was kind enough to put his wood mark on the right leg facing me as I work; so, I can glance down at any time to be reminded of this project and all I learned working at his side.

Thanks, Dad!

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:

• 11/14/2006: An open source Omea?
• 5/30/2007: An open letter to Jetbrains about Omea
• 3/15/2008: Omea is open to the community
• Today: No mention of openness on JetBrain’s Omea home page, which hasn’t been updated since version 2.2 was released on 11/16/2006; no life in the Omea development “community” (other than a thick coat of spam everywhere)…

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.

Every once in a while, something truly inspirational occurs. Earlier today I was able to witness one such event live with my kids via YouTube: the Mach 1.24 freefall by “Fearless Felix” (Felix Baumgartner) from over 24 miles above the earth.

The following pictures are courtesy of the iPad’s screen capture facility while watching the jump live on YouTube. They are in chronological order.

Although the world may have been focused on Felix (and his mom), I reminded my kids that even a seemingly individual event involves a team. This event was no different and the Stratos team is probably significantly larger than those captured on the video:

Thanks again, Felix and team, for inspiring me and my kids today, and congratulations on your accomplishments!

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. http://craigrandall.net/archives/2012/09/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?

Have you ever wanted to get a better sense of an event’s commentary on Twitter? For example, a subset of your following may be attending an event in your periphery but making interesting enough comments to warrant a closer look.

Well, I’ve had these thoughts on an increasing basis lately so I thought I’d dive into the Twitter stream a bit to see what I could learn.

Fortunately, I was aware of a gist to query Twitter by @pmonks, and this Groovy script became the foundation for my exploration.

Since I don’t normally program in Groovy, I had to setup Groovy on my MacBook Pro. (To be clear, I went for “get this to work” rather than “accomplish your configuration with all best practices incorporated.” I’m sure there may be better techniques where Groovy setup on MacOS is concerned, and I thank you in advance for any comment-based pointers.)

1. Visit the Groovy website and understand basic Groovy installation instructions.
2. Downloaded the binary release (Zip) of Groovy 1.8.6 (i.e. latest available version of the stable branch at the time of this post).
3. Extracted Zip contents and moved (via Terminal) them under my up-to-date Java distribution:

   prompt$ sudo mv ~/downloads/groovy-1.8.6 /usr/share/java

   (I’ve seen apparent best practice guidance to create a symlink that allows you to access Groovy without referencing the version number, but I’ve skipped that here.)

4. Edit your .profile file to point your environment to your new Groovy installation. (If you don’t have a .profile file, read and follow this.)

   prompt$ open /Applications/TextEdit.app .profile

   Add (or confirm) the following lines in your .profile file:

   JAVA_HOME=/Library/Java/Home; export JAVA_HOME
   GROOVY_HOME=/usr/share/java/groovy-1.8.6; export GROOVY_HOME
   PATH=$GROOVY_HOME/bin:$PATH; export PATH

   Save your .profile file, exit TextEdit, close all open Terminal windows, exit Terminal and open a new Terminal window to enable .profile changes to take effect.

5. Confirm that Groovy is ready to act on your script:

   prompt$ groovy -v

   My confirmation looked as follows:
   Groovy Version: 1.8.6 JVM: 1.6.0_31 Vendor: Apple Inc. OS: Mac OS X

For this particular script, queryTwitter.groovy, you need to provide a peer twitter4j.properties file that will provide to Twitter your username and password. Once that’s ready,

prompt$ groovy queryTwitter.groovy %23interesting_event

The results are ready to be nested within a table element, if you want to produce HTML for display as-is. However, you could also modify the script to render JSON output and pursue alternative visualizations (e.g. rate of tweets over time, geolocation of individuals in the tweetstream, word clouds for the event, influencer status, etc.)–something for D3.js.

“D3.js is a small, free JavaScript library for manipulating documents based on data.” -http://mbostock.github.com/d3/

Since I’ve been trying to spread the word with colleagues about this powerful, expressive visualization technology, I thought it might be worth sharing similarly here.

The following tutorials have been helpful in ramping folks up on D3:

• Jan Willem Tulp’s introduction (also his blog posts on D3 and his interview about D3)
• Stanford CS
• Scotty Murray’s series

D3′s creator, Mike Bostock, has published a white paper on D3 (Stanford Visualization Group) and presented D3 during the most recent W3Conf (browser-based slides).

A couple of spotlights on D3 include one by Flowing Data and another by SVG Magazine.

Flowing Data also posted an application of D3, “How Americans Spend Their Day” (background context).

If this whets your appetite, visit the D3 wiki for a whole lot more goodness (documentation, additional tutorials, example visualizations, etc.).

Update 8/30/2012: Mike Bostock posted his 3/5/2012 D3 workshop given at VIZBI 2012. Also since my original post, I discovered D3 for Mere Mortals and Christophe Viau’s Try D3 Now post.

If you follow me on Twitter, you might have an idea that my son is currently without one of his rides (i.e. a Razor Cruiser kick scooter). My son is big and tall for his age, and this scooter is perfect for him.

Like most boys his age, though, he doesn’t understand “cruiser” in the face of a neighborhood of boys who all like to jump all manner of wheeled vehicle. As a result of this lack of appreciation (er, love of both scooter and jumping), what looked like

now looks like

Do you see the opportunity?

Razor makes a quality product–one the is easy to use and maintain. Ease of maintenance is largely facilitated by modularity of design.

So when my son came to me with the disappointment of pushing his ride too hard, my first thought was to simply disassemble the scooter to isolate the failed part (deck). Easily accomplished.

Except that apparently Razor and its authorized parts retailers doesn’t stock replacement decks for the Cruiser kick scooter.

So…Razor built a modular kick scooter but doesn’t stock a critical module (deck).

What’s the point of modularity, if there are no modules (i.e. ability to swap module instances that fulfill necessary interfaces)?

My son’s predicament is clearly of his own making, but herein is opportunity for Razor. Beyond already clearly stating what their product is designed to perform, Razor can anticipate that boys will be boys and provide timely relief in the form of complete replacement parts, including readily available decks.

Within earshot of my son are more than a dozen boys of similar age, and they’re always outside planning their next jump. Many already own their own Razor, too. What if he could turn around an accident with word that Razor saved the day? Talk about brand advocacy and social media!

What’s your Razor-like story? What’s your Razor-like opportunity?

Here is a technique you can apply to your browser to make your Adobe Connect room joining workflow more streamlined.

If you work at Adobe, you use Connect on a regular basis. After a while, and in the face of shortened URLs (and everything else), you start to just think in terms of frequented room names.

If this sounds like you, you can simply your Connect room joining experience as follows:

javascript:q=window.getSelection();
if(q==""){q=prompt('Please%20enter%20the%20name%20of%20
the%20Adobe%20Connect%20room%20you%20wish%20to%20join:')};
if(q)location.href='http://my.adobeconnect.com/'+escape(q);


This code is simply the logic inside a bookmarklet that you can drag and drop into most modern browsers. That is, you can drag the following link into the links bar of your browser: Connect

Then you can click on the bookmark link to receive a dialog as follows:

Please note that you may need to replace “http://my.adobeconnect.com/” with your Adobe Connect host URL.

(HT @chrisvls)

P.S. While we’re talking about Adobe Connect productivity, I recommend that you visit the Adobe Connect User Community downloads page for additional tools.

In my #AdobeMAX session today, I presented a set of experience architecture principles with my colleague Marcel Boucher as follows:

• Modularity is critical to ‘better experience faster’
• Everything is content (and content is managed in a repository)
• Context is king
• Cloud first, mobile first, social first

I’ve gone into greater detail about these principles in a technical white paper that is available from the Adobe Enterprise Developer Center as a PDF download.

During our session, Marcel presented two demonstrations:

1. The first demonstration featured an overall vision for customer experience in the retail banking domain. If you weren’t able to catch this demo live, you can see it presented here during the FinovateSpring 2011 event.
2. Marcel’s second demonstration provided more of the how behind the vision in terms of Adobe’s integration across its Web Experience Management (WEM) solution, SiteCatalyst and Test&Target. A video similar to Marcel’s demonstration of this integration is available here.

MAX is always a great event, and the enterprise team at Adobe is looking forward to sharing more with you about Digital Marketing at our upcoming summit in March 2012.

The Adobe® Digital Enterprise Platform (ADEP) Experience Server supports WAN clustering (important in high latency situations and given distributed infrastructure), hot cluster join (allowing you to expand infrastructure on the fly), and runs in a very small memory and CPU footprint. This makes the Experience Server suitable for deployment in the cloud, whether actual deployments are done there or on premise.[1]

In pursuing interaction patterns, ADEP starts its approach with mobile devices (particularly tablets) and then expands to consider other environments. ADEP can detect over 17,000 devices,[2] enabling content contributors to understand exactly what experience will be delivered to segmented content consumers via device emulation support. ADEP presents the concept of device groups to reduce the complexity and managing the diverse range of never-ending devices and device types.

Today’s customer increasingly leverages social activities to gain validation of their decisions and to share them with others. ADEP supports a range of social capabilities including support for local communities and the ability to glean information from public communities (Facebook, Twitter, etc.) and use that information to tailor the customer experience. Social capabilities in the platform are much like the public social environment: they surround everything we do and are available for use at any time for any purpose.

With ADEP:

• You build applications for the cloud with on premise in mind,
• You build applications for mobile with desktop in mind, and
• You understand that every user is a contributor and has a social graph.

This post wraps up the current series on ADEP architecture principles. Now that we have a shared frame of reference, we’ll return to ADEP Developer Center as a PDF download. Please feel free to provide me with your feedback on that work here. Thanks in advance!

Footnotes:
[1] i.e. ADEP Experience Server is “cloud ready”
[2] Adobe’s Customer Experience Solution for Web Experience Management (previously known as CQ5), leverages the WURFL device description repository.

Given the previous principle, you may be surprised to read that context, not content, is king in the Adobe® Digital Enterprise Platform. Actually it’s more like a king and his kingdom. Great content is critical to customer experience, and customers experience content in context.

At the center of Adobe’s technology for customizing and optimizing user experience is something called the Context Cloud.[1]

Adobe’s approach to building CEM solutions aims to empower and delight customers by (among other means) giving Web visitors exactly the information they need, in the right form, at the right time. Doing this reliably and in real-time can be a challenge. It requires software that can aggregate relevant user information from a variety of sources so as to drive intelligent provisioning of content on a page according to predetermined strategies.

Adobe’s Customer Experience Solution for Web Experience Management rises to this challenge with a patent-pending technology called the Context Cloud. The Context Cloud represents a dynamically assembled collection of user data that can be used to determine exactly what content should be shown, for example, on a given Web page in a given situation.

Several things make Adobe’s implementation of the Context Cloud unique:

1. Much of the information (such as info about the user’s viewing environment) is derived on the fly in real-time; it is not persisted anywhere.
2. Marketers can experiment with different user-data values to see changes to a page in real-time (e.g. to try different campaign strategies before going live).
3. The Context Cloud is extensible. You can add a new (custom) session-store object whose contents can fully participate in campaign “what if” scenarios.[2]
4. Non-volatile information shown in the Context Cloud viewer is persisted on the client side (in a cookie), relieving the server of having to maintain (and then transport back and forth) large amounts of user data.

Because user info is persisted on the client, concerns over privacy and control of potentially sensitive user data are easily allayed: The user has ultimate control over the data.

Credit: Thanks to Kas Thomas for his work in describing Context Cloud.

Next: cloud first, mobile first, social first

Update 9/6/2011: The larger technical white paper from which this post was drawn is now available from the ADEP Developer Center as a PDF download. Please feel free to provide me with your feedback on that work here. Thanks in advance!

Footnotes:
[1] Previously in Day Software, Context Cloud was referred to as Clickstream Cloud.
[2] When Adobe CQ5.4 released in February 2011, it demonstrated this extensibility via its integration with Omniture. CQ5 is now known as the Customer Experience Solution for Web Experience Management.

In the Adobe® Digital Enterprise Platform (ADEP), everything is content, and content resides in a repository. There are no loose files somewhere else to manage. Source code, dynamic modules, configuration and even the state of an application reside side by side with marketing collateral, digital assets such as images, audio and video, etc. The content repository recognizes that “meta” is in the eye of the beholder.[1] Consequently, there is no justification to treat content (i.e. the file stream) and metadata differently.

Since the content repository consistently manages this diversity, the rich set of content services above the repository is uniformly available. For example, the resource-first request processing of the ADEP Experience Server[2] is equally available to traditional content such as Web pages and to applications such as a product configurator. By managing to a wide definition of content, ADEP can reduce the amount of code and effort required to deliver a solution.

Since ADEP provides a virtual content repository that easily connects with existing content silos in an enterprise, “everything is content” also means that any existing content is free to participate in serving customer experience (e.g. via marketing campaigns, customer communication, etc.).

Next: context is king.

Update 9/6/2011: The larger technical white paper from which this post was drawn is now available from the ADEP Developer Center as a PDF download. Please feel free to provide me with your feedback on that work here. Thanks in advance!

Footnotes:
[1] Content management systems that treat files in a differentiated, somehow more valuable, manner miss the reality that often the metadata around the file has the real business value.
[2] At the core of the ADEP Experience Server is CRX technology that Adobe acquired from Day Software. More on the ADEP Experience Server in a future post.

Modularity is perhaps the most essential architecture principle applied across the Adobe® Digital Enterprise Platform (ADEP). Modularization in ADEP enables you to manage the complexity of your CEM solutions by separating them into independent components and other concerns that can be worked on by different development teams and tested in isolation. When deployed, these solutions consume minimal footprint that is associated with specific workload requirements (i.e. resource usage is kept to what is essential for delivering business value).

The very nature of differentiated customer experience is modular–my experience today should differ from my experience tomorrow, from my experience yesterday and from what another customer may experience. ADEP anticipates, is tuned for and can accelerate composition and reuse. In an enterprise context, supporting such modularity means that you can draw upon the breadth of assets (content, applications, documents, processes, services) available, including those from Adobe, Adobe’s partners, systems integrators, agencies and other teams within your enterprise. These assets can be brought to bear on business problems in a manner that can be partitioned and rolled out incrementally with minimal disruption (e.g. hot deployment[1]).

Modularity in ADEP is a form of separation of concerns that provides both logical and physical encapsulation of classes. Modularity is desirable because it allows you to break applications into logically independent pieces that can be independently changed and reasoned about. Modularity enables division of labor across a solution, and it promotes abstraction, reuse and ease of maintenance and repair.

As a consequence of embracing modularity as a core architecture principle, software modules in ADEP are self-contained (local wholes), highly cohesive (fulfill single purposes) and loosely coupled (well-isolated from other modules).

To support all three properties, it is vital for modules to have a well-defined interface for interaction with other modules. A stable interface enforces logical boundaries between modules and prevents access to internal implementation details. Ideally, the interface should be defined in terms of what each module offers to other modules, and what each module requires from other modules.

Modularity is driven across the ADEP architecture via the following principles:

• Interface-based programming[2]
• Externalization of cross-cutting concerns (aspect-oriented programming[3])
• Late binding of implementation instances to interfaces (dependency injection;[4] extensibility)

Next: everything is content.

Update 9/6/2011: The larger technical white paper from which this post was drawn is now available from the ADEP Developer Center as a PDF download. Please feel free to provide me with your feedback on that work here. Thanks in advance!

Footnotes:
[1] i.e. a provision of dynamic modularity in an OSGi-based system like ADEP
[2] Please consider Interface Oriented Design for a more detailed discussion of interface-based programming.
[3] Please consider AspectJ in Action: Enterprise AOP with Spring Applications, Second Edition for a more detailed discussion of aspect-oriented programming (AOP).
[4] Please consider Dependency Injection: Design patterns using Spring and Guice for a more detailed discussion of dependency injection (DI).

Architecture is the result of a collective set of design choices, and these choices are informed by principles.

It occurred to me that before I continue much further with my current series on “content + apps”–a design pillar in Adobe’s enterprise software platform for Customer Experience Management–it would be good to share the architectural principles of the Adobe® Digital Enterprise Platform (ADEP). Talking first about ADEP architectural aspirations will hopefully clarify their realization (i.e. architecture implementation choices in ADEP).

In summary, here are the principles:

• Modularity is critical to industrialize differentiated experience
• Everything is content
• Context is king
• Cloud first, mobile first, social first

Next, we’ll examine the importance of modularity to ADEP.

Update 9/6/2011: The larger technical white paper from which this post was drawn is now available from the ADEP Developer Center as a PDF download. Please feel free to provide me with your feedback on that work here. Thanks in advance!

Related series of posts about Adobe® Digital Enterprise Platform (ADEP):

1. What is XOA?
2. What is a UX Component?
3. This post

Awhile ago, Stacy Young broke the news of an internal-to-Adobe framework for RIA development, inspired by OSGi and Spring and targeting the Flash Platform, called “Gravity.”

If you’re a Java developer, you probably already now about OSGi and Spring, de facto standard implementations of modularity and dependency injection (among other things), respectively. Both are leveraged within the Adobe® Digital Enterprise Platform (ADEP).

Although “Gravity” never did make it to Adobe Labs, work on the framework never ceased. In fact, work on “Gravity” increased as it became clear that large-scale application development on the client (edge device) with Flash and AIR required similar modularity and dependency injection support.

One of the attractions of so-called Rich Internet Application[1] development is a blurred line between client and server, leveraging the full facilities of the local environment where software executes. In order to promote such blur, though, it helps to have a consistent programming model end-to-end. ADEP provides this consistency by embracing OSGi and Spring on the server-side and by offering the Client Component Framework (pka “Gravity”) on the client-side for customer experiences built on AIR or the Flash Player.

If you attended my session at MAX last year, “Realizing great customer experiences with LiveCycle ES3,” you may remember that I talked a fair bit about “Gravity”–now the Client Component Framework in ADEP. As you can see, marketing has since determined final product names; so, please apply the following translation when reviewing that content (i.e. slides 26-47 in particular):

• Gravity – now Client Component Framework
• Mosaic – now Composite Application Framework
• LiveCycle RIA Server – now ADEP Experience Server
• LiveCycle ES (user management integration) – now ADEP Document Server
• LiveCycle ES3 Solution Application – now Customer Experience Solution (powered by ADEP)
• Field Force Automation – now the Adobe Unified Workspace Customer Experience Solution

Shortly after MAX 2010, Stacy reiterated that a public release of “Gravity” was approaching.

As has been the case for the past few months, you can play with the Client Component Framework now. To do so, please join the pre-release program for the Adobe® Digital Enterprise Platform (ADEP). (Don’t worry if the initial screen says something about LiveCycle ES3; you will subsequently see reference to ADEP.) Once you do sign-up, please post your feedback on this technology (and the rest of the platform) to the pre-release forums. Thanks!

Although it’s just now becoming a public, supported API in its own right, the Client Component Framework in ADEP has been used in production for awhile now. LiveCycle Mosaic 9.5 (part of LiveCycle ES2.5) leverages Gravity internally for managing composite RIA components (i.e. tiles).

As shown in the above figure, the Client Component Framework operates above the Flash Player and below the Flex SDK–much like the Text Layout Framework. That is, the framework operates independent of the Flex SDK and supports a mixed-SDK-version runtime environment. This is especially important for large enterprise project that may need to reuse components from other vendors that don’t all leverage the very latest (or same) Flex SDK.

Additional points of value in the framework include the following:

• It enables you to choose what parts of your solution to upgrade and when.
• Newer versions of a component that may leverage a newer Flex SDK can co-exist with older versions of the same components based on an older SDK.
• Since components using the Client Component Framework communicate via a service registry, not each other, you can apply versioning and other policies as you would expect of a service-oriented architecture.
• Components using the Client Component Framework are intrinsically loosely-coupled, which improves their changeability, comprehensibility and testability.

Having introduced the Client Component Framework, next we’ll talk about the Composite Application Framework, which leverages the subject of today’s post. Cheers!

[1] Aren’t most apps RIAs these days?

Update 7/26/2011: Instead of moving on to the Composite Application Framework, I thought it best to address ADEP architecture principles first with a set of posts.

Previously, I offered some thoughts in response to “What is XOA?” To recap, experience-oriented architecture indicates an approach to solution design that is about the customer in, not the underlying systems out. I mentioned the concept of experience components in the Adobe® Digital Enterprise Platform (ADEP) as a concrete expression of XOA for Flex developers, noting that XOA is, in fact, technology agnostic.

Now, let’s talk in more detail about UX Components.

Adobe CEM applications use a component model that is oriented toward reuse across a spectrum of applications. At one end of the spectrum we have static applications where individual components are statically linked into an application. At the other end of the spectrum, individual components are placed in a catalog on a server and dynamically injected into an application at runtime. We call these “experience components”–UX Components.

Technically speaking, a UX Component is a combination of MXML and ActionScript classes that is bundled into SWC files that separate concerns and encapsulate each concern behind an interface. Interfaces make the implementation of concerns (i.e. presentation, domain, etc.) replaceable and extensible.

The fact that a UX Component is well-composed behind a set of interfaces, allows you to focus on the concrete implementation of familiar coding patterns productively.

For example, let’s assume that the domain model and service integration specified by Adobe for a UX Component is well-suited for your use case, but in order to differentiate your customer experience, you need to implement a custom user interface. By leveraging UX Components in ADEP, you simply focus your attention on implementing a custom view and presentation model that will leverage everything as-is:

Another common requirement involves integrating existing systems into new customer experiences. Depending on your use case, you may be satisfied with a UX Component as provided by Adobe. So, you need only focus on implementing a custom façade to ensure that customer interaction with your experience is integrated with your existing infrastructure:

Here is an example of a UX Component:

At the top is a logo component and a navigation bar. The left column has a calendar, and the right column has resources finder and a document viewer. Each of these components are very generic displays of information. For instance, the project calendar is a graphical list of items, actually a tree of items that is rolled up into a Gantt chart. Each of these items has a start date, finish date, phases, a current state shown in color and descriptions.

A UX Component is completely independent of its data source. Simply by injecting a data source at runtime and providing a different skin, a different application experience can be delivered:

Here is the same calendar UX component, with a new skin and a new data source. This shows a charcoal theme, and the data is a product development plan rather than a marketing plan. The renderer for each of the items now shows the phases of the project as colors in the bar.

By creating a well thought out UX Component, where concerns are inheritable, skins are replaceable, and services are injectable, ADEP enables you to achieve a high level of reuse while providing both richness and consistency in the experience.

More on ADEP‘s Composite Application Framework (pka Mosaic) and Client Component Framework (pka Gravity) in future posts…

Update 7/6/2011: “What is the Client Component Framework?“

XOA stands for experience-oriented architecture. XOA was first coined by Adobe’s Steven Webster “to very specifically mean applying design thinking to evolving an architecture stack, and more recently, to talk about instrumenting an experience in order that it can be measured and monitored as delivering against intended KPIs.” It is therefore incorrect to reduce XOA down to component development. At its heart, XOA embodies best practices for RIA development, whether in the browser or on the desktop.

In the (just-announced) Adobe® Digital Enterprise Platform, XOA manifests its RIA best practices via layers (concerns) as follows:

• Presentation – view rendering
• Domain – client-side computations, abstraction of server calls, etc.
• Infrastructure – server communication

XOA is an architectural approach and is not bound to a particular technology (e.g. applies to Flex, HTML5, native mobile, etc.). XOA is certainly not meant to be a formal label—just like you wouldn’t expect to see “SOA” in XML, etc.

This layered architecture [1] provides an efficient way of segregating the code related to view rendition, client side computations, perpetual asynchronous communication, etc. Embracing such separation of concerns enables ADEP development projects to be easier to understand and to manage. Moreover, it helps developers with different personas to work in tandem on a component (e.g. the UI developer in concert with a business logic developer).

Example of applying XOA to ADEP-based Flex development: Enterprise Flex components (aka UX (User Experience) Components) are mostly data-driven with data synchronizing from a backend server over Remoting, Data Services, etc. With data coming from server in an asynchronous fashion and component assembling itself by computations, the complexity increases manifold since the component, apart from rendering itself also needs to construct itself. Therefore, it becomes extremely important to separate concerns before the component development turns unmanageable. However, please keep in mind that XOA is about much more than component development as noted above.

For example, a UX Component in ADEP is an enterprise Flex component that embodies XOA principles.

More on UX Components and other aspects of ADEP in future posts…

Update 6/30/2011: “What is a UX Component?”

[1] You may recall that I spoke about XOA during my MAX 2010 session, “Realizing great customer experiences with LiveCycle ES3.” (ADEP replaces “LiveCycle ES3.” ADEP is the new brand that incorporates aspects of LiveCycle with aspects of the Day Software aquisition.)

Earlier this week, my wife and I finally got to see U2 in concert after purchasing tickets more than two years ago due to a mid-concert accident by Bono in 2010. I recall having a better time at the U2 concert in San Jose (Vertigo tour), but it was a good time nonetheless–could have been due, in part, to enjoying good seats…

This first video–all were taken with my Flip video recorder and uploaded directly to YouTube in HD–is Lenny Kravitz opening his act as the main opening band for U2 with “Come On Get It.”

The second video is Lenny Kravitz performing “Let Love Rule.”

The third video is U2 performing “Elevation.”

The third video is U2 performing “City of Blinding Lights.”

Social is a popular adjective in software these days (along with cloud and mobile); so, I thought I’d capture some of how I view social in light of enterprise software and customer experience.

When I think about “social software” I think about how experiences are impressionable (e.g. customers can leave impressions causing other direct/indirect participants to learn/benefit/dialog/collaborate). To me, “social” means allowing users to leave impressions such that impressions are mined for context and understood in context. Software that embraces this notion of sociability becomes more context-sensitive as a whole much like a piece of UI might present or hide itself depending on context (e.g. user’s role, workflow state, etc.) or a different service is invoked depending on context (e.g. SLA).

To me, “social software” isn’t about simply sprinkling social artifacts into existing systems (e.g. adding tags, ranking, etc.). It’s about ensuring that software incorporates sociability into its equilibrium as presented to customers.

One hears “less is more” and “more is more.” I find that both can be true, and the user will ultimate indicate the truth. In the case of providing more context, a user action to exclude is social to the underlying system, if that system is built to recognize it as such. That is, being exclusive is part of being social; excluding (and including) is a form of engagement. “Social software” must promote engagement–for relationship-based business benefit.

Being social can mean being friendly (i.e. sensitive to past expressions of preference, a form of context, as well current inference of the task at hand in a framing goal). A context-sensitive platform should go beyond just facilitating “one degree of friendliness.” It should anticipate the implications of deeper…collaboration. When a compelling experience and frictionless interaction is delivered to one, it can become a beacon for many subsequent experiences and interactions. So, how can this downstream effect be understood up front? How should context-sensitivity adjust, pivot, etc. to optimally understand this potential (reality)? “Social software” get this at its core.

Social is about collaboration–with purpose. To understand/infer purpose requires being sensitive to context.[1]

My definition of being social is as follows: a software system that allows any user to leave an impression, expecting that the system will recognize it, understand it and subsequently bring it to bear on the resulting experience, across space and time (i.e. same customer and/or different customer(s), immediately and/or in the future). This is just one of the traits we’re building into our enterprise platform at Adobe.

[1] For more on context, you may want to check out what my colleague Ben Watson has started over at Contextography.com.

Dear Outlook team:

As I was riding home on the train today talking with my fellow riders, an idea for a practical feature in an upcoming Outlook release developed. Since time is precious, and I’m focused on other pursuits, I wanted to place this idea into the Creative Commons for your consideration.

At least the passengers of the train car I typically occupy find it all too common to receive meeting requests in Outlook that clearly conflict with existing appointments already scheduled. It’s as if the person who called the meeting just added names (reading off a script) without even bothering to click into the Scheduling Assistant UI.

This is unfortunate since that UI does a fairly good job of actually assisting the caller of a meeting with the scheduling process.

However, it’s hard to teach a drone how to find pollen; so, I think there is an opportunity to bring more assistance into the default Appointment UI.

Sparklines.

Here’s the essential idea: as attendees (or resources) are entered into a meeting request, dynamically shade the background of each name according to availability as follows:

• Green – potential attendee is completely available
• Yellow – potential attendee has a tentative conflict (i.e. a complet or partial conflict)
• Red – potential attendee has already committed to attend another meeting

Changes to the date/time of the meeting should trigger event handlers that reflect any change in availability shading.

Additionally, you could also provide another, central visual cue for the overall meeting (e.g. a green highlight effect around the current Send button to indicate that there are presently no scheduling conflicts known to the system).

Frankly, I think it’s fair to question a person calling a meeting who doesn’t bother to confirm attendee availability. However, we are talking about drones not worker bees. So, for those of us who receive such meeting requests all too frequently, please consider this idea for a future release of Outlook. (If you have implementation questions, you can always reach out to your Excel colleagues. )

Thanks for your consideration.

The industrial age challenged us to rethink the limits of the human body: Where does my body end and the tool begin? The digital age challenges us to rethink the limits of the human mind: What are the boundaries of my cognition?

It’s tragically ironic that the tagline for Douglas Rushkoff’s book incorporates an Old Testament reference to the Ten Commandments, since Rushkoff writes in his introduction that the Jewish race has, since the time of Moses, merely promoted an “enduring myth” where the contents of those stone tablets is concerned.

Regardless, Rushkoff’s perspective is fascinating and worth some contemplation:

• Are we just learning to use programs or are we learning to make programs?
• Do we favor the distracted over the focused, the automatic over the considered, and the contrary over the compassionate? Why?
• Do we merely grant our kids access to the capabilities given to them by others, or do we empower them to determine the value-creating capabilities of these technologies for themselves?
• Do we pursue new abilities, or do we fetishize new toys?
• Are we optimizing our machines for humanity, or are we optimizing humans for machinery?
• Do we think and behave differently when operating different technology as we do given different settings?
• Are we allowing computers and networks to discourage our more complex processes–our higher order cognition, contemplation, innovation, and meaning making–in addition to copying our intellectual processes (i.e. our repeatable programs)?

…and these are questions that arise after reading just the introductory chapter…

Apparently Rushkoff’s book grew from a short talk he has given on the subject, and there is substantial commentary to wade into just on the talk alone. [1][2]

Contemplation. Something that can all to easily become sacrificed on the altar of busyness. Something to fight for, protect and prize. Warmly embracing why.

Here’s to a 2011 that is more focused, considered and compassionate!

[1] http://rushkoff.com/2010/03/25/program-or-be-programmed/
[2] http://boingboing.net/2010/03/30/rushkoff-program-or.html

A little over a month ago, I encouraged my readers–many new from the Day Software (now Adobe) community via the Ignite conference in Berlin–to download and leverage Adobe Enterprise Café.

…the Café is hard at work to integrate the Day community as well. However, you don’t need to wait for that new version of Café; you can install Café today and when the Day community is integrated, you’ll receive that update the next time you launch the Adobe AIR application.

Hopefully you’re already receiving value from Café. If you held out for the Day community integration with Café, that day has arrived.

Presenting Adobe Enterprise Café 1.6!

Update 7/29/2011: Now that the Adobe® Digital Enterprise Platform (ADEP) has been announced, I recommend that you upgrade to Adobe Enterprise Café 1.8, which features a new ADEP community that is the combination of the previous LiveCycle and Day Communities.

For technical insights on ADEP, please follow the ADEP category and/or ADEP tag herein. Thanks.

Several years ago, I blogged about how I winnowed atom-based content at that time. When I consider my increasingly digital life now, I smile at how out-dated that post seems.

Maybe some day I’ll let go of my hardcopy altogether and go 100% digital.

Almost two years after my winnowing (paper-based) content post, I briefly waxed sentimental about personal content management. Judging by that post’s imagery, I’m not sure how much “evolution” had actually occurred. I do know that the binders of paper were eventually tosed outright, but even a quick glance at my current technical library at home tells me that I have far from reached any “evolved” state.

As a visual person, I tend to value what I can see and tangibly interact with. Books present a particular challenge to me. A good book, in hard cover format especially, is immediately available to give to someone else as a loan or a gift (e.g. from one generation to the next). The same book in electronic format is more subject to the winds of technology (e.g. will there be a reader for this format? what all is required to actually read the book in terms of supporting hardware and software? etc.). On the other hand, if I took the time to bookmark or otherwise annotate paper, this could distract subsequent reading by others–electronic metadata should be more distinctly layered and separable from original content.

Given the choice between hunter or gatherer in a shopping context, I’m definitely a hunter. Put me in the middle of a men’s department or clothing store and I’ll happily panoramically scan the selection, deciding in mere seconds whether there is something for me (to killpurchase), or not. (Thankfully, my wife is my primary wardrobe consultant; so, my hunter instincts are necessarily balanced and muted. ) However, as much as I may be a hunter over clothes, I am a serious gatherer of books and music. Places like Barnes & Noble and Borders love guys like me.

So, you might think that my struggle over books (i.e. physical or digital) is a struggle I have with music, too. Perhaps, but I think that my music-as-content evolution is a bit more “advanced” and, therefore, may be informative.

Although I still buy physical CDs more than digital downloads, all of my music is immediately rendered in digital format and almost entirely consumed digitally thereafter. Going “essentially digital” has enabled me to take full advantage of classification software (e.g. MusicBrainz, freedb, etc.), playback software (e.g. Apple iTunes, Microsoft Zune, etc.), recommendation engines like Pandora, etc. and also various playback hardware (e.g. an Apple iDevice, laptop, PC, etc.). If I read the liner notes for an album, I do so once (typically after unwrapping the CD). From then on, interaction with music is based on bits rather than atoms (the occasional CD play through my high fidelity entertainment system notwithstanding).

Perhaps with the advent of The Undesigned Web, software like Instapaper, and hardware like iPad, etc., my interaction with reading material will tip to become predominantly digital. Certainly, as I use the Read Later feature of Instapaper, I find it to be a digital equivalent to my paper-based content winnowing approach from years ago. (Tapping into familiar workstreams is always an effective catalyst to change my behavior.)

…if I did go digital my office would be too Spartan.

Actually, I think another contributing factor to my attempt at balancing the gathering of atoms with gathering bits instead is the fact that there is limited physical space to house either. Today, it’s not really a concern over becoming Spartan, it’s about using limited wall and desktop space to display physical items of the greatest value (e.g. family photos, art, sculpture, etc.).

Just like I’m able to visualize the “height” (or “depth”) of, say, my iPod (i.e. the number of digitized albums stored in terms of a stack of CD cases), I’m beginning to visualize my iPad in a similar manner (i.e. in terms of the stack of print magazines and books available electronically instead). Virtually speaking, such devices “fill a room.”

Who knows, I may just have to invest in my own book scanner to help free up some shelf space…

Thanks to everyone at Day Ignite Berlin 2010 who came to the technical track session that I presented this afternoon. In order to keep the conversation going, I’ve uploaded this presentation as follows:

During this presentation I recommended that you consume my “Realizing great customer experiences with LiveCycle ES3″ presentation from Adobe MAX 2010, if you’re interested in more details about the architecture and capabilities of LiveCycle ES3. You will find that presentation here.

I also asked you to consider downloading and installing Adobe Enterprise Café. Café, as we like to call it in Adobe, helps you stay in touch with the enterprise community, receive news, find information and aggregate content related to Adobe LiveCycle ES (Enterprise Suite), Acrobat, Connect, ColdFusion, the Adobe Flash Platform, and (since its v1.5 release) the Omniture community. Targeted at the general developer ecosystem, Café is the one tool you need to search across the entire community knowledge base and stay in touch with the Adobe teams. Furthermore, the Café is hard at work to integrate the Day community as well. However, you don’t need to wait for that new version of Café; you can install Café today and when the Day community is integrated, you’ll receive that update the next time you launch the Adobe AIR application.

When I presented this session with Alex Choy in Chicago, Irina Guseva of CMS Wire published her thoughts on the session: “Apps as Content, or How Day and Adobe May Fit Together.”

Thanks to everyone at Adobe MAX 2010 who came to the session that David Nuescheler, Roy Fielding and I presented. If you weren’t able to attend our session, it’s provided below.

Roy kicked off the discussion by talking about open development and how open development is critical to architecture. David followed Roy by showing how open development principles have been powerfully applied at Day to its products like CQ5, providing live demonstrations to our audience. I wrapped up this discussion by relating WCM and Day content infrastructure (e.g. Sling and CRX) to Adobe’s CEM platform and specifically to LiveCycle RIA. (For more detail on LiveCycle RIA and other aspects of the LiveCycle ES3 release, which is currently under development, please see my previous post.)

In order to keep the conversation going, I’ve uploaded this presentation as follows:

Update 11/5/2010: You can now watch and listen to this MAX session online (i.e. in synchronized fashion).

Update 12/3/2010: Jayan has done a nice job of rounding up LiveCycle-flavored MAX sessions, including this one, here.

Thanks to everyone at Adobe MAX 2010 who came to the sessions that I presented. I enjoyed the interactivity during after after the presentations, especially listening to your thoughts on how Adobe CEM will enable you to realize your own customer experience vision as well as the growing expectations of your prospects, consumers, customers and clients.

In order to keep the conversation going, I’ve uploaded this presentation as follows:

Realizing Great Customer Experiences with Adobe® LiveCycle® ES3 – Craig Randall

Whether you were able to attend MAX or not, I encourage you to check out MAX 2010 on Adobe TV (e.g. here are the keynotes). Please also visit the MAX 2010 session catalog to browse all sessions and download presentations of interest.

Update 11/5/2010: You can now watch and listen to this MAX session online (i.e. in synchronized fashion). It appears that the good folks at MAX decided to post the slides and recording that corresponded to my first delivery (on Monday during MAX). While that session went well, I did receive some feedback that I incorporated into a revised deck that was also recorded (on Wednesday during MAX). Personally, I liked the latter content and delivery better than the first, and that is what is provided here in this blog post, above.

Update 12/3/2010: Jayan has done a nice job of rounding up LiveCycle-flavored MAX sessions, including this one, here.

The closing event for Day Ignite Chicago 2010 was a real treat: a private concert by the Bernard Allison Group at House of Blues® Chicago.

The band, left to right:

• Jose James (sax, backing vocals, percussion)
• Bernard Allison (guitar, vocals, keyboards)
• Erick Ballard (drums)
• George Moye (bass guitar)
• Toby Marshall (keyboards)

This first video–all were taken with my iPhone and uploaded directly to YouTube; so, the quality isn’t the best–is the group opening without Bernard, playing the first track off their latest album The Otherside: “Send It In” (2:42).

The second video above is “The Otherside”–track #5 off their latest album of the same name (6:01). At the beginning of the video, Bernard introduces the band.

The third video above is the group going Hendrix, playing the Jimi Hendrix classic, “Fire”–also the 11th track on The Otherside. Around the 5:57 mark, Bernard introduces Erick Ballard for a substantial drum solo that earned him the evening nickname of “The Energizer Bunny” (12:34).

The fourth video above is a two-song medley that highlights various band members (8:39).

The fifth video above is a bass solo by George Moye (4:10).

I recorded another video that occurred in between the fourth and fifth videos above; however, it was 15:40 in duration and YouTube doesn’t accept videos longer than 15 minutes currently.