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.

Inspiration

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.

Felix Baumgartner
Vertical track
View of Earth below
Temperature and pressure
Inside closed capsule
Inside opened capsule
Stepping out
Stepping out
Stepping out
Jumping off toward Earth
Speed record achieved
Freefall short of record
Guided flight
Guided flight
Home sweet home

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:

Stratos Mission Control Team

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

Integration

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/

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?

Adventures with Twitter in Groovy

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.