Adding Search to Jasperserver: A Cautionary Tale

Summary

Our upcoming 3.7 release of Jasperserver includes a major new feature: faceted search.

As the first major initiative I pushed for after joining Jaspersoft as User Experience Architect, search was my pet project. While I am certain the new functionality has improved the user experience for some users, I believe, due to flaws in the design process I led, we missed an opportunity to deliver an interface that made finding objects in our system dramatically simpler for all users.

This post is an illustrated attempt to break down that design process in the hopes that others may benefit from understanding the errors I made and the lessons that I have learned (or, sadly, re-learned).

Lessons (Re)learned

To help you parse this long post, I’ll begin by listing the lessons I took away from the search project:

  • Never assume the primary persona or the essential use cases
  • Mockups are not prototypes
  • Evolution is an easy sell; revolution requires data
  • Performance matters

And most importantly:

  • NO PET PROJECTS!

The Starting Point: An Expert Interface

In Jasperserver 3.5 the only way users can find reports and other objects contained in the system is via an interface that looks like this:

This design is obviously modeled on a file browser.  As such, it suffers from the problem shared by all browse experiences, namely that it is a tool for experts, not novices.

Because it is designed to expose the file structure, a browse tool provides a good experience for the administrator who needs to create or maintain that structure.  However, for the business user who knows the name of a report stored in the repository, but no idea of the logic the administrator used to construct the structure, using a browse interface is a bit like an easter egg hunt. I explain this issue in more detail in this post.

As the percentage of Jasperserver users who maintain repositories is considerably smaller than the percentage of Jasperserver users who want to find the reports contained within the repositories, my feeling was that the repository interface was optimized for the wrong persona.  I believed that we could fix this usability issue by adding a search functionality to our server, and then optimizing the repository interface around the new search feature.

I made this argument in a number of product planning sessions and succeeded in getting a search project prioritized for our next development cycle.  Paradoxically, this early success was the source of my biggest mistake.  By focussing on functionality, I sold the idea of adding search, but, as it turned out, never actually got buy-in for the crucial underlying assumption that we should optimize our design for the repository user, rather than the repository creator.

The Mockups

In my initial storyboards for the new repository experience, I proposed a faceted search navigation combined with a federated results display:

The point of the default design was to present the objects in the system in terms of meta data most relevant to a business user.  However, because we did need to support the administrative workflow for creating and maintaining the hierarchical structure, I proposed that users be able to opt-in to a view of the file structure, by pressing a button:

If exposed, in addition to various management functions, the folders could be used to control the scope of the search, and, combined with the search string and the other facets used to refine the found set. I thought this design was starting a bit complicated, but as viewing the folders was an opt-in experience, I was comfortable that by default we would be offering a simpler presentation of the repository objects.

I used images like these in storyboards detailing a variety of use cases that I shared with project stakeholders. The storyboards were met with a favorable response and we moved into production.

In retrospect I now understand that this was the point where I made a second, crucial mistake.  This was that I moved directly to storyboards without first establishing with the stakeholders what the critical use cases actually were.  If I had begun by asking the stakeholders to help me define the most important use cases I think we would have uncovered almost immediately the fact that many of the stakeholders did not share my main assumption that we should optimize the design for business users.  Instead, I presented storyboards that embodied the business user persona assumption implicitly.  As a result stakeholder approval of these storyboards really only meant that the storyboards told stories that made sense.  Approval did not mean, as I assumed, that the storyboards made sense and told the stories we all thought were most important!

First Prototype and First Hiccup

This problem only began to be clear to me when we finally presented our first working prototype.  It didn’t have the all the filters working and it didn’t group the results by type, but was otherwise quite faithful to the mockups:

And, as proposed, folders could be exposed and used to set the search scope:

The reaction of several project stakeholders to this prototype first alerted me to the fact that we did not all share my fundamental assumption that we were optimizing this design for repository users, rather than administrators.

The trouble began when the stakeholders finally understood that the folders were acting to set search scope, not to define the location of the panel that displayed objects.  You can see this in the screenshot above.  The folder ‘Ad Hoc Components’ is selected, but if you look carefully at the path shown for the displayed objects, you will see that these objects are all actually located in a child folder ‘Topics.’  From a search perspective this is correct: the search is finding all objects that match the current search string (in this case the empty string “”) located within the selected folder and all its children.

However, from a browse perspective this is an incorrect result because only results located in the currently selected folder should be visible.  In this case, this would mean no results would display. Once this difference was understood, the stakeholders insisted that the administrative user could no longer use the interface effectively because it would not meet his browse expectations.

Compromise Mode

It was now clear to me that I had made strategic blunders in managing the design process for this project.  Rather than leading the good fight to improve the experience for our agreed upon primary persona, I understood that I was perceived by several critical stakeholders as forcing a dramatic change in interaction model to which they had not agreed and strongly objected.

Suddenly finding myself without consensus regarding the primary design persona, and lacking data demonstrating that the change I proposed would be acceptable to the existing administrative users, I decided that the most responsible thing for me to do was find a compromise design that would quell the stakeholder rebellion and move the project forward.

The first step towards this compromise was the addition of a means by which a savvy user could switch the experience from search to browse mode. While I accepted the political need for this adding this mode,  I knew it probably meant my vision of using search to simplify the repository experience was out the window.

That said, I continued to hope we could still offer a simpler default display.  Here, in the next working prototype, the initial view continued to look like the storyboards, including the results grouping:

However, when folders were exposed, a mode switch was also revealed:

If the user switched to browse mode, then the results display only showed objects located within the current folder (in this case no objects):

The search field and filters would continue to work in this mode, but would be of limited utility as they could only be used to refine the display of the objects within the current folder.

This prototype was a failure for two reasons.  The first was that in playing with it, it became clear that the hidden mode switch was totally confusing. The second issue was that several stakeholders continued to object strongly to the idea that one had to opt-in to see the folders because to quote one “folders are first class filters.”

After presenting this prototype I realized my belief in compromise was overly optimistic.  In fact, what was required on my part, given the political situation, was complete capitulation.  I needed to accept that in order to close this project I had to re-set my fundamental assumption and accept that most stakeholder believed the primary persona for this project was the administrative user, not the business user I had been designing for.

Evolution not Revolution

With this insight, it was clear to me what I needed to do to get to a design all the stakeholders would accept: treat search as an incremental evolution of the existing experience rather than a revolutionary change.

The next prototype looked like this:

The functionality was the same as the previous prototype but the presentation was now designed to promote folders as the primary organizational structure.  The interaction mode was still by default search, but the mode switch was made more prominent and visible at all times.

With this presentational change, stakeholder resistance evaporated.

Performance: the unkindest cut of all

Having accepted the shift in priority, I had made my peace with the new presentation when a final problem surfaced: performance.  It turned out that for technical reasons having to do with how the repository database stored object meta data, creating the object type groupings was extremely inefficient.  The user experience impact of this was that a search that attempted to bring back all types of objects and group them by type would take a very long time when the repository got large.

This discovery came very late in the the production process when no appetite remained for any further design changes.  As a result we settled on the expedient solution of breaking the simple faceting model for object type.  While the rest of the filters defaulted to some kind of ‘all’ setting, the one for type would default to a custom group named ‘Visualizations’ that contained the object types most interesting to business users: reports, dashboards, and analyses.  You can see this change if you compare the screenshot above which shows a filter set to ‘All types’ versus the one below that shows the same filter set to ‘Visualizations.’

With this change we knowingly made it harder to understand the conceptual model underlying the filters.  The only other short-term alternative would have been to abandon the grouping concept entirely, but, lacking any kind of ‘popularity’ algorithm (an earlier sacrifice to project schedule, deemed acceptable because of the grouping concept) this would have meant that by default searches would return arcane object types (e.g. JDBC connections) with the same priority as frequently used types (e.g. Reports).

Conclusion

The conclusion I draw from this post mortem is that the last lesson I listed above is really the most important: no pet projects.

The bottom line here is that, because I was personally invested in this project, I skipped or at least shortcut, a number of steps that I know are part of a successful design project.  Probably the most critical error I made was to confuse the process of selling the project to stakeholders with the user and stakeholder research I should have done, but didn’t, before beginning the design phase.   I compounded this error by relying on mockups, rather than prototypes, to communicate status until far too late in the development phase.  Finally, I did not engage deeply enough with the technical aspects of the project to avoid being surprised by last minute performance issues.

Shifting to the bright side, the early feedback I’ve gotten from users familiar with our product is that faceted search does, in fact, materially improve the experience of finding and interacting with system objects.   In other words, what we did achieve with this project was a tangible improvement in user experience compared to our previous product release.  While my initial design aspirations were larger than that, this positive outcome raises the perennial question of design leadership: when is the incremental, but safe, value offered by evolution a more responsible strategy than the dramatic, but risky, value offered by revolution?

Experience Requirements Document

One of the most significant organizational challenges I encounter as a professional software designer is that, almost universally, the business environments in which I work do not have an established first class design document.

By this I mean there is no existing expectation in the product development process for a document that is intended to capture the design intent of the project.  There will nearly always be an expectation for a document capturing the business justification and market needs for the product–this is usually called the MRD or Marketing Requirements Document.  Commonly  there will be one or more engineering responses to MRD called things like the PRD (Project Requirements Document) or the TS (Technical Specification). And then there is some kind of quality assurance document, often called the QA Test Plan.

But, aside from Apple, I have never found at any software company for which I have worked either full-time or as consultant, a formal, first class design document as part of the established development process.  In this respect, software development is sadly unique.  Pick any other engineering endeavor and you will always find, built-in to the development process, an expectation for some kind of formal design documentation that has the role of conveying the visual and experiential aspects of the proposed project.

In my effort to enlighten the backwards software development world, I have championed the need to include design documentation in the standard project documentation. Generally the first question asked when I introduce this idea is ‘what would this document look like?’ Here, below, please find my latest version of the answer to this question.

Experience Requirements Document

About this Template
This template contains 5 sections. They are structured to present information ordered from highest level to lowest level of abstraction.
The document begins with a discussion of project scope, then moves to a context section that is intended to clarify the fundamental environment and constraints in which this proposed design must succeed.
After describing context, the final three sections are organized around the concept of a house.
The foundation section should define the basic concepts upon which your planned experience depends, in the same way that a house is utterly dependent upon its foundation in order to stand.
The framework section should describe the kinds of affordances, layout and navigation your experience will provide in order to meet user needs. This section is analogous to the framing, plumbing, wiring, fenestration, etc that provides structure, access and functionality to a house.
The finish section describes the presentation and labeling that combine to provide what the user perceives as look and feel. The analogy here is to the paint, trim, moulding, cabinet hardware and other details that are the things people actually touch and see in a house.
This document structure is loosely adapted from the work ‘The Elements of User Experience ‘ by Jesse James Garret.

Tips
  1. Don’t re-invent the wheel. If you can ‘complete’ any section of this document by referencing a previous project, or an existing element in the product’s UI framework, definitely do so!
  2. You don’t have to fill out every section. Some may not be relevant to you. Leave the heading, but note that no information is required.
  3. In general, focus on describing the new things your project is adding to the product user experience. Particularly with respect to the Finish section, you may find you are not adding anything that is not already part of the existing UI framework. If this is case, simply state this and be done. If however you are extending the framework, be very clear about how.

Scope

Design Issue

Explain the fundamental design issue that needs to be addressed with this project. You may be able to draw from the MRD here in terms of the business case or user scenarios.

Proposed Solution

Describe the design proposal in a nutshell. You’ve got the entire rest of the document to provide details so here just create the ‘elevator pitch.’ Just one or two sentences capturing the major UE impact and benefits.

Context

References

Links to relevant documents. Definitely include other internal planning docs like MRD & PRD but also any design references, examples of the experience you plan to create, etc.

Personas

If personas are defined in MRD then echo them here. Add whatever special circumstances or details are needed to improve the reader’s understanding of how these personas are relevant to the project, or how they constrain the UE design.

Primary

You MUST declare a primary persona.

Secondary

Optional but do include if considerations of other personas influence this experience.

Storyboards

Add links here to attached storyboards. If possible, indicate what use cases/scenarios the storyboards cover. If you can connect the storyboards to scenarios or use cases appearing in the MRD or PRD so much the better.

Of course you may include pieces of the storyboards or any other illustrations as clarifying images in any of the sections below.

Foundation

The foundation section should define the basic concepts upon which your planned experience depends, in the same way that a house is utterly dependent upon its foundation in order to stand.

Conceptual Design

Conceptual Model

What is the process or ‘machine’ the user must create in his mind’s eye in order to understand the basic logic of this experience? If you explain this by citing an existing standard model that’s good. If you need to define a new model, explain why.

Information Architecture

What are the basic pieces of this experience and how are they related hierarchically? How does data flow through this experience?

Language

What unique terminology is used by this experience? What is the domain of human endeavor from which this terminology is drawn?

Interaction Design

Interaction Model

What can the user do? How can he do it? If he pushes on this lever, what door will open? Again, cite an existing model if possible, and if not possible, explain why you need a new one.

Error Model

What kinds of mistakes can the user make and what are the planned mitigations for these errors?

Framework

The framework section should describe the kinds of affordances, layout and navigation your experience will provide in order to meet user needs. This section is analogous to the framing, plumbing, wiring, fenestration, etc that provides structure, access and functionality to a house.

Navigation Design

Orientation

What context does the user imagine himself to be in during this experience? How does he keep track of this context? Are there places where he may lose his context? Identify any modes in this experience and explain why they are required.

Wayfinding

How does the user move through this experience? How does he arrive here, how does he leave and how does he get back?

Interface Design

Idiom

What basic type of experience is this? Is it a designer, is it a viewer, or is it more like a blog entry? Can you give examples of experiences that this one will be similar to?

Modes

How does the user switch modes, how does he know what mode he is in?

Zones

Describe the basic display areas involved in this experience. Don’t forget to include overlays, inlays, pop ups, floating panels, etc.

Modules

Provide detail as required to explain the modules found in the zones you’ve described above. Do explicitly call out any modules that are new addition to the product’s UI framework.

Controls

Provide detail as required to explain the special controls found in any of the modules. In general you will only need to detail controls this experience will add to the product’s existing UI framework.

Finish

The finish section describes the presentation and labeling that combine to provide what the user perceives as look and feel. The analogy here is to the paint, trim, moulding, cabinet hardware and other details that are the things people actually touch and see in a house.

Information Design

Presentation

Describe how the information architecture is communicated and displayed to the user. Also highlight any presentation components or designs that are novel to this experience as compared to the existing product experience.

Categories

Identify the categories that are used to organize the information presented in this experience.

Visual Design

Standards

List with references all the standards you are following in this design.

Style

Identify any planned stylistic deviations from the standards cited above.

Colors

Define your color palette or any additions to the palette identified in the standards section.

Typography

Give examples of any typographic conventions or styles in this experience not already covered in the standards section.

Breaking Down Search and Browse

The point of this post is to describe concisely the technical difference between search and browse.

In so doing I will expose a paradox:

browse experiences are more intuitive but less novice-oriented

search experiences are less intuitive but more novice-oriented.

Examining the Difference

From a computational perspective searching and browsing have a single specific difference:

browse: display objects in terms of a fixed hierarchical structure

search: display objects in terms of shared intrinsic properties.

Let’s examine how this difference plays out in some example interfaces.

Example 1: The Mac Finder

mac finder browsing

The Mac Finder is a great example because, while it prioritizes browsing, it also attempts to integrate the two navigational modalities.

The characteristics of this experience are that:

  • the default interaction mode is browse
  • the organizing principle of the display is directory structure; objects are displayed only in terms of their location within that structure.
    • objects to the left are always closer to the hierarchical root than objects to the right.
    • each pane displays the contents of the selected directory to its right.
  • the design assumption of this display is that the file structure has meaning to the user, and displaying it will help him find his way to the object he seeks.

The overall utility of this display for navigation turns on this last assumption: if the file structure taxonomy has meaning to the user then an interface that faithfully traverses it will be useful to him.

Of course, we all know that this assumption is often not true.  The structure may not meaningful to the user because:

  • he didn’t build it
  • he did build it, but then he forgot the rules he used to build it
  • it is incomprehensibly vast and idiosyncratic like the world wide web.

These issues are in fact different aspects of a single problem: while the concept of using hierarchical categories to organize objects is natural and intuitive, the assumptions underlying any particular taxonomy are arbitrary and idiosyncratic. Thus a browse interface is only efficient as an object-finding tool for a user already expert in the taxonomy being displayed in the tool. Any other user must spend time exploring the hierarchy before he can use it to locate objects of interest to him.

For this reason search is often a more efficient navigational experience because it permits the user to create object displays organized around a particular object characteristic that is meaningful to him.

The Mac Finder affords a transition to search by integrating into the experience in two ways:

  1. the search box in the upper right
  2. the saved search options in the last grouping in the right hand pane.

While these search affordances are visually integrated into the UI, using either of them produces a modal shift in the display:

Mac Finder Searching

The most apparent difference between display modes is that the panes have disappeared.  With them has gone the concept of directionality or left to right flow because that presentation relied upon the assumption that the most important object property to display was the container in which the object was located.  Instead this display groups objects in terms of a user-defined search query, in this case ‘search mode’.

And yet, in this example, reference to structure is still provided as a refinement feature.  At the top of the display pane there is a set of controls that can be used to set the search scope (where to look for objects) and the search field (what to look at within each object):

scope bar

These buttons represent a type of affordance called a filter.  Interacting with them provides the user with a means to reduce (or expand) the objects matched by his search in terms of additional dimensions beyond the query string.

Put another way, these buttons expose to the observant user that the true search expression is more complicated than simply the text query he entered.  In fact the complete expression involves, by default, certain types of metadata.  The fact that the Mac Finder offers structurally-based refinement options by default is an honest reflection that search has been added on top of a system that has as its intrinsic organizing principle the concept of directory structure.

The next obvious question is what about a system that does not have a simple, pre-defined organizational principle? What is the interface that permits users to locate objects in this system?  Let’s consider the world’s most successful example of this kind of interface: Google.

Example 2: Google Search Results

Google Spelling disambiguator

The Google search results page is excellent counter-example to the Mac Finder because it comes at the problem of directing users to objects of interest from the absolutely opposite perspective.

The characteristics of this experience are that:

  • the default interaction mode is search
  • the organizing principle of the display is the user’s query; objects are displayed in terms of their relevance to this query
    • objects at the top are always more relevant (per the rules of Google’s search algorithm) than objects below
    • each listing highlights (literally) the way it is relevant to the user’s query.
  • the design assumption of this display is that the search term has meaning to the user, and organizing objects around it will help him find the best match for his query.

The overall utility of this display for navigation turns on this last assumption: if the query describes the user’s true interest then an interface that displays objects relevant to that query will be useful to him.

Of course, we all know that this assumption is often not true.  The search may not return results meaningful to the user because:

  • the query is spelled incorrectly
  • the query is ambiguous
  • the search algorithm defines relevance in a way that is not intuitive for the user

These issues are in fact different aspects of a single problem: creating a precise rational expression that represents our current interest is hard for people to do. Recognizing this issue, the Google experience provides a number of subtle cues and affordances that help an inherently irrational human create a concise and rational search expression.  In fact, in the image above we can see how Google automatically offers a spelling correction to address one significant source of error.

In the image below we see another tool that Google provides to help users create more specific queries called facets.

Screen shot 2009-11-21 at 10.44.50 AM

Selecting any of the choices in the left pane narrows the results in the right pane accordingly. If multiple selections are made they are applied sequentially to produce a more and more refined set of results. It turns out that this refinement experience feels very browse-like even though it does not actually result in traversing a single fixed taxonomy. This suggests a clarification to the statement that the process of browsing is intuitive. In fact what is intuitive is the process of refinement: iteratively evaluating and editing information until I have thrown away enough of what I don’t want that I can see clearly that which I do want.

Conclusion

Thus we conclude our brief tour of these two interfaces with the interesting observation that, in an effort to overcome the limitations of browse the Mac Finder offers search and, in an effort to make search disambiguation more intuitive Google offers facets as a browse-like option.

Here, then, are our design takeaways:

  1. The more navigating your system feels like a process of refinement the more intuitive it will feel
    1. Navigation tells a story; told correctly the end coincides with the place the user wants to be
    2. His reward for each navigational decision he makes should be an obvious elimination of information from his view
  2. Because browsing is for experts there are only two cases where a browse interface is good design:
    1. You are certain your users will be experts in the system taxonomy
    2. You are certain you want your users to become experts in the system taxonomy
  3. Except for the two exceptions the best choice for navigational design is to base it upon search
    1. Search is better for novices because it does not require an expert understanding of the system taxonomy
    2. Most people are novices with respect to most system taxonomies
  4. A search-based navigational system can, but does not have to, include an actual search field
    1. Links can be used as affordances that trigger searches
    2. Facets can be used to offer an intuitive refinement experience

Simple Storyboard Production Technique

This is a simple technique for transforming a set of images into a sequenced multi-page PDF storyboard.

Limitation is that it is Mac-only because it relies on Preview, the can opener utility that ships with the Mac OS.

  1. Create your storyboard images; you are on your own here
  2. Open 1 of the images with Preview, it doesn’t matter which one
  3. Open the ‘sidebar’ in Preview that let’s you visualize thumbnails of the ‘pages’ in the document; you’ll see a representation of your image there
  4. In the Finder, select ALL the rest of your storyboard images
  5. Drag them into the Preview sidebar
  6. If necessary, drag the images into the correct sequence
  7. Select ALL the images in the sidebar (tip: select the first, scroll to bottom, shift-click last)
  8. File > Print Selected Images…
    1. this option is usually ‘Print…’
    2. the fact that it changes when Preview is displaying, and you select, multiple images is part of the secret sauce
  9. In the resulting Print dialog, make whatever formatting changes you need (i.e. ‘orientation’)
  10. Instead of pressing Print button, use menu in lower left to ‘Save as PDF…’
  11. You are done; you now have a multi-page PDF of your images.

The added bonus is that not only can you share this file like any PDF, you can also easily present it using the ‘slideshow’ feature of Preview.

New Leaf at Jaspersoft

This week is my one year anniversary at Jaspersoft as User Experience Architect.

Appropriately, but coincidentally, this week we are beginning a new approach to integrating UX into the development process.

The New Leaf

This change in methodology is our response to a failed project: a visual redesign of Jasperserver, our flagship product. In this case ‘failure’ was a schedule issue: late in the cycle we realized that we would not meet our release target unless we pulled the redesign from the plan, and reverted it out of trunk.

There are probably 5 or 6 particular reasons why this project failed.  I think it would be useful to take these point by point in some future post. Today, however, I am more interested in how our experience is part of a more general issue: how do organizations combine user-centered design with the agile development methodology?

Faced with our recent failure in solving this integration we are making two fundamental changes:

  1. We are recognizing that not all projects are created equal. Many can be done in parallel but some must be sequenced before other development.
  2. Previously we managed all projects as in terms of requirements, design and production.  Going forward we are recognizing that we need to manage certain projects (see point 1) in terms requirements, design, user experience architecture, software architecture and production.

Recognizing the Special Projects

With respect to the first point, my initial guess as to what defines a project that must be done sequentially is one that creates a change in the object model of any software layer. A sexier and more compact formulation would be to say that architecture projects must be sequenced.

You might recognize such a project because it involves changing or upgrading a named framework.  Switching from a homemade set of Javascript utilities to jQuery is a good example. Upgrading to a newer version of Spring would be another.

Our ‘Visual Redesign’ project is another good example. At one level the architecture that was changing was purely visual: the visual logic of the pages, the color palette, the typography and the massing and organization of the white space. However, the true focus of the project was to change the markup structure in order to enable the new, beautiful and flexible visual design. This is the crucial point.  Once we agreed to change the markup, we were agreeing to change the DOM structure, and this meant invalidating many of the assumptions upon which the event handling scripting was based. This in turn made it impossible to move forward with almost any other work.

It’s the interface, stupid

The simple reason parallel development was blocked was that converting over to the new framework broke the UI.  We learned very quickly that a broken UI made it challenging to progress even on initiatives that were classified as infrastructure projects. The reason, obvious in retrospect, is that in the execution of essentially all projects the graphical user interface is the primary tool developers use to evaluate whether their changes are successfully meeting requirements. In addition, without a functioning UI, all QA testing, both manual and automated, ground to a halt.

As an initial mitigation we tried to maintain both the old and new UI environments simultaneously. Within two weeks of embarking on this program we realized that rather than reduce risk, the parallel approach dramatically increased it by literally doubling our development effort. Given that the business could not double our available schedule, maintaining two environments meant guaranteeing we would miss our target release date.

This all came to a head after a week in which the entire team worked long hours and yet we saw almost no meaningful progress on new features and zero reduction in our bug count.  At this point, even I, the primary cheerleader for the project, had to admit it was time to back out.

Three Heads Are More Rational Than Two

Following this painful but entirely rational decision (OK, maybe there was a little bit of yelling) we’ve begun looking at how we are going to get the Visual Redesign into our next release. As mentioned above, in addition to realizing a visual redesign is a special kind of project we have increased the body count at the planning table.  Whereas in round one we staffed the planning phase with just myself, the UX architect, and  a software architect, this time around we are including a third player: the technical manager.

Our thought is that this addition will produce two distinct benefits.  First, it means the cycles the software architect has available for this project will be devoted to the production of his most valuable contribution: a rock-solid interactive architecture.  This time he will not have to split his effort and allegiance between producing the best architecture and planning the steps involved in implementing it within the allotted schedule.

Second, including the technical manager from the beginning means that as soon as the frameworks begin to form, be they conceptual models or interactive frameworks, they will be critiqued by a third party who has no personal investment in the vision they represent, but is simply concerned with their tactical production implications. Our hope is that this practical critique will help trim the fat from the architectural visions without producing the compromise in ideals that occurs when talented individuals spar endlessly over the myriad important, but ultimately arbitrary, decisions that comprise a holistic and internally consistent vision.

That’s the theory, anyway.