Christopher Bennage

More On Caliburn & Silverlight’s SaveFileDialog

Christopher Bennage — Tue, 06 Oct 2009 21:20:00 GMT

I was a bit hasty in my earlier post when I called the SaveFileDialog inadequate.

One complaint I was going to make was simply a matter of my ignorance. It had to do with the dialog thinking that it was not initiated by the user.

In particular, it was some of our Caliburn magic obscuring this. However, it’s powerful white magic that does more good than harm. :-)

The problem is this, the SaveFileDialog can only be shown as a result of a user’s action, such as clicking a button. (I’m sure this is driven by security concerns that aren’t entirely clear to me.)

If your code follows this sequence:

user clicks a button
the event handler initiates a web request
the callback for the web request tries to show a SaveFileDialog
the world ends (not with a bang)

Then you will get the “Dialogs must be user-initiated” exception, because Silverlight doesn’t trace the web request callback back to the button click.

Deep Magic

In regards to the Caliburn magic that obscures this, I had a method that looked something like this:

public IEnumerable<IResult> DownloadFile()
{
    var result = new Result();
    var query = new GetBinaryContent(_data.ContentId);
    yield return new ProcessQuery(query, result);

    if (result.HasErrors)
    {
        yield return Show.Errors(result);
        yield break;
    }

    var saveFileResult = new SaveFile();
    yield return saveFileResult;

    if (saveFileResult.FileStream == null) yield break;

    var content = result.FindResponse(query).Data;
    using (var writer = new BinaryWriter(saveFileResult.FileStream))
    {
        writer.Write(content);
        writer.Flush();
    }
}

This method lives on the ViewModel, and _data is part of that model. It contains the metadata for a file (name, type, last updated) as well as an id for fetching the actual binary content.

First, it processing a query, which is actually an asynchronous web request. If there are errors then it displays them, otherwise it opens a save file dialog. If the users provides a file, then the binary content is written out. The problem here, that is not obvious, is that the save dialog is being opened as a result of the web request and not directly from the user’s click. If I reorder the code in the method, so that the save dialog is shown before processing the query then the exception goes away. In other words, the code below does not throw an exception.

public IEnumerable<IResult> DownloadFile()
{
    //open the dialog _before_ the web request
    var saveFileResult = new SaveFile();
    yield return saveFileResult;

    if (saveFileResult.FileStream == null) yield break;

    var result = new Result();
    var query = new GetBinaryContent(_data.ContentId);
    yield return new ProcessQuery(query, result);

    if (result.HasErrors)
    {
        yield return Show.Errors(result);
        yield break;
    }

    var content = result.FindResponse(query).Data;
    using (var writer = new BinaryWriter(saveFileResult.FileStream))
    {
        writer.Write(content);
        writer.Flush();
    }
}

N.B. All of these implementations of IResult are specific to our project and are not a core part of Caliburn. However, Rob is creating similar (and improved) versions of a few in the samples.

thinking out loud: asp.net mvc & nhaml

Christopher Bennage — Fri, 02 Oct 2009 20:48:00 GMT

I’ve been playing around with the view engine nhaml and asp.net mvc. At the same time, I’m playing around with some architectural ideas in hope to benefit future projects.

I’m not doing any fancy yet, but I thought that it might be interesting to show you a couple of things to see what you think. Bear in mind, this is my sandbox code. I also suspect that I’m reinventing some wheels.

The context here is a page that allows a user to register for an account on the site.

First, the view looks like this:

%h2 Create Account

%form{method="post"}
  = Html.FormField<OpenAccount>(x=>x.AccountName)
  = Html.FormField<OpenAccount>(x=>x.EmailAddress)
  = Html.FormField<OpenAccount>(x=>x.Password)
  
  %input {type="submit" value="Save"}
  %button {onclick="javascript:history.back()" type="button"} Cancel

OpenAccount is my view model. (I hate how we’ve overloaded these terms.)

I really like the succinctness of the nhaml, though I’m not ready to commit to it 100%. Spark is very attractive to me as well.

Html.FormField is an extension method I wrote. I’m toying with the idea of having it emit a <lablel /> paired with the <input />. Part of my motivation here is standardizing all of the label/inputs in my forms as well as a few experimental ideas about localization.

It’s rather naive at the moment, but here is the helper:

public static string FormField<T>(this HtmlHelper helper, Expression<Func<T, string>> property)
    where T : class, ICommand
{
    var model = helper.ViewData.Model as T;
    if (helper.ViewData.Model != null && model == null) throw new InvalidOperationException();

    var expression = (MemberExpression)property.Body;
    var name = expression.Member.Name;

    var value = (model == null)
                    ? null
                    : property.Compile().Invoke(model);

    return helper.TextBox(name, value);
}

Yeah, I hardcoded to a textbox for the moment. As I said, this is just a sandbox spike.

Finally, the associated controller action looks like this:

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Create(OpenAccount form)
{
    var result = _backend.Execute(form);

    return result.Success
               ? (ActionResult) RedirectToAction("WhateverIsNext")
               : View(result);
}

I’m treating the incoming form as a command. The _backend is responsible for processing the command. The command is just information necessary to execute the command, not the logic to execute it. The result I’m getting back is actually an instance of the same command with information attached by the backend (e.g., did the command execute correctly, what were the validation errors). It’s not exactly SRP, however I’m influenced by the simplicity of RoR here.

One more interesting bit. I really don’t like having actions in my controller that do nothing other than render the view. For example:

[AcceptVerbs(HttpVerbs.Get)]
public ActionResult Create()
{
    return View();
}

So instead, I created a base controller that does this:

public class ControllerBase : Controller
{
    protected override void HandleUnknownAction(string actionName)
    {
        try
        {
            View(actionName).ExecuteResult(ControllerContext);
        }
        catch (InvalidOperationException e)
        {
            //show the error or something
        }
    }
}

Are Value Converters Evil?

Christopher Bennage — Thu, 01 Oct 2009 05:17:00 GMT

Justin Angel (who is undoubtedly a Silverlight Rock Star) decided to stir things up a bit on Twitter the other night.

I was compelled to echo Ward Bell’s response that value converters can play legitimate role in the UI. Justin asked me to defend my position; a reasonable request. Now, I know that I am in the minority for maintaining this position. Many heavy hitters in the WPF community think MVVM does away with value converters. (I am not going to talk about the other bits here, just value converters.)

בְּרֵאשִׁית

One of the early WPF examples that got my attention was a listbox that was styled to look like a map of the United States. What impressed me in this sample was the separation of Behavior from Feel. I’m using the word “feel” with a very specific meaning. We often talk about Look and Feel. I think Look is shallow and Feel is deep. You can change the look of a listbox by changing the colors, the borders, the thickness of the lines, the icon that activates the dropdown, and so on. However, even by changing all of those, it stills feels like a listbox. Now, once you’ve made that “listbox” into a map of a country you’ve done something deeper. You’ve changed the Feel. Pretty significantly too, I’d say.

But even with the radical feeling map-listbox, one thing you haven’t changed is the Behavior. The semantics of a listbox are still in effect. Show a list of items and allow one to be selected.

But alas, those primeval glories of WPF were drowned out in the drones of “where’s my datagrid?”.

Seeking Abstractions

Rob Eisenberg and I were early adopters of WPF. At the same time, we were also in the feverish rush of applying Design Patterns to everything. You know, that phase of adoption where you’ve learned how to hammer and everything’s a nail. Still, it was good for us. We were digging through Fowler’s and Gossman’s and Crevier’s blogs. These sources began to shape my conceptions of ViewModel (or Presentation Model or Your Mama Model), however I was still deeply influenced by my lingering notion about the separation of Behavior and Feel.

The result of this is that my idea of a ViewModel is a representation of the Behavior of the View. However, the ViewModel is agnostic about the Feel. This means I don’t build “formatting” and such into my ViewModel. I try to keep my ViewModels as “pure” and abstract as possible. This also means that I rarely take strong dependencies on WPF and Silverlight.

Why go to such extremes? What’s the benefit?

My Fantasy World

There’s a lot of talk about UX lately, and perhaps more fittinhly, Interaction Design (IxD). In reality, I fiind that there are few people are actually doing IxD. Although, I think that’s the audience that Expression Blend is targeted at (do you recall what Blend was originally named?). These chimerical Interaction Designers are the ones that would benefit the most from this proposed separation of Behavior and Feel.

Let’s imagine a we’re building a WPF application. Harkening back to that old, impressive sample of yesteryear, the behavior we need in our app is to “allow the user to select a state”. As a developer, we can create a ViewModel that embodies that behavior, we can test the ViewModel, and even build a simple, naive View (testing that the required bindings are present with Caliburn thank you). Then we can hand it over to an interaction designer. The designer can then radically alter the Feel without changing the Behavior. In fact, if we’re using something like Caliburn’s testability framework (not available in Silverlight unfortunately), these IxD peeps can exercise a great deal of liberty in establishing the most appropriate feel for the behavior.

Unfortunately, our typical approach to software development inhibits IxD’ers from working this way. The Feel is often deeply entangled in the presentation logic (or worse).

Context

I’m sure that a large majority of WPF developers might see these distinction as useless. Especially, when building Line Of Business applications. That’s okay. Not everyone needs to do this. Many projects don’t need the additional complexity that might be introduced by thinking in this way. However, I think this is an emerging field and UX/IxD will be increasingly important. Soon it will be the distinguishing factor in commercial software.

Wait, Wasn’t This About Value Converters

Yes, and here is how they fit in. Let’s take my current favorite example of formatting dates. We have a behavior that requires communicating some date/time information to the user. Applying my philosophy to our ViewModel, the developer should expose the raw data (an actual DateTime property) on the ViewModel and leave the rest up to the IxD’er. After careful consideration, research and usability testing, the designer decides the dates need to be formatted as “[x time ago]”. (See the referenced post if that doesn’t make sense.) The designer, who can likely write a bit of code, creates a value converter to format the date value as the Feel demands.

Secondly, we could conceivably have multiple Views in an application for a single ViewModel. Each View would have a different Feel, and the application (or the user) could select the most appropriate (or comfortable one).

Incidentally, when I first learned about MVC it was in the context of writing a minesweeper game in Flash where the user could switch between an isometric and top-down view.

In the End

In real life, we’re not very close to this. There are few IxD’ers out there and most teams don’t need to be concerned about this. That means that for most practical purposes the Simplest Thing to Do might be to forego value converters and hard code formatting in the ViewModel. Value converters, just like anything else, can be abused.

Nevertheless, I definitely do not consider them a worse practice.

If you think I’m wrong, speak up. I am willing to listen. If you’ve been burned by the use of value converters, please share.

Saving Files from Silverlight (using Caliburn)

Christopher Bennage — Fri, 25 Sep 2009 19:30:00 GMT

We’ve been working on a Silverlight project that could be classified as a Line Of Business application (whatever that means).

There have been a few places where we need to allow users to save files. First, I thought I might give you a peek as to how we do this with Caliburn .

Imagine that we are displaying a table of data and that we are allowing the user to export that data to a csv file and save it to their desktop.

How We Do It

In the view, I have a button that looks like this:

<Button pf:Message.Attach="Export" 
        Content="Export Data">

pf is defined as

xmlns:pf="clr-namespace:Caliburn.PresentationFramework;assembly=Caliburn.PresentationFramework"

You can read more about Message.Attach in the Caliburn documentation.

The view is associated with a view model, and that view model has a method:

public IEnumerable<IResult> Export()
{
    var saveFileResult = new SaveFile { DefaultExt = "csv" };
    yield return saveFileResult;

    if (saveFileResult.FileStream == null) yield break; //null means the user clicked ‘Cancel’

    var content = FormatAsCsv();

    using (var writer = new StreamWriter(saveFileResult.FileStream))
    {
        writer.Write(content);
        Caliburn.Core.Invocation.Execute.OnUIThread(writer.Close);  
    }
}

The Message.Attach in the view binds the button to this method on our view model. IResult is a poor man’s coroutine and you can read more about it here.

It’s not that obvious when discussing the save file scenario, but this approach is really useful when dealing with asynchronous actions, such as interacting with a web service. Also by using the SaveFile abstraction, we could more easily test this method. (Though newing it up here sort of nullifies that, but I digress.)

But what is the SaveFile class anyway?

public class SaveFile : IResult
{
    public string Filter { get; set; }
    public string DefaultExt { get; set; }

    public string SafeFileName { get; private set; }
    public Stream FileStream { get; private set; }

    public void Execute(IRoutedMessageWithOutcome message, IInteractionNode handlingNode)
    {
        var dlg = new SaveFileDialog
        {
            Filter = Filter,
            DefaultExt = DefaultExt,
        };

        if (dlg.ShowDialog().GetValueOrDefault(false))
        {
            FileStream = dlg.OpenFile();
            SafeFileName = dlg.SafeFileName;
        }

        Completed(this, null);
    }

    public event Action<IResult,Exception> Completed = delegate { };
}

It a simple abstract for opening and managing the SaveFileDialog. If you want to know more, check out the Caliburn documentation and sample (or harass Rob Eisenberg to post more). Rob also had an introductory post on IResult.

Coming Soon

My rant about Silverlight’s inadequate SaveFileDialog.

Designer Wanted

Christopher Bennage — Tue, 22 Sep 2009 16:30:25 GMT

We need to contract a designer for our current project. I’m looking for one of those mythical beasts that has:

some real graphics design skill
understands (or at least cares about) usability
works with Silverlight

There is also a strong preference for someone in the NYC/NJ area.

If you are interested or know someone who qualifies, please contact me through the blog.

Source Control Presentation

Christopher Bennage — Tue, 01 Sep 2009 21:33:00 GMT

I want to thank everyone that came out to my session at the Jacksonville Code Camp. I had a great time and it was definitely worth the drive.

Here are my slides from the presentation. They are really only useful with the accompanying notes, with are available on the slideshare site. You have to select to “Notes on slide X” tab underneath the presentation to see them. (I wish there was an option to embed the notes, but I didn’t see it.)

I want to acknowledge Joe Kuemerle whose Get Rid of VSS presentation was helpful. Also, Eric Sink whose blog influenced a great deal of the content.

As always, any feedback is greatly appreciated.

My Solid State Sorrow

Christopher Bennage — Mon, 31 Aug 2009 11:44:00 GMT

I recently installed a Solid State Disk, an Intel X25-M to be precise, as my operating system disk. (It was time to upgrade to Windows 7!) Despite the fact that it would not really increase compiles times, I was very excited about the other anticipated performance improvements.

After the installation, I had Windows 7 and Visual Studio installed quickly; less than an hour I think. However, shortly after that, my machine froze. Then it froze again. <heart stop/>

It was definitely a problem with the new drive. A little bit of research turned up that my motherboard, MSI P6N SLI Platinum, uses a chipset with a known problem. Specifically, the nForce 650i and 680i.

By default, the SATA controllers on these boards have a featured enabled called command queuing. This is the feature that causes the problem with the ssd. However, I could not find anywhere to disable this feature.

There was speculation on some forums that upgrading to the latest firmware would fix everything. I did, and it didn’t.

Needless to say, I was getting a little bit concerned.

The Solution

I had not installed any vendor-specific drivers. Since this was vendor specific feature, I reasoned that that using the NVIDIA drivers might allow me to disable command queuing. It did, and now my system has four times as much awesome as previously.

Install the NVIDIA nForce drivers.
In Device Manager, under IDE ATA/ATAPI controllers, locate the NVIDA nForce Serial ATA Controller associated with your SSD and click Properties.
Switch to the tab for the port that the SSD is located on.
Uncheck Enable command queuing. You only need to do this for the SSD drive.
Rejoice!

On a side note, I built my machine based on The Coding Horror Ultimate Developer Rig. That’s right kids, it is pure rock and roll.

Build Notification, Visual Studio, & Snarl

Christopher Bennage — Thu, 27 Aug 2009 10:54:00 GMT

I’m not talking about build notifications from a build server. Rather, I’m talking about times when you are building locally. It’s a big project and it takes 30 seconds. So… you flip over to a web browser while you wait. Then you forget about it and waste another minute or two until you remember: oh yeah, I was building.

Ok, maybe I’m the only who does that.

Notifications

I recently (re)discovered Snarl. It’s a small app, inspired by Growl for OSX, and is a generic provider for system tray notifications.

I also found this plugin for Visual Studio that notifies you when a build is finished.

Funny enough, all the projects I am working on right now build quickly, so I don’t really need this. I just like it.

Quirk

On Vista, I would get duplicate notifications. No problems on Windows 7.

Lacking Confidence

Christopher Bennage — Tue, 25 Aug 2009 11:47:00 GMT

One of my biggest professional hindrances is a lack of confidence. I don’t have a CS degree. In fact, I have almost zero technical academic training. (My degree is in Religious Studies). In addition, I hang out with a lot of very smart and motivated programming gurus. I tend to judge myself by what they are capable of, and hence I often fail at my own standard. Add this to the fact that we men have fragile egos and it’s not hard to see how I arrive at this lack of confidence.

Last week Rob and I presented at the Orlando .NET User Group. Walking back to the car afterwards, I was chatting with Scott Densmore. He mentioned that he doesn’t blog as much as he would like because he’s not convinced that he has anything of value to say. At first this surprised me. If you know Scott, then you know that he has a lot of interesting things to say. In addition, he’s very good at saying them. However, after a moment’s reflection, I recognized that I think the same thing all the time.

What Others Think

Despite the fact that I don’t officially care what others think, I frequently base my actions on the anticipated responses of others. :-P

I am afraid of failing in front of my peers. This has become evident to me as I have worked on NHProfiler. Ayende is something of a Rock Star in the .NET world (though he may not believe it). I was timid to commit code. He might look it. It would suck and then he would know I was an idiot. I mean, I know that I do dumb things all the time but I didn’t want to let that out.

That is the wrong attitude. Instead, I need to open and transparent. What’s the worse that can happen? I write some bad code. We have to revert a commit and then I learn how to write better code. (Yeah, this did happen and I lived.)

Bias Towards Actions

Where am I going with all of this?

We often talk about the value of Failing Fast. We want to surface problems as quickly as possible, so that we are able to address them sooner. We apply this to development tasks, to project management, and even to the way we structure code.

Too often I have not acted, because I was afraid that I would seem stupid, irrelevant, or inadequate. My advice: don’t be afraid to act. Sure, you might fail but that’s okay. Actually, it’s more than okay. True failure is not in falling down, but in refusing to get back up. If you aren’t failing, then you probably aren’t accomplishing anything.

Answer the User’s Questions

Christopher Bennage — Sat, 22 Aug 2009 16:27:00 GMT

One little usability bit that I picked up from many of the Web 2.0 apps (in particular 37signals apps), is displaying date and times in a “how long since” format.

Take a look at the community page on Silver Arcade. I wanted to display when a user became a member of the community. Instead of displaying the actual date that they signed up, I choose to convert that date to “how long ago”.

At first I did this just because I liked it. Then it began to dawn on me that there are reasons that I like it.

Questions

One primary purpose of any UI is answering the user’s questions. “How much credit is left in this account?” “Is this customer currently active?” “How many days are left before this explodes?”

Frequently, when we are displaying dates and times we are really trying to answer questions that begin with “how long ago did …” or “how soon until …”.

When we display a simple date and time, such as “August 22, 2009 12:11 PM”, we are providing raw data to the user, but we really aren’t answering their question. We’re leaving the final step up to them. That’s translating that raw data into a meaningful answer for their ‘how long’ question. Every translation has a cognitive cost.

This may not seem like much, but the cognitive cost adds up very quickly. This can be one of those subtle points that makes two seemingly similar interfaces feel so different.

I’m not saying to display every date and time in your application in this format. Instead I am saying to ask “what question will my users have and am I really answering it”.

To be fair, this is purely anecdotal and is not backed up with any empirical evidence.

Speaking Schedule: August/September

Christopher Bennage — Tue, 18 Aug 2009 14:00:00 GMT

August 20th, Case Study: Silver Arcade

Orlando .NET User Group (ONETUG)

This will mostly be Rob, but I’m tagging along to offer witty banter. We’ll be discussing how we built Silver Arcade using ASP.NET MVC, Azure, NHibernate, jQuery, and more.

August 29th, Source Control with Subversion

Jacksonville Code Camp

This is a Getting Started session for those who don’t know much about source control.

September 5th

Tallahassee Code Camp

I’m not 100% certain what I’ll be doing here. However, we have an awesome lineup. If you are within driving distance, come spend your Labor Day weekend with us. It’s going to be a great event.

September 17th, Getting Started with NHibernate

Tampa Bay ASP.NET MVC SIG

I’m really excited about this one. We’ll be discussing how to get started with NHibernate specifically within the context of ASP.NET MVC applications.

If you attend any of these events, please stop and and introduce yourself. I really enjoy connecting with other developers. It’s half the fun of these events.

Refactoring Relationships

Christopher Bennage — Sun, 09 Aug 2009 01:45:00 GMT

Working with people is a lot like working with code. New relationships are green fields. Over time they become brown fields and (just like code) they require maintenance. I’m sure that everyone reading this can identify some legacy relationships that they would describer as, well, complicated. Just like some legacy code.

I mean a lot with the word ‘relationship’. I have in mind everything from co-workers to friends to significant others. These variations all require maintenance and I think we should deliberately structure our relationships so that maintenance is easier.

Interaction Smells

So what is the social equivalent of a switch\case statement?

We talk about code smells in software development as suggestive indicators that something is wrong. In our relationships, it is interaction smells. I would consider these common emotional responses to be smells:

avoidance
irritation
suspicion

Personally, I have been guilty of avoiding someone because I thought I would irritate them and I didn’t want the hassle. This was in a work environment and it a negative effect on the overall efficacy of the group. My impulse to avoid was a smell and it led to a problem that needed to be addressed.

Amicability Debt

Bad code gets worse over time. We call this technical debt. Relationships that have soured do not get better by themselves. Little fractures grow over time. If we don’t address them when we smell them, the stink only gets worse. In addition, the stinky relationship can be begin affecting other parts of design, uh I mean, other social interactions (e.g., the team you are working with).

Refactoring the Relationship

Relationships are more difficult to work with than code for one primary reason:

You cannot revert back to the last revision if your changes fail.

Nevertheless, we often need to make changes. Refactoring code doesn’t change the exposed functionality, but we make internal changes to improve it. If you are beginning to have problems with your boss, that doesn’t necessarily mean it’s time to quit (change the function) rather you might just need some relational refactoring.

But what do I mean by refactoring a relationship? Well, there’s a lot to be said there and you can find a lot of practical advice on dealing with conflict and more over on “Doc” List’s blog.

In brief though, I mean this:

Be honest and humble. “Hey, Joe, I feel like you’ve been a bit on edge with me. Did I do something to frustrate you? I’d like to clear the air.” Then talk it over. Again, refer to Doc’s blog for lots of details.

I would like to qualify this further. Since you cannot revert what you say and do, you must be deliberate and thoughtful about your refactoring.

Afterword

You can see where my brain has been lately. It’s the cross-pollination of ideas from software development into all other human interests. Next week: multithreading and Italian cooking, followed up by ALT.NET and comparative religion.

If any of this resonates with you, you might be interested in (a possibly controversial) post regarding the maintenance of marriage on my personal blog.

Agile Living

Christopher Bennage — Wed, 05 Aug 2009 03:14:00 GMT

I yearn to be consistent. I want my professional values to be the same as my personal ones. This is why I was quick to sign the Agile Manifesto; it aligned with my personal values.

I have been overcommitted for the last couple of months and the stress has forced me to do some professional reevaluation. I had a number of entrepreneurial and professional books on my back log. One of the book was The 4-Hour Workweek by Timothy Ferriss.

I really like this book.

That’s nice, Christopher. Thanks for sharing. What does this have to do with software development?

Not a lot. Perhaps. But I think it has a lot to do with the philosophy of Agile.

Eschew BDUF

One of the first ideas in the book is that the notion that retirement is a bit silly. We spend forty something odd years saving up money to retire and for what? How do we really know what to save up for? Do we honestly know what our requirements for old age will be? The standard cultural approach to professional life is Waterfall. We spend so much time building our product, and we have one big rollout.

Iterative Design

I recently watched the film Holiday with Cary Grant and Katharine Hepburn. In the movie, a young and savvy Johnny Case (Grant) struggles between Doing Business (because that’s sensible) and taking time off to figure out what he wants out of life. Ferris makes a similar proposition in the book. He suggests planning mini-retirements. It’s a release often, release early approach to life. Discover what you want you by trying things out. It’s Life in Sprints.

Illusion of Slackness

Agile has had a bad rep for being unstructured and lacking in discipline. Of course, practitioners of Agile know the exact opposite is the case (and let that be a life lesson in itself). One of the things I love about Agile is the focus on delivering value. Likewise, my initial perception of the book was that it was a guide for the lazy; just another Get Rich Quick scheme. No, it’s about being deliberate with your life. It’s not a book that most people can use, because it requires disciple.

Eliminate Waste

If I’m being technical, I guess I would say that this is a Lean principle. However, Lean and Agile are complimentary ingredients in the tossed salad that is my head. Ferris applies this principle to all of life. It’s a beautiful thing. There’s a lot of waste in our lives, hidden under the veil of busyness. Find it and eliminate it. Repeat.

Conclusion

Okay, so I guess this turned out to be a book review of a non-technical book. If any of this stirs your brain, then I recommend that you read the book. If you are compelled by the ideas of Agile or Continuous Improvement, read the book.

My Advice: be deliberate with your life, your professional, and your time.

“… the unexamined life is not worth living…”
Socrates, Plato’s Apology

“Whatever your hand finds to do, do it with all your might, for in the grave, where you are going, there is neither working nor planning nor knowledge nor wisdom.”

Kohelet 9:10

One day with Balsamiq Mockups: a review

Christopher Bennage — Fri, 19 Jun 2009 04:03:00 GMT

We’ve just started a new Silverlight project and since ~~our~~ the UI guy is not on site with us, I ended up with the task of producing screen mockups. Some interest was expressed in using Balsamiq Mockups, and this seemed like a good time to really take it for a test drive.

What does it do?

Balsamiq is a tool for quickly authoring mockups of applications and websites. My favorite tool for doing mockups is pencil and paper (turns out that it’s really, really good). However, we needed something that we could readily show during a review meeting and my sketches don’t photocopy well.

Nevertheless, I did my brainstorming on paper and I used it for my first round of reviews with the team. This left me with about a dozen pages storyboarding the core of our application.

After the first review, I began recreate it with Balsamiq.

In Balsamiq you start with a blank, gridded canvas and drag various UI elements from a library onto the canvas. It reminds me of Visio a bit, but without so much pain. All of the elements are styled to look like hand-drawn. This is important because it prevents anyone from assuming that the application is “done” when you’re just presenting mockups.

The elements in Balsamiq are impressively intelligent. Most elements allow you to type in some content and they react intuitively to that content. I was amazed a couple of time at how smartly they responded. Balsamiq ships with about 75 elements in its library and there are more being posted all the time. You cannot really extend the library yourself however, though you can incorporate your own images.

Each mockup screen is a single file. They are XML so it’s source control friendly. If you are mocking up an entire application (like I was) you can link the files together. Many of the elements have a link property that you can point to any other Balsamiq files in the same directory. Once you’ve linked up some files, you can “run” your mockups in presentation mode. This allows you to navigate around the application and toggle annotations (like the sticky note in my screen shot). The presentation mode is really cool.

Should you buy it?

I think that mocking up the UI is a very useful exercise. It helps to expose the behavior of the application that you are going to build and surfaces many insights into what it really needs to do. I still prefer to use paper and pencil for the initial pass. However, I found that following this up with Balsamiq forced me to think through the entire flow of my appplication. My paper storyboards had holes in them that I did not realize until I attempted to express them in Balsamiq.

The reviewers were really excited to see the Balsamiq mockups and being able to walk them through the application was a definite plus for them. The tool is easy to use. I would say that any ~~designer~~ developer doing UI work should be using a tool like Balsamiq.

What it offers for $79 is really hard to beat. Admittedly, I don’t know what other tools are out there and how they compare. By itself, I think it definitely worth it for anyone doing UI work.

Of course, there is SketchFlow. It is coming. I think that SketchFlow looks very promising, especially for us XAML guys, but it’s not available yet. I’ll let you know what I think about the overlap once I get a change to actually use SketchFlow.

Little Things

I had a couple of annoyances that are worth pointing out.

First, you cannot create reusable components. For example, I had certain elements of the application that appeared in several places. I had to clone these elements, but when I needed to change them, I had to make the change in each element. (Another reason to start with pencil).

I think that it would also be nice if there was a “back button” in presentation mode. Within my mockup I had a few screens that you could get too in multiple ways, however I did not have an easy way of returning the the previous screen.

I also get the impression that the community around Balsamiq likes to poke fun at us PC guys. I smile politely.

Finally, Balsamiq likes to keep all of the linked files open. You’ll notice an excessive number of tabs on the bottom of the screen shot. Those are all the screens within the application I was mocking. It became a little difficult to find that right one.

On the whole, Balsamiq is a smart application and I expect to see great things as it matures. Many of its features are intuitive and “just work”, and that’s how I like my software to roll.

:-P

The Influence of MVC on my WPF

Christopher Bennage — Wed, 06 May 2009 19:48:01 GMT

I was introduced to MVC as a pattern for Web development through Castle MonoRail. From there I studied a bit of Ruby on Rails (not enough) as well as the general philosophy of 37signals.

As I mentioned before, I thought I was moving away from Web development. However, the dive into ASP.NET MVC that Silver Arcade brought about has roped me back in.

My work during the day (and some nights too) is still WPF though. I’ve discovered that MVC thinking has seeped into my WPF development.

Convention Over Configuration

A characteristic of most MVC frameworks is Convention Over Configuration. In short, it means that your “environment” makes assumptions about what you want and that you only need to be explicit about the exceptions.

A practical example of this is the way that the View for an Action is inferred from the name of the Controller and Action. After creating your Action, you create a folder for the controller and and view that matches the name of the action. It just works. If you need to make exception, you can.

An Example in WPF

In our WPF development we employ a number of Separated Presentation patterns. One of the more common patterns we use is MVP (in particular, the flavor of MVP implemented in Caliburn, which is really Supervising Controller).

Imagine a simple contact manager application. We can add new contacts, view a list of all contacts, and open individual contacts for viewing or editing. We can open as many individual contacts as we like.

Let’s say that there are buttons to open up the “Add New” view and “All Contacts” view. We can open an existing contact by double-clicking on them in the “All Contacts” view.

My solution setup for this imaginary (and highly contrived) application might look like this.

ApplicationPresenter would be the root object of my UI. It would have an ObservableCollection of IPresenter that would be bound to a TabControl in Shell.xaml. Likewise, ApplicationPresenter will have a CurrentPresenter of IPresenter that will be bound to the SelectedItem on the TabControl.

Shell.xaml is my only window in this example. All of the other views are user controls. I named it “shell” because I think of it as the outermost level of the views. Shell’s data context is set to ApplicationPresenter.

I’m not going to dive too much deeper into this, because I want to get to my real point.

My presenters don’t know anything about their views. It’s up to data binding to render each presenter with the correct view. This means that I need to create data templates for each of the presenters. Not such a big deal in a small application, but it can get tedious as the application grows.

Hmmm… This structure is beginning to look a lot like an MVC app. Perhaps I can have it automatically infer my data templates for me?

Some Code

Yes we can. Here’s a very naiveté bit of code that will do just that. It makes some big assumptions:

all of your presenters implement IPresenter
all of your presenters are in a namespace containing “.Presenters”
all of your views are in an analogous namespace containing in “.Views”

Again, this is not production ready code, just my spike to prove the idea works. Please feel free to make suggestions.

public static class MvpConfiguration
{
    /// <summary>
    /// Creates a set of data templates pair to presenter classes based on naming conventions.
    /// </summary>
    /// <remarks>If a data template is already present in the resources, then it is skipped.</remarks>
    /// <param name="resources">The ResourceDictionary that the data templates for the views will be added to.</param>
    public static void InferViewsFromPresenters(ResourceDictionary resources)
    {
        var lookup = MatchPresentersToViews();

        foreach (var pair in lookup)
        {
            var template = CreateDataTemplate(pair.Value, pair.Key);
            if (resources.Contains(template.DataTemplateKey)) continue;
            resources.Add(template.DataTemplateKey, template);
        }
    }

    private static Dictionary<Type, Type> MatchPresentersToViews()
    {
        var presenters = from type in Assembly.GetExecutingAssembly().GetTypes()
                         where typeof (IPresenter).IsAssignableFrom(type)
                         select type;

        var first = presenters.FirstOrDefault();
        if (first == null) throw new Exception("I expected to find at least one presenters!");

        string viewNamespace = first.Namespace
            .Replace(".Presenters", ".Views");
        viewNamespace = viewNamespace.Substring(0, viewNamespace.IndexOf(".Views")+6);
        //yeah, that was hackish

        var views = from view in Assembly.GetExecutingAssembly().GetTypes()
                    where !string.IsNullOrEmpty(view.Namespace)
                          && view.Namespace.StartsWith(viewNamespace)
                    select view;

        var table = new Dictionary<Type, Type>();

        foreach (var view in views)
        {
            var presenter = GetPresenterForView(view, presenters);
            if(presenter == null) continue;

            table.Add(presenter,view);
        }

        return table;
    }

    private static Type GetPresenterForView(Type type, IEnumerable<Type> presenters)
    {
        string name = type.Name.Replace("View", "Presenter");
        var presenter =
            presenters.Where(p => p.Name == name).FirstOrDefault();
        return presenter;
    }

    private static DataTemplate CreateDataTemplate(Type viewType, Type dataType)
    {
        var template = new DataTemplate(dataType);

        var factory = new FrameworkElementFactory(viewType);
        template.VisualTree = factory;
        return template;
    }
}

To use this, in your App.xaml.cs within OnStartup() add:

MvpConfiguration.InferViewsFromPresenters(Resources);

What do you think? Am I totally nuts?

Oh, and I should also point out that FrameworkElementFactory is actually deprecated. :-( Caveat emptor.