SpotifyStatusApplet v1.3 Beta 1

SpotifyStatusApplet Playing

A small update to SpotifyStatusApplet has been released as a beta.

This version fixes a critical issue with newer versions of Spotify that prevent the applet from working. Thanks JeffreyO.

It also adds the (much requested) feature of playback control using the remaining soft keys: 2 – previous, 3 – play/pause toggle, 4 – next. Thanks JeffreyO.

More information is available on the Project Page.

Beer Catalog

BrixtonIn recent months I have had the opportunity to increase the gamut of my beer tasting. As a side effect I have begun to lose track of what beers:

  • I’ve tried
  • when I’ve tried them
  • would I them drink again

In order to keep a better track of these beers I have created a beer catalog page capturing what I deem to be the important details.

I’ll also be posting about beers as and when I taste them.

Ode to IBM Rational Rhapsody

Ode to Rhapsody

to the tune of “Comme d’habitude” / “My Way”

And now,  the end is here Pentagram_and_human_body_(Agrippa)
And so I face, the final codegen
My friend, I’ll say it clear
I state my Use Case, I’ll draw a Lifeline
I’ve declared a class that’s pure
I created each and every dependency
And more, much more than this, I did it in Rhapsody

 

Branches, I’ve merged a few
But then again, too few to mention
I did what I had to do and saw it through without testing
I planned each charted course, each careful step along the activity
And more, much more than this, I did it in Rhapsody

 

Yes there were time, I’m sure you’ll mention
When I lost my rag, adding functions
But through it all, there is still doubt
Should it be In, InOut or Out
I chose them all, I felt small, I did it in Rhapsody

 

I’ve waited, I’ve waited and cried
I’ve had my fill, my share of generating
And now, as tears subside, I find it all so amusing
To think, I did all that
And may I sat, not in an efficient way
Oh no, oh no not me, I did it in Rhapsody

 

For what is a shared pointer, what has it got
If not newed, then it should be nought
To be the thing it truly feels, must be cast dynamically
The model grows, the model slows, I did it in Rhapsody

 

Yes, it was Rhapsody

 

P.S. The etymology of Rhapsody leads us back to Greece; rhaptein ‘to stitch’ + ōidē ‘song, ode’.

Image courtesy of Wikipedia.

 

Antimatter Poster

During university I produced a poster on the topic of Antimatter as part of a Communicating Science module.

I put this up on the web in 2007 and years on, I am seeing traffic to the site driven by a link contained in a Rutgers assignment concerning Information Design. Unfortunately, across the years the poster image had become unavailable…. until now. While the poster was discoverable via a Google search (finding it hosted without permission on other sites, another story) in order to help out those eager students I will post it here permanently.

 

Antimatter

Software Metrics and Craftsmanship

Gource

Software Development Metrics are a notoriously difficult area, there exists a large allure of quantitative measurements that can be condensed into a top-level dashboard showing progress, plan alignment, effort , costs and so on. However, the unfortunate reality is that the collection and analysis of Software Development Metrics is difficult for a number of factors such as complexity, variance, meaning and gaming of the system. Often it is a difficult case of understanding if we are more interested in the performance of the project (Health) or the performance of the developer (Efficacy).

The effectiveness of metrics themselves will most certainly affect their usefulness and the strength of decisions based on their analysis but it is the potential for gaming of the system that I find most worrying. In the simplest sense, I mean the Human optimization of the reward/penalty system for which the metric provides an input. This coupled with Measurement Inversion begets an environment that can devolve into detrimental, with the focus on low value metrics and developers preoccupied on maximizing their score rather than on the Health of the project.

I feel some of the difficulty with Software Development Metrics comes from the nature of the development activity. Despite attempts at documentation, formalization and rigidity (with various levels of success) much of the development activity can still be quite organic. To be more explicit, the concept of Software Craftsmanship is one that strikes a similar chord to my experiences. This goes as far as an online manifesto and prompts rebuttals of the craftsmanship concept. This seems to be quite a conflicting topic but the way I read things, it is often a matter of perspective with the contributors sometimes advocating the some underlying principles. Perspective and trend also come into the job titles; what are the differences between Software Engineer, Software Developer and Software Programmer?

Following the line of argument, although we could say that developers are not factory workers and that there may be some level of craft to their work, does it rule out metrics? I wouldn’t say so completely but I think the focus showed be more towards the Project Health side of things. A craftsman may prefer to be measured by the quality of the product rather than the volume – and if human nature tends toward gaming of the system, the result will ideally be to improve the quality. Now we just need to agree on Software Quality metrics…

 

Image courtesy of FreeFoto

UI Navigation – Android

Flight of the NavigatorUp vs. Back or in other terms hierarchy vs. chronology is one of the User Experience aspects touched upon in my post UML: Modelling User Interfaces Part 1 – Hierarchy and Navigation. The Android methodology for UI navigation has received some attention over the years and the largest change to date was brought in with the introduction of the Action Bar as part of Android 3.0+.

Pre-3.0, Navigation would occur as a result of widget interaction (forward nav) and the system Back button or user defined Back widget (backward nav). Post-3.0 the Action Bar now offers an Up button in addition to the previous Navigation methods.

The Up button is used to navigate within an app based on the hierarchical relationships between screens. For instance, if screen A displays a list of items, and selecting an item leads to screen B (which presents that item in more detail), then screen B should offer an Up button that returns to screen A.

If a screen is the topmost one in an app (that is, the app’s home), it should not present an Up button.

The introduction of the Action Bar and the Up navigation method is no news, so why am I posting about it now? The Google documentation of Android Navigation goes to some length to describe and clarify the current situation. I feel the information presented there resonates with some of the points made in my post that I shall explore further

Navigating to screens with multiple entry points

Sometimes a screen doesn’t have a strict position within the app’s hierarchy

Indeed! I wish I had been able to capture this point so saliently. The concept of an always available page runs counter the that of a fixed hierarchy and yet it is a very common use case. Following the advice of the Android documentation, back or up should return the user to where they previously came from, in a tree-like hierarchy this could only be achieved by having the page as a child node of every node. This sets some warning flags regarding duplication.

Changing view within a screen

Changing view options for a screen does not change the behavior of Up or Back: the screen is still in the same place within the app’s hierarchy, and no new navigation history is created.

Obvious? This can be treated as an internal state change. Some actions are clearly an internal change but are they all, this is very much a UX issue and the actions/outcomes should match the user expectations. The decision as to whether to keep the behavior internal or cause a navigational transition is debatable and often an area for user feedback and iteration. One approach would be to look at this from a function/non-functional change perspective – does the action cause a change to the current function or user sequence?

Navigating between sibling screens

When your app supports navigation from a list of items to a detail view of one of those items, it’s often desirable to support direction navigation from that item to another one which precedes or follows it in the list.

This is personally the most interesting point of the article, the concept that navigation between siblings is neither a hierarchical or chronological navigation action. On first site this may be difficult to articulate to a user, designer or implementer, however, in real term usage there are many straight forward use cases e.g. viewing multiple photographs one-by-one in an image gallery, or selecting between songs in a music player.  The Android article does highlight where the alternative approach is used and it is a legitimate case. The selection of implementation is therefore quite tricky and should be done to best provide affordance to the user.

Looking at this from a tree-like hierarchy perspective, the notion of sibling-to-sibling node navigation (and the notion that Up or Back should operate independently of the nodes) is something that breaks the rules.

Sibling Navigation

 

Summary

Hierarchy Navigation on the Android platform was enhanced with the introduction of the Up button in version 3.0. Android documentation provides guidance and clarification on the UI in order to provide the best UX. The documentation provides several examples that resonate with concepts raised in my earlier posts. The main theme of these is that a strict, rigid Hierarchy is not rich enough to articulate the nuances of everyday device and app usage, not convoluted applications but intuitive ones. From the perspective of a tree-like hierarchy, several elements bend or even break fundamental rules and pose the question “Is the Tree fuzzy enough to accommodate me comfortably?”

UML: Aside – Completeness vs Clarity and other CvCs

imageOne of the recurring issues I have experienced with UML, or more generally Model Driven Design is the continual struggle between definition and interpretation. One of the tenants of UML is to abstract upwards towards a level that avoids implementation specifics. However, this introduces the potential for a need of a “Leap of Faith”, something that was discussed my post UML: Modelling User Interfaces Part 1.

In tools that allow a complete forward driven Modelling approach (by this I mean where the model generates code for implementation) the gap between abstraction and implementation must be bridged, generally by propriety extensions, properties or mechanisms. Ignoring some of the practical issues, this seems to work counter to the benefit of the abstraction in the first place, putting a larger burden on the Modeller. However, a counter argument is that these additional decorators offer and capture the bridging formally and explicitly; this could be view as beneficial in comparison to implicit knowledge held withing a group. Whether the Model is the best place to document such information is a topic for another day. Continue reading

Android Resource and the Eclipse switch Quick Fix

In the process of updating and refactoring an old Android project I unwittingly changed a Project configuration option (the “Is Library” option) that lead to my resource file being generated differently. E.g

Before

public final class R {
    public static final class id {
        public static final int button1=0x7f090001;
        public static final int button2=0x7f090002;
        public static final int button3=0x7f090003;
    }
}

After

public final class R {
    public static final class id {
        public static int button1=0x7f090001;
        public static int button2=0x7f090002;
        public static int button3=0x7f090003;
    }
}

A subtle change indeed but one that caused the following compiler error for each line

case expressions must be constant expressions

Continue reading

C and C++ Preprocessor: warp, Clang and GCC

http://pixabay.com/p-92418/?no_redirectI belatedly came across the news regarding warp, a C and C++ preproccessor written by Walter Bright in a joint project with Facebook. This has been released under the Boost license and is available at https://github.com/facebook/warp.

The Facebook blog makes the following statement with regards to  improved efficiency over the GCC preproccessor

Replacing gcc’s preprocessor with warp has led to significant improvements of our end-to-end build times (including linking). Depending on a variety of circumstances, we measured debug build speed improvements ranging from 10% all the way to 40%, all in complex projects with massive codebases and many dependencies

The AMA on Reddit and the comments on Hacker News have some interesting commentary on the performance claims, as always with performance measurement and comparison this is a difficult field to navigate.

I am reminded of a recent bottleneck I experienced in the build process of a medium sized project using GCC for an ARM target. The investigation identified the major culprit to be the preprocessing stage, specifically the Search Path for header files was very long. A long Search Path is not something that I would have immediately assumed would be the cause of the bottleneck but other lines of investigation were strongly indicating this was truly the cause.

Continue reading