Blog

Joining Telerik

Thu, 26 Apr 2012 14:16:53 GMT

Earlier this year, I wrapped up my work with The Code Project and Lake Quincy Media and returned to NimblePros, the consulting company Michelle and I started a few years ago and which she’s run quite successfully the last few years. NimblePros has been doing some great things the last couple of years, with revenues in 2011 doubling those of 2010. At the same time, we’ve been watching Telerik continue to grow by leaps and bounds, entering new markets and attracting a ton of great people to join their team. We’ve had a great relationship with Telerik for almost ten years, as individuals and through several different businesses, and have always found them to be exceptionally good to work with. That’s why when they approached us about joining the NimblePros team with Telerik’s, we were very enthusiastic about the opportunity. Today, I’m excited to announce that the entire NimblePros organization is now a part of the Telerik team, and will be providing a variety of services to Telerik clients and partners.

Michelle and I will continue to run our team from our office in Hudson, Ohio. This location is now Telerik’s 5^th US office, and the first Ohio office. You can read more details in the official press release and on NimblePros’ home page, and of course you can learn more about Telerik’s Service Offerings on our web site.

Principles of Product Development Flow Book Review

Wed, 25 Apr 2012 13:49:33 GMT

One of the more advanced books I’ve read relating to the subjects of Software Development and Lean is The Principles of Product Development Flow: Second Generation Lean Product Development by Donald G. Reinertsen. I recently published a Pluralsight course on Kanban Fundamentals, and as part of my research for that introductory-level course I read a few related titles, including this one. I previously reviewed some of the others:

If you were looking into learning more about kanban and lean as it relates to software development projects, I would probably suggest you read them in the order I have listed above, with Principles of Product Development Flow following these. It is certainly the most advanced of the books. It also has the most to offer to any product-oriented business, and does a good job of debunking certain myths about lean as it relates to software development. Unsurprisingly, writing custom software without a script is not entirely analogous to manufacturing known goods using known techniques as quickly as possible. Reinertsen does a good job of demonstrating where and how lean manufacturing principles do not directly apply to software product development, and provides models and principles that can be applied with confidence.

Principles of Product Development Flow is organized into nine sections. The first one, The Principles of Flow, sets up the rest of the book by describing the problems with the current accepted best-practices of product development. It is in this section that the author first mentions that the book is organized into 175 principles. When I first read that, I thought it was a typo, but it is in fact correct. The book’s organization into small, cohesive principles is actually a great feature, as they are easily able to reference one another and they are easy to refer to yourself as needed. In some ways, the author’s organization of the book is akin to well-designed software, with small, focused modules organized into larger, cohesive modules.

If you’re debating whether to buy this book, this section is the one to read, as it will “sell” you on the book’s promise (not in a bad way – it does a good job of demonstrating the need for the book to exist). Just a few of the important points described are a general failure to apply basic economics to decisions relating to product development, a systemic blindness to queues in software and knowledge work development, a worship of efficiency, and a blind hostility toward all sources of variability. These, and eight other, problems are described in the first section, with the remainder of the book dedicated to solutions to these problems.

The second section focuses on the economics of how we control projects. One of the recurring themes in the book is the U-Curve, first introduced in this chapter with principle E6: The U-Curve Principle: Important trade-offs are likely to have U-curve optimizations. That is, when making a decision, it’s unlikely that only a single variable is involved – usually there are at least two worth considering. For example, when considering the optimal batch size for a given process, one should consider, at a minimum, the Holding Cost, which increases as batch sizes (and presumably time) increase, and Transaction Cost, which increases as batch sizes shrink. A typical curve is shown here.

Reinertsen suggests that when considering the optimal batch size, one should consider the U-Shaped Total Cost, as opposed to blindly believing that small batches are always better or striving for One Piece Flow (a nirvana of some lean approaches). Note too that these curves are merely examples, and that in order to apply this principle you must first understand the nature of the holding and transaction costs that apply to your process. You can also then work on changing the shape of these curves in order to lower your total cost, perhaps reducing transaction costs through automation.

The next eight sections of the book cover these major themes:

Economics
Queues
Variability
Batch Size
WIP Constraints
Cadence, Synchronization, and Flow Control
Fast Feedback
Decentralized Control

Again, there are 175 principles covered. A few highlights I noted include:

Principle Q14: Don’t control cycle time, control queue size. Cycle time is a trailing indicator; queue size is a leading indicator. Thus, measure and manage queue size.

Queue size multiplies the cost of delays. When we have 20 jobs in a queue, a 5 minute delay generates 100 minutes of delay time. When there are only two jobs in line, a 5 minute delay generates 10 minutes of delay time. You can apply this same logic to overloaded web servers, for which queued HTTP requests immediately result in massive performance degradation.

On variability: We cannot add value without adding variability, but we can add variability without adding value.

A key point in the variability chapter and the book as a whole is that small batch sizes and low variability are not universally desirable. Rather, there are economic payoff functions for each and cases where reducing batch size or variability can actually be the wrong decision, economically (which of course should be our basis for decision-making). When we do wish to reduce variability, one way to do so is by using principle V5, Variability Pooling: Overall variation decreases when uncorrelated random tasks are combined.

On WIP constraints, there are several principles that can be used to attack queues as they emerge. W9 suggests that when a queue begins to emerge, adding even inefficient resources to it can have a dramatic effect on throughput. W10 notes that part-time resources that are up-to-speed on the task at hand have great “surge” potential when needed. W11 suggests that the “Big Guns” – the best talent in the organization – be kept available to combat emerging bottlenecks rather than being over-utilized, as is typically the case in most organizations. Finally, W12 introduces the notion of “T-Shaped Resources” – team members who have a wide breadth of skill but are masters of one area, or “jack of all trades, master of ONE.” These offer great flexibility, as they can shift to other assignments as needed to combat queues.

There’s a wealth of additional information on the effects of congestion on highways and how this applies to product teams as well as comparisons of synchronized and unsynchronized batches and adjacent operations. Reinertsen uses telecommunication and Internet routing protocols as models for how to efficiently route and prioritize work packets from a source to a destination, and then shifts gears to explain how the US Marines Corps deftly combines centralization and decentralization to successfully manage warfighting in the face of extreme uncertainty. I found the many principles to be well-founded, interesting, and applicable to software development in general and product development in particular.

Have you read the book? What did you think of it? Let us know.

New is Glue

Fri, 13 Apr 2012 13:56:32 GMT

When you’re working in a strongly typed language like C# or Visual Basic, instantiating an object is done with the new keyword. It’s important that we recognize the significance of using this keyword in our code, because I would venture to say that well over 90% of developers don’t give it a second thought. Most developers have, at one time or another, heard the practice of building software applications likened to building something out of LEGO bricks (I’ve even written about LEGOs and software in the past). A few days ago, it occurred to me that I could sum up my thoughts on this topic in three words, which I might hope would be memorable enough to “stick” in developers’ minds:

New is Glue

Any time you use the new keyword, you are gluing your code to a particular implementation. You are permanently (short of editing, recompiling, and redeploying) hard-coding your application to work with a particular class’s implementation.

That’s huge.

That’s like your code’s getting married, forever and ever, until redeployment do us part. Once you’ve said the words (new) and exchanged some vows (type metadata) and exited the church (deployed), changing your code’s chosen partner becomes a very expensive endeavor. This is a big decision for you and your application. You need to be very sure that this is the one and only implementation your code will ever need to work with, or else think about calling the whole thing off.

The marriage metaphor is taking things a bit far, I know, but let me add one more bit before we leave it behind us. It’s quite likely that your code is going to need behavior from more than one other class. In fact, it’s quite common that you’ll need to work with other classes in virtually every class within your application. If you go the new route, that’s a lot of overlapping marriages that all need to stay happy for your application to work effectively.

But what if the behavior or service you need is only found in one place? Maybe it’s not the perfect, now-and-forever class, but it’s the one that has what you need right now? What am I suggesting, that one forego leveraging any other classes, and just do everything yourself? Not at all, but let’s go with another metaphor now.

Favor Contractors over Employees

Your application requires certain services to do its job. Think of your application like a small business. There are things your application does, and things it needs to do its job. A small business might need office space, and beyond that, certain utilities like electricity, phone service, internet service, shipping, etc. In a business, relationships you have with service providers and contractors are relatively easy to change, while relationships you have with employees can be somewhat more difficult (for purposes of this analogy, pretend we’re talking about a country where firing people is very difficult/expensive). Now think about which approach to running a small business makes more sense.

In the first scenario, your business’s needs are each met by a full-time resource. You have Bob, the electrician, who ensures your electricity works, Joan, the telecom expert, who ensures your phone service is connected, and Joe, the truck driver, who takes care of delivering everything you ever need to send. You also need an office to hold all of these people, which of course you leased with a 5 year lease that’s every expensive to get out of.

In the second scenario, your business’s needs are all met by service providers or contractors. You use standard utility companies for electricity, phone, internet, and you can switch from one to another with only a small amount of pain if one fails you. You ship with FedEx, USPS, UPS, etc. based on whichever one fits your needs of the day. Your office space is just big enough for you, and since you’re still growing and aren’t sure how your needs will change, you’re paying month-to-month.

Which of these two scenarios provides the greater degree of freedom for the business to adapt to future needs? Which one is locked into a particular implementation and will be hard-pressed to change when needed?

Decoupling Services from Providers

New is Glue. It binds your code to a particular collaborator. If there is any chance you’ll need to be flexible about which implementation your code will need, it’s worth introducing an interface to keep your code loosely coupled. It doesn’t matter what the service is you need – you can always replace it with an interface even if your class is the only one that uses it. Let’s say your code needs send an email, with default code that looks like this:

using (var client = new SmtpClient())

using (var message = new MailMessage(fromEmail, toEmail))

    message.Subject = subject;

    message.Body = bodyHtml;

    message.IsBodyHtml = true;

    client.Send(message);

Note the two new keywords here, gluing whatever else this class is doing to this implementation of message sending. This can be replaced with an interface like this one:

public interface IEmailClient

    void SendHtmlEmail(string fromEmail, string toEmail, string subject, string bodyHtml);

Now the code that used to contain the first block of code can be rewritten to simply use the interface:

public class SomeService

    private readonly IEmailClient _emailClient;

    public SomeService(IEmailClient emailClient)

        _emailClient = emailClient;

    public void DoStuff(User user)

        string subject = "Test Subject";

        string bodyHtml = GetBody(user);

        _emailClient.SendHtmlEmail("noreply@whatever.com",

user.EmailAddress, subject, bodyHtml);

Edited: Please assume that DoStuff() does some useful value-added work, and that sending an email to the user is just something it does as a side effect, perhaps only when it’s successful, and not that it’s the main intent of the method, if that helps you think about the value of removing the dependency on SmtpClient.

How many new keywords are in this class, now? Run a search in Visual Studio to find how many instances of new you’re using in your solution, and where. Use ctrl-shift-F to find in files, search for “new”, Entire Solution, Match case, Match whole word, and Look at these file types: *.cs.

Have a look at the total numbers, the numbers of files, etc. In one very small ASP.NET MVC application I’m working on now, this search yields 280 matching lines in 25 files out of 47 files searched. Four of the files and 28 of the matches are in my tests project. The lion’s share of the rest of the matches are from SqlHelper.cs. My controllers have a total of 7 matching lines, and all of these relate to creating model/viewmodel types, not services.

When is it Acceptable to use New?

Using new isn’t wrong, it’s a design decision. Like all design decisions, it should be an informed decision, not a de facto one. Use it when you don’t expect you’ll need flexibility in the future. Use it when it won’t adversely affect the usability of your class by its clients. Consider the transitivity of the dependencies you take on within your class – that is, how the things you depend on in turn become dependencies for classes that use your classes. Consider too how your design decisions and considerations today may change in the future. One common example of this is applications that hard-code dependencies on local system resources like the file system, local memory (session, cache, global collections), and local services like email. When the application needs to scale out to multiple front-end machines, problems ensue. Loosely coupling these resources together would make implementing a webfarm- or cloud-optimized version of these services trivial, but thousands of new statements gluing implementations together can take a long time to fix.

One last thing to think about, if you actually do search your code for new, is how many duplicate lines you find. Remember the Don’t Repeat Yourself (DRY) and Single Responsibility (SRP) principles. If you’re instantiating the same class in the same way in more than one place in your code (e.g. 10 places where you new up a new SqlConnection), that’s a DRY violation. If you have ten different classes that all do some kind of work, AND need to know how to create a SqlConnection, that’s an SRP violation. Knowledge of how to talk to the database should be in only one location, the responsibility of a single class. The same is true for any other resource that you find you’re commonly instantiating in many different classes. The exceptions here would be low-level intrinsics like strings, datetimes, and things like exceptions that generally are created only in exceptional cases.

Moving Forward

Learn to look for new in your code and in code reviews. Question whether it’s appropriate when you see it. Work on pushing the responsibility of choosing which classes your code will work with into as few classes as possible, and see if your code doesn’t start to become more loosely coupled and easier to maintain as a result.

Modifying and Disabling Hyperlinks using jQuery

Fri, 13 Apr 2012 13:41:37 GMT

I have a simple menu in an ASP.NET MVC application allows a user to take one of several actions after first selecting a resource to work with from a drop down list / select box or textbox. In the case where the user hasn’t yet selected anything (or entered any text), I want the links to be disabled, as I’d rather let the user know the issue on the current dashboard page than have them go to a page without a required parameter and then hit them with an error message about the missing parameter. Instead, I’d like to, in the case of the empty textbox, give the textbox focus and flash some color there so the user (usually me) knows they need to enter something there before proceeding.

You can’t just .disable() a hyperlink or anchor tag using jQuery, nor can you .enable() it. There’s also a bit of magic involved in being able to take the contents of a textbox or select list and stick them into the URL in a link, which I’ll also show here. For my menu, it’s organized inside of an unordered list (<ul>) with individual list items (<li>) and anchors (<a>). It’s pretty straightforward to select and work on each such link using a jQuery selector.

Here’s the HTML for one of the two menus I’m working with, the one that requires a textbox. The other one is set up identically except it has a drop down list.

<h2>Email Admin Menu</h2>

<fieldset>

    <label>Email Address:</label>

    <input type="text" id="email"/>

</fieldset>

<div class="menu">

    <ul class="navlist" id="email-menu">

    <li>@Html.ActionLink("Unsubscribe Email from All Lists", "UnsubAll", "EmailAdmin")</li>

    <li>@Html.ActionLink("Change Email for All Lists", "ChangeEmail", "EmailAdmin")</li>

    </ul>

</div>

Getting the Value from the Textbox or DropDownList

The first thing I need in either menu is the value the user has provided in the <input type=text> or <select> form field. Here are the two ways to do this – jQuery 101 stuff:

// get selected text from <select> list

var selectedList = $('#SelectedListName :selected').text();

// get text from an <input type='text'> field

var selectedEmail = $('#email').val();

Appending a Value to a Link in an Anchor

Next, I’ve set up my routes in ASP.NET MVC so that the last bit of each URL is the resource being worked with – in this case an email address the user enters into a textbox. Whenever the user enters something, I want the value to be automatically tacked onto the end of all of the different links within the corresponding menu. However, I can just append the value to whatever the link is currently, because then the link would continue to grow and grow and grow if the user changed their mind and typed or selected a few different things before clicking a link. Thus, I need to only replace the last section of the link, after a certain number of ‘/’ characters. Here’s the code to update all of the links within a menu, using the .each() function:

$('ul#list-menu > li > a').each(function () {

    var href = $(this).attr('href');

    var parts = href.split('/');

    var baseUrl = parts.slice(0, 3).join('/');

    $(this).attr('href', baseUrl + '/' + selectedList);

});

Enabling and Disabling Links using jQuery

The last step is to make sure that the links don’t work until the user has entered a value into the textbox (for the dropdownlist, it will always have some valid resource selected, so I don’t need to do this). The way you disable clicking on an anchor tag from navigating to the corresponding href URL is by binding the click() event and calling e.preventDefault(). This will prevent the default behavior of the click, namely the navigation to the URL. In my case, I’m doing this whenever the textbox has zero length – I could do more advanced validation but this is sufficient for this example – and when this occurs I’m also highlighting the textbox in red and giving it focus.

Once you’ve added a .click() event handler, you can’t simply add another one to undo the effect, as this will cause both to happen. So, you could wire up the .click() handler to call a named function, and do your validation checking in that function, or you can unbind the .click() handler when it’s not needed, which is the approach I’m showing here. The full function for adjusting the links in the email-based menu is shown below, which includes the code required to modify the URLs similarly to what was shown above.

function updateEmailLinks() {

    var selectedEmail = $('#email').val();

    $('ul#email-menu > li > a').each(function () {

        var href = $(this).attr('href');

        var parts = href.split('/');

        var baseUrl = parts.slice(0, 3).join('/');

        $(this).attr('href', baseUrl + '/' + selectedEmail);

        if (selectedEmail.length == 0) {

            // disable links

            $(this).click(function (e) {

                e.preventDefault();

                $('#email').effect("highlight", { color: 'red' }, 2000);

                $('#email').focus();

});

        } else {

            // re-enable

            $(this).unbind('click');

});

Wiring Things Up

Once you have these things set up, all that remains is to wire them up when the page loads. In this case, we want the updating of the links to occur any time the corresponding UI element changes. I’m also setting up the textbox to autocomplete based on emails in the system already. In addition to firing when the UI element changes, I need the functions to each run one time when the page loads, so that the URLs are set accordingly and the links are disabled if the textbox is empty. Here’s the on-page-load function:

$(function () {

    $('#SelectedListName').change(function () {

        updateListLinks();

});

    updateListLinks();

    $("#email").autocomplete({

        source: "/Admin/Emails",

        minLength: 2,

        change: function (event, ui) {

            updateEmailLinks();

});

    updateEmailLinks();

});

Summary

I’m far from being a jQuery expert, but I was able to get all of this working very quickly with some help from jQueryUI.com and StackOverflow.com, which has a ton of jQuery questions and answers. I’m not currently using an MVVM style of client-side programming, although I expect to learn to do so in the very near future using frameworks like Knockout and KendoUI, which for this code wouldn’t make a huge difference, but might clean it up some by letting me bind things to a model, rather than to the selected element of some UI element. This would clean up the menu link URL logic significantly, as I could just bind the links to a model with a property for the URL that was dynamically created, for instance. This is left as an exercise for the reader, or perhaps a follow-up article in the future.

Beyond Role Based Authorization in ASPNET MVC

Wed, 11 Apr 2012 21:06:38 GMT

A fairly frequent requirement in applications is to check for authorization to perform an action. At the most basic level, this might just involve seeing if the user is authenticated (at all) or checking a flag to see if they are an Admin. However, more complex requirements frequently include a variety of roles, and it’s quite common for the notion of ownership to be involved as well, with some actions being allowed if you own the item being worked on, and otherwise not. I’ve written about using the notion of Privileges over Role Checks for this exact purpose in the past, as a way to ensure the logic of such decisions is properly encapsulated so that you can follow the Don’t Repeat Yourself principle. In that article, I describe how you can test privileges, but I don’t get into how to use them at the UI level, specifically in an ASP.NET MVC application.

ASP.NET MVC Authorization

You can do basic authorization in ASP.NET MVC by using attributes. Specifically, the Authorize attribute will let you mark a controller or action as requiring authorization, and you can optionally specify certain roles and/or users who are authorized to perform this action. However, this is as far as the attribute will take you, so by itself it won’t handle the case of letting users perform certain actions on things they own, but not on others’ things.

It’s also worth noting that you can apply filters like Authorize to an entire site by using GlobalFilters (in MVC 3+). For instance, in your global.asax you can add a call to RegisterGlobalFilters(GlobalFilters.Filters) in your Application_Start() and then implement this method like so:

public static void RegisterGlobalFilters(GlobalFilterCollection filters)

    filters.Add(new HandleErrorAttribute());

    filters.Add(new AuthorizeAttribute());

Then if you have only a few actions that don’t require, for instance, authorization (e.g. home page, login page), you can mark these with the AllowAnonymous attribute (in MVC 4+):

[System.Web.Mvc.AllowAnonymous]

public ActionResult Login()

    return View();

Authorizing Owners

In my case, I’m globally authorizing the users as shown, but then within each action I need to verify that the user is either an administrator or they are the owner of the resource they are managing. Originally, each action had some code in it that looked like this:

var person = _personRepository.Get(_currentUser.UserId);

if (!_authorizationService.CanAdministerResource(resourceId, person))

    return View("NotAuthorized");

The problem, of course, is that this is boilerplate code that would need to be added to every action. Not very DRY. At first I thought I might just extract this into its own method, but since it involves a return statement, that doesn’t work well and the best I could do is write a boolean method and keep the if statements in every action method.

After a bit of research, I found out that OnActionExecuting is the best way to ensure every action within a controller runs a particular bit of code, and further, how to return a particular view from this method. With this, I was able to override OnActionExecuting in my controller in question (every action of which will include the resource being worked with) like so:

/// <summary>

/// Verify the current user has permission to manage the resource

/// </summary>

/// <param name="filterContext"></param>

protected override void OnActionExecuting(ActionExecutingContext filterContext)

    string resourceId = filterContext.ActionParameters["resourceId"] as string;

    var person = _personRepository.Get(_currentUser.UserId);

    if (!_authorizationService.CanAdministerResource(resourceId, person))

        filterContext.Result = View("NotAuthorized");

    base.OnActionExecuting(filterContext);

What do you think of this approach? In my case, I only have one controller that needs to do this, but if I had several I could always create a common base controller and push up this code into the base class. I’m sure I could also go the custom action filter route but that seemed like overkill for what I’m looking at doing (and you can’t actually change the behavior of the action from within the filter itself, so there would need to be more moving parts). Any suggestions on how to do this better, or does this seem like a good approach?

The _currentUser class used here is one I picked up somewhere online (not sure where at this point or I would add a link) that makes it easy to avoid a dependency on HttpContext. It looks like this:

public class CurrentUser

        public CurrentUser(IIdentity identity)

try

                IsAuthenticated = identity.IsAuthenticated;

                UserId = Guid.Parse(identity.Name);

            catch (Exception ex)

                Debug.Print(ex.ToString());

        public bool IsAuthenticated { get; private set; }

        public Guid UserId { get; private set; }

I inject it into the class using my IOC container, in this case StructureMap. I don’t need to tell StructureMap anything about CurrentUser itself, provided it knows what to do with the constructor parameters. Thus, I include one line to tell it how to get an IIdentity:

x.For<IIdentity>().Use(() => HttpContext.Current.User.Identity);

Of course, in my tests I can simply pass in a new CurrentUser() and pass in a mock IIdentity if I care about its settings within the context of a given test. These last bits are separate from the main topic of the post, but I’m including them so the code shown is clear and not missing key ingredients, which I know can be frustrating.

Configuring Web Apps To Behave Like Native Apps on iOS

Wed, 28 Mar 2012 19:51:23 GMT

There are a number of things you can do with your web-based application to have it behave like a native iOS application. One of these I mentioned previously, which is to disable the user’s ability to zoom in and out using pinch gestures. In addition, you can hide the Safari user interface “chrome” so that the user is unaware they’re in a browser. You can also add splash screens and customize the icon that is shown when users add the web application to their device’s home screen.

Hide Safari Browser UI

This is referred to as “standalone mode” for your web application, and is accomplished with this meta tag:

<meta name="apple-mobile-web-app-capable" content="yes" />

There will still be a status bar at the top of the application. You can further customize the appearance by setting the status bar to be black, allowing your app to utilize the entire screen.

<meta name="apple-mobile-web-app-status-bar-style" content="black" />

Customize iPad or iPhone Icons for Web Apps

Users can easily add links to web pages to their iOS device’s home screen. As a web developer, you’d like to be able to control the appearance of the icon that is used to represent your web site or application on the user’s device. You can do this with a few more meta tags. Incidentally, Apple calls these “Web Clips” though I can’t fathom why. So, if you’re searching for more information on customizing how your web app’s icon appears on a user’s home screen, search for web clips.

At its simplest, all you need to do is specify an icon. This can be done using this meta tag:

<link rel="apple-touch-icon" href="/custom_icon.png"/>

If you don’t want the icon to be messed with at all by iOS, then you need to add –precomposed to it:

<link rel="apple-touch-icon-precomposed" href="/custom_icon.png"/>

By default, icons should be 57x57 pixels in size. However, some devices use different resolutions for their icons. You can (and should) create icons for each of the supported sizes and specify them using the sizes attribute, like so:

<link rel="apple-touch-icon" sizes="72x72" href="touch-icon-ipad.png" />

<link rel="apple-touch-icon" sizes="114x114" href="touch-icon-iphone4.png" />

You can also simply add these icons to your web site’s root URL, and if they use a well-known name they will be discovered and used. The most basic filename is simply apple-touch-icon.png, but you can include size information and whether it is precomposed as well (e.g. apple-touch-icon-57x57-precomposed.png). Naturally, you’ll be (slightly) better off from a performance perspective if you tell iOS which icon to use via a <link> than by having it try multiple different convention-based image URLs.

Adding a Splash Screen

Many native apps on mobile devices like iOS display a splash screen as the application is launching. Web pages and applications, typically, do no such thing. Thus, one more way you can make your web apps behave more like native apps on iOS is to add a splash screen to them. apple calls these Startup Images, and the process is largely the same as for customizing icons – you simply need to add the appropriate tags via <link> elements. As with icons, there are options available to specify different splash screen images for different device sizes. The most basic option is to simply set a single image:

<link rel="apple-touch-startup-image" href="/startup.png">

For iPhone and iPod touch, the image needs to be 320x460 pixels. However, if you want to use a higher-resolution image for iPads(1 and 2 in this case), etc. you can achieve this like so:

<link rel="apple-touch-startup-image" href="/startup-748x1024.jpg"   media="screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation:landscape)" /><link rel="apple-touch-startup-image" href="/startup-768x1004.jpg"   media="screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation:portrait)" />

Summary

Especially as Single Page Applications take off in popularity, the ability to run such applications on iOS devices as if they were actually native apps will be an important feature. Here I’ve shown a few settings that can easily be applied to any such application, or to any web page, to make the user experience of working with the web page nearly indistinguishable from using a native iOS application. You can learn more about customizing web content for iOS in the iOS Developer Library.

How Do I Disable Zoom in an iPad iPhone Mobile Web App?

Wed, 28 Mar 2012 19:16:25 GMT

If you’re building web-based applications for mobile devices like the iPad/iPhone and you want to mimic native applications’ look and feel and experience, one thing you may want to do is disable the pinch zoom gesture. Most native applications don’t offer support for this, but of course most mobile browsers currently do, so a sure way for users to tell that they’re actually viewing a web page is to let them resize the page easily using these gestures. To disable the pinch zoom, you can simply specify an identical starting and maximum scale. This is achieved by adding a viewport meta tag to the page or site in question, like so:

<meta name="viewport"

   content="width=device-width, initial-scale=1.0, maximum-scale=1.0" />

By adding this viewport tag, you’re forcing the browser to maintain a 100% scale for the page. You can also use the ViewPort meta tag to help optimize how your page or site renders in mobile devices, without limiting users’ ability to zoom in and out. Simply remove the maximum-scale setting in the above meta tag.

With this setting in place, you’re one step closer to creating a web application that behaves like a native iOS app. You can learn more about ViewPort settings specific to the Safari browser on iOS from the iOS Developer Library article on Configuring the Viewport.

Asus Zen Ultrabook Revisited

Tue, 27 Mar 2012 18:51:23 GMT

A couple of months ago I got an Asus Zen ultrabook, which I posted about when I first got it, and a month or so later. Now that I’ve had it a while, I thought I’d post one more time with how it’s continued to work for me. I’m still very happy with its look, feel, and speed. It’s very responsive both while up and running and when waking up or shutting down. One thing I wish it came with is an HDMI adapter, but I picked up an HDMI adapter for $2 from Amazon and it works fine. The machine does come with a VGA adapter, which is more likely to be what you’ll need when projecting, but our conference room has both and the HDMI is a bit sharper so I’m happy to be able to use it now.

In the last month, this machine has traveled with me to Vancouver, Seattle, and Orlando as well as various clients and businesses in Ohio. It’s super-light, the battery lasts and lasts, and it’s small enough to use on an airplane without being either a contortionist or sitting in first class/exit row. I also installed Windows 8 consumer preview on it a few weeks ago when that came out, and it works great as well. I followed Scott Hanselman’s boot to VHD instructions. In Win8, the touchpad is a bit more “touchy” (if your hand rests on it as you type it can move the mouse pointer or click it), but other than that (and the fact that it isn’t a touch screen device) it seems to work fine. The performance and stability of Win 8 seem to be very good, too, so much so that I know several people who run it as their primary work OS.

One of the nice things about having such a portable, powerful laptop is that I find myself using it more often. Of course, it’s now competing with an iPad, at least at home, so for many tasks that are mainly consumption-oriented, the iPad wins. But for actually creating anything, whether it’s a blog post or working on code in Visual Studio, the Zen works great. And of course it’s also a great movie and consumption machine in its own right (and when someone else in my household has dibs on the iPad). And at work, where I don’t currently bring the iPad, its small size makes it ideal to take to meetings or even just to have on the edge of one’s desk as a secondary machine to use for email/twitter/browsing while doing dev work on a full-sized pair programming workstation.

Some pundits are claiming that the ultrabook as a brand is already dead, because the name and brand are being diluted by forthcoming larger laptops that are thicker and feature spinning-rust hard drives rather than SSDs. I agree this kind of brand extension is a bad thing for the ultrabook brand name, but I’m definitely a fan of ultrabooks in the original sense, and I continue to be very pleased with mine. The one feature of this particular machine that continues to be a minor annoyance to me is the keyboard, which tends to result in missed keys more frequently than other laptops I’ve used and far more than full-sized keyboards. But I’m a fairly proficient touch-typist and it may just be that my style doesn’t jive well with this particular layout or type of keyboard. If you’re concerned it may be an issue for you, see if you can try one out before you buy one, but for me it remains a fairly minor, but notable, concern.

Obligatory Legalese

Disclosure of Material Connection: I received one or more of the products or services mentioned above for free in the hope that I would mention it on my blog. Regardless, I only recommend products or services I use personally and believe my readers will enjoy. I am disclosing this in accordance with the Federal Trade Commission’s 16 CFR, Part 255: “Guides Concerning the Use of Endorsements and Testimonials in Advertising.”

How to use System.Web in a Console Application

Fri, 23 Mar 2012 15:38:42 GMT

I’ve been bitten by this and have seen others run into it enough times that I thought I’d blog about it. Let’s say you’re creating a new Console, WPF, or Windows Forms application in .NET 4. You’re using Visual Studio 2010, and everything is going great until you get to the part where you wanted to make an HTTP request. You know you can do this, you’ve done it before, heck, you might even be copying code straight out of MSDN that does what you need. But it doesn’t compile. If you try and add a reference to System.Web, you’ll find it’s not there:

If you look closely, though, you’ll see at the top of the dialog it says “Filtered to: .NET Framework 4 Client Profile”. That’s the issue. Now, if you really are doing HTTP requests in a console application in .NET 4, then I recommend you use the System.Net.HttpWebRequest type that *is* available in the Client profile. But for argument’s sake, if you really do need something in one of the filtered out assemblies, like System.Web, then you simply need to change your project type to use the full .NET 4 Framework. You can do that by going into project properties and changing the Target framework from .NET Framework 4 Client Profile to simply .NET Framework 4.

Having done that, you’ll then be able to reference System.Web again in your project. Hope that helps!

Kanban Book Review

Wed, 21 Mar 2012 17:05:31 GMT

While researching material for my Kanban Fundamentals video training course on Pluralsight, I read Kanban: Successful Evolutionary Change for Your Technology Business, by David J. Anderson. I’ve previously reviewed a couple of other related books, including Personal Kanban and Scrumban, if you’re interested in learning more about this topic. I would recommend Personal Kanban as the most introductory, followed by Kanban, which goes into greater depth and does a good job of building on Personal Kanban (even though it was written first). Scrumban is more advanced and is a collection of essays/blog posts that are more loosely organized than the other two books.

Getting back to Kanban, the book, I really enjoyed this book for several reasons. I’m a fan of David Anderson’s and have seen some of his presentations on lean and kanban, so I was looking forward to the book. You can learn more about David here. Before getting into the book, take a closer look at the image on the cover at right. Notice that the three workers’ statuses are obvious based on the board behind them. One of the beautiful effects of kanban implementation is the easy, visual communication of status to everyone without the need to ask for status reports.

The book is organized into 20 chapters spanning just over 250 pages. Different people will find different parts of the book valuable. Chapters 3-5, representing “Part 2 – Benefits of Kanban,” were my favorite, and in particular the case study presented in chapter 4, “From Worst to Best in 5 Quarters,” is particularly compelling. In it, Anderson describes a dysfunctional team that sees dramatic improvement in lead time and customer satisfaction. To wit:

the team had reduced the lead time to an average of 14 days against an 11-day engineering time. The due-date performance on the 25-day delivery time target was 98 percent. The throughput of requests had risen more than threefold, while lead times had dropped by more than 90 percent, and reliability improved almost as much. No changes were made to the software development or testing process. The people working [on the team] were unaware of any significant change.

Think about that. This team’s performance (measured in throughput, lead times, quality) was dramatically improved, and the individuals on the team were unaware of any significant change. Chapter 4 alone is enough to merit buying and reading this book if you’re involved in shipping software. I spend some time on this same case study in my Kanban Fundamentals training class, because I think it’s a great testimony to the power of these ideas in practice.

Part Three, chapters 6-15, discusses Implementing Kanban. There’s a ton of great material here for anyone interested in using kanban to improve their organization or team, from creating card walls and describing what to put on each card to negotating and establishing service level agreements with clients. One of the recommended steps to successfully implement kanban is to change the way work is delivered to and from the team implementing kanban, and establishing service level agreements with downstream collaborators is one way to accomplish this. In this section David also discusses some of the theory of queues and the need to limit work in progress, as well as how to scale kanban to larger projects.

Part Four, Making Improvements, looks at how to eliminate waste, reduce variability, keep things flowing through bottlenecks, and introduces economics to the discussion. In the simplest case, lean proponents tend to adhere to certain basic principles, like “reduce variability to increase flow” and “the ideal is one piece flow”, that is, a batch size of one with zero queues. Donald Reinertson, whom Anderson references in this section, does a great job of applying real-world economics and payoff functions to these ideals. He explains how the world of software development has very different economic payoff functions for things like variability and batch size than does a physical factory (where lean and kanban originated) in The Principles of Product Development Flow (review coming). One term Anderson introduces in this section that I found worth noting is failure load.

Failure load is demand generated by the customer that might have been avoided through higher quality delivered earlier… Failure load still adds value. But what is important is that it adds value that should have been there already.

It seems to me that failure load is conceptually related to technical debt. When you deliver software that has a large amount of technical debt, there may be resulting defects or extra resources required to modify the system that shouldn’t have been there. Fixing them, paying down the debt, adds value, but it’s value that should have been there already if the quality of the software had been better.

Each chapter in the book ends with a bulleted list of takeaways that highlight the important ideas covered. Like this:

Takeaways

Kanban is a great book for learning about and implementing kanban for teams
The case study in chapter 4 is, I think, worth the price of the book all by itself
Beyond the mechanics of setting up a visual card wall or board, the book describes how to implement kanban within an organization
Think about how much failure load your team has, and how you could reduce it
Learn more about kanban from Pluralsight

Make IIS Express the Default for VS2010 Web Projects

Mon, 19 Mar 2012 18:37:18 GMT

Here’s a quick tip that will help you leave Cassini in the past where it belongs. If you’re using VS2010 SP1, you can configure your IDE so that it will automatically choose IIS Express out of the box for new web sites and projects. There are a lot of good reasons why you should be using IIS Express instead of Cassini / WebDevServer – you can learn more about IIS Express here. Unfortunately, Cassini remains the default web server for new web projects in VS2010 (unless you change it).

To configure an individual web project to use IIS Express after you’ve created it, simply right click on the project in Solution Explorer and choose the Use IIS Express option. You can also configure it in the Web tab of the project’s properties:

That’s great, but it’s annoying to have to do for every new project you create. The good news that it’s pretty easy to make IIS Express the default. Thanks to Damian Edwards for pointing this setting out to me. You can go to Tools-Options-Projects and Solutions-Web Projects and check a box there to make IIS Express the default. Note that this setting will work for web sites as well as web projects, so don’t let the menu’s name throw you off.

That’s it. Check the box, and enjoy a Cassini-free development environment from this point forward. Except on your other machines, where you’ll have to set this setting again. Oh, and next time you reinstall Visual Studio – you’ll have to set it again then, too. Y’know, wouldn’t it be cool if Visual Studio would remember your settings in the cloud for you? I’ve only been asking for that since like 2003. Maybe now that remember users’ settings is getting baked into Windows 8 it’ll be closer to a reality for Visual Studio. I can dream…

Getting Started with Single Page Applications in ASP.NET

Fri, 16 Mar 2012 13:22:02 GMT

One of the new features in ASP.NET MVC 4 (Beta) is a new project template for Single Page Applications (SPA). You can download the latest version of MVC4 from http://asp.net/mvc/mvc4. Once you have that installed, get started by creating a new ASP.NET MVC 4 project:

You’ll immediately be asked another question about exactly what kind of project you’re looking to create. This is only asked on project creation, but it’s possible in the future you’ll be able to mix and match these kinds of templates and the resources they provide in a more ad hoc manner, after projects are created, in the future. For now, though, to check out Single Page Applications, choose that template.

Ok, so now we have our new project and in a few seconds our project is fully set up. We see a solution explorer window that looks something like this:

So of course the next step is to hit F5 (or ctrl-F5) so we can check this thing out, right? Doing so yields a pretty standard home page:

Unfortunately, there’s no SPA goodness going on here. Yet. Unlike most of the other project templates, this one actually expects you to do some work to get things going. The nerve, right? In fact, if you’d actually read the first page that came up in the solution before quickly hitting F5, you might have noticed these comments:

But admit it, you didn’t read that, you just hit F5, right?

So, let’s go ahead and actually RTFM a bit and see how this SPA stuff works. We’re basically going to follow the instructions shown above. If you *didn’t* hit F5 yet, make sure you do so or Build the project before you try to do the Add –> Controller step. Otherwise, you won’t see the TodoItem as an option for the Model Class. The dialog should look something like this:

Now you can hit F5. And then manually change the URL to /Tasks to see the page in action.

Pretty exciting, eh? At this point, you can perform standard CRUD (Create-Read-Update-Delete) operations on your TodoItems without ever going to a new page. Watch the address bar and open up F12 developer tools in IE (or Chrome, or Firebug in Firefox) and watch the network activity as you manipulate the data in the list. You should see something like this:

You’ll also notice that you get full back/forward button support in your browser, which is pretty cool considering this is a single web page. So how does this work? Let’s look back at Visual Studio and see how this is all put together, starting with our controller. If this were a traditional ASP.NET MVC application, we would expect our TasksController to include a bunch of methods for things like Index, Update, Delete, etc. Here’s the one we created for the Single Page Application:

Now let’s look at the View. It’s probably a massive mess of indecipherable JavaScript to make all of this stuff work. Or is it? Here’s the Tasks’ Index.cshtml file:

Ok, so, 27 lines of text with 4 lines of JavaScript – not bad. I’ve circled the areas that make the magic happen. The two divs on lines 6 and 10 have a data-bind attribute set which is linking their visibility to the state of the page. That is, when the page’s state is not editingTodoItem, the grid is shown. Otherwise, the editor is shown. These bindings will be triggered instantly if the state of the page changes.

Likewise, the success and error divs on lines 14-15 are also making use of the data-bind attribute, in this case to bind the text of the div and specify the duration (in milliseconds) that the div should flash and remain visible.

Finally, there are two script blocks. The first one pulls in the viewmodel for the TodoItems, which was created for us when we created the controller using the Visual Studio tooling. This script file contains about 100 lines of JavaScript code that provides the client-side viewmodel the user will interact with. The constructor for this ViewModel class takes in some parameters, one of which is the URL to the web service/API that will be used for persisting changes to and from the data source. You can see in the code above that we’re passing in a URL of ~/api/GettingStartedWithSPA which is the name of my project. The /api convention is used by Web API by default.

Looking back at our list of Controllers, we now see that one that was added is named the same as our project, and another one for the model class we’re working with (TodoItem). These provide the Web API for performing CRUD operations on our model class, by default using Entity Framework. In addition, the /api/ path is specified in an AreaRegistration class in the first of these controllers:

The heavy lifting is all done by the base class, but by default it won’t actually expose any services until you create the methods yourself. That’s why the other controller file is there – it exposes the four methods we need to work with the data. Note that it’s part of the same class as in the other file, not a separate class.

That’s pretty much all of the server-side code required for the simple TodoList management application that we have at this point. Let’s look back at the client-side script from the Index.cshtml view. The last bit of script was:

Line 19 simply uses jQuery to run this script when the page has completed loading. Line 20 uses a helper method to define the shape of the data. At runtime, the code emitted by this helper looks like this:

The reference to upshot is referring to a JavaScript library included in the project, upshot.js. Upshot’s main task is to link your client-side code and the changes you make to the client-side model with the backend server-side persistence via web API calls.

Next we create the viewModel, and finally we apply the bindings on line 25 by calling another JavaScript library, knockout.js. Knockout provides the support for data binding, observable properties, and the structure for creating client-side ViewModels that we can interact with at a higher level of abstraction than DOM elements.

Even Better Updated Templates

Even better than the default item templates that come with the MVC 4 beta bits, there are some updated examples that Steven Sanderson posted about last week that you can get via NuGet. Start with a new MVC 4 project, and then install the package from the Package Manager Console by running this comment:

Install-Package SinglePageApplication.CSharp

assuming you’re using C# (.VisualBasic for VB). You should see a bunch of stuff in the console window and perhaps a few security warnings, and maybe even an error referring to a T4 template (SpaIndex.tt). Ignore all of these things and dismiss the various security windows.

When you install this package, it does the following:

Note: If you run this after already adding a controller using the original MVC4 Beta templates, your _SpaLayout.cshtml file will be messed up. It should look like this (you’re best to start from a new project):

You’ll note that both knockout and upshot were upgraded, along with EF and jQuery. Looking at the new default view, we can see it’s a bit shorter and cleaner now:

The latest version moves the <div> tags and their data-bind attributes into the partials, and uses a new helper method to configure upshot, leaving just one line of raw javascript in the file now. Running the revised template results in this:

Notice how this version behaves differently. As you add each item, nothing happens on the network. Now click Save all, and you’ll see that all of the values are persisted at once, and the CSS styling of the items goes away (Green was indicating they weren’t yet saved). You can also click Revert all to throw away any unsaved changes you’ve accumulated.

This is some pretty cool stuff, and the coolest part is how easy it is for you to set up and work with. If you find this technique interesting, I strongly recommend you check out Steven Sanderson’s talk on Knockout and Upshot and also look at John Papa’s MVVM and Knockout course on Pluralsight.

You can view and download the source code shown here (both projects) here.

How to Give Feedback on Microsoft Developer Products

Mon, 12 Mar 2012 16:12:51 GMT

In the last few years, a number of Microsoft dev teams have started using online tools to manage how the community can offer feedback. If you’re a Microsoft developer, and especially if you’re a web developer, you should know about these tools and offer your feedback through these channels if you’d like Microsoft to respond to your needs. There are several ways you can offer this feedback, and different reasons why you might choose one channel or another.

UserVoice

By far the most effective way to get your ideas on the radar of the product teams is through the use of UserVoice forums for the appropriate product or feature. If the group in question has a UserVoice forum set up, then it’s a solid bet they’re looking at it when they are locking in the feature set of a new version of their product. Currently both the ASP.NET and Visual Studio teams have UserVoice forums set up, including separate categories for many of the sub-features of these two groups’ products. Below are some of the areas in which you can leave feedback for the teams:

Connect

While UserVoice is great for feature requests, bugs are better reported via Connect. The challenge with Connect is finding the right place to log the bug. In the case of developer tools, you’ll find them listed here:

Connect – Developer Tools

Many of the products will also accept suggestions, in addition to bugs, via connect. If you’re really pushing for something, it wouldn’t hurt to post it to both UserVoice and Connect. Some of the specific Connect links for product feedback and bugs include:

Unlike UserVoice, Connect can also grant access to private forums and resources. If you’re in a particular “insiders” or early adopters program, you’ll likely use Connect to get access to documentation and software, as well as to leave feedback on the product(s) you’re using.

Twitter

Twitter has become a very popular way for software developers to communicate. Microsoft has a large presence on twitter, and you can use this medium as another way to reach our to Microsoft and provide feedback. Most of the actual developers and PMs working on developer tools for Microsoft are on twitter, and the various products have official twitter accounts as well. There are several ways you can have your voice heard, even if you’re completely new to twitter (if you are, the first step is to create an account – the rest of these assume you have one).

Follow the Conversation

If you’ve ever been a member of a mailing list or newsgroup, you probably know that it’s often best to “lurk” for a bit to get a feel for how the community interacts, who the main contributors are, etc. You’ll usually get a better reaction from the participants in the discussion if you understand how they interact and follow the often unwritten rules of the medium. Twitter has no private meeting rooms, but this notion of understanding who’s involved in the community still applies. Before you speak, it’s a good idea to listen. There are several ways to find the conversations of interest to you on twitter, including accounts, hash tags, and lists.

Follow Specific Accounts

Whatever tools and technology you’re using, there are most likely official twitter accounts for them and certainly individuals who are involved in creating, supporting, and using the technology. Here are some official twitter accounts for various products you might wish to follow. Once you follow them, you’ll be able to see which users they tend to interact with, and twitter itself will suggest other twitter accounts you may wish to follow.

In addition to product-specific accounts, which tend to mostly post announcements and occasional responses to tweets that reference them, you can also follow real people. For instance, if you’re interested in ASP.NET and/or Azure, then you’ll want to be sure to follow Scott Guthrie (VP of Azure) and Scott Hanselman (prolific community rep for ASP.NET). You can follow me, too, if you like, though I don’t have nearly the reach and influence of these two Scotts.

Once you’re following a few of these accounts, you can use Twitter’s “similar to” feature to find additional people you may be interested in following. For instance, here’s a list of accounts Twitter thinks are similar to mine.

Follow Hash Tags

In addition to following individuals, you can also follow hash tags. Hash tags are simply words you can include in a tweet to “tag” them as being related to a particular topic, and by convention these are prefixed with a hash (#) symbol. For instance, #aspnet would be used to indicate a tweet that maybe didn’t mention ASP.NET/ASPNET by name was related to this technology. Most twitter client applications offer support for saved searches that will let you follow a hash tag, or you can search for a hashtag on twitter’s web site. By following the hashtag, you’ll start to see who the major players are in the conversation, and you can add them to your list of people you follow if you find them interesting.

Follow Lists

Twitter also has support for Lists, which any user can create. You can subscribe to a list, and viewing a particular list lets you see a stream of just that lists’ members’ tweets. This can be a great way to filter different interests you might have, and gives you a way to pseudo-follow individuals without actually following them and having their tweets in your main stream. There’s a good write-up on Twitter Lists here. As an example, you can see a List of all programmers Scott Hanselman follows (or did when he created the list) here.

Project Hubs

Many of the projects currently under development for Microsoft developers are built in the open at sites like CodePlex and GitHub. You can find out more about projects, get access to source code, and report issues. You can even fork the code and submit a pull request for the owner to consider including in the project. Here are a few project hubs you might want to check out:

If you’re serious about getting your idea implemented, you can always create your own implementation of it, either from scratch or by forking an existing project. This can provide a great way to explain how you would approach the problem and what your idea of the solution looks like.

Your Blog

Don’t underestimate the power of your blog to express your ideas and get them heard by the community. Even if, like most of us, your blog doesn’t get inundated with traffic, it can provide you with a place to explain your thoughts in whatever way makes sense to you. Your blog can be a great way to support your feedback via other means, as you can link to a post that elaborates on an idea you couldn’t fully describe in 140 characters on twitter. The best ideas and feedback offer constructive criticism and reasons why the status quo causes you pain or slows you down. Try to avoid rants or simply complaining that a particular product of feature “sucks” if you’re hoping for someone to actually take action. You’ll also find that while sensational titles can work well as “link bait”, they’re also cliché enough at this point that whole articles have been written making fun of them. Try to craft a compelling and honest title, but try to avoid over-sensationalizing if you want to have a reasonable conversation with your readers.

Personal Contacts

Just like in real life, often the best way to explain yourself is through personal connections with real people. When you have the opportunity, go to a conference or user group and listen to the folks in your community of choice. Introduce yourself. Have a conversation. Ask questions and listen to what they’re working on right now, and let them know what you’re doing and how you could be doing it better. Shockingly this kind of interaction can be much higher value than any virtual electronic system, so don’t underestimate it.

What Works For You?

Hopefully you’ve found this useful, now it’s time to give something back. What have you found to be the most effective way to provide feedback on Microsoft developer tools? Post a comment with your story, and let us know.

Personal Kanban Book Review

Fri, 09 Mar 2012 14:29:53 GMT

Not long ago, while preparing my Kanban Fundamentals video training class for Pluralsight, I read Personal Kanban, by Jim Benson and Tonianne DeMaria Barry. If you’re new to the concept of kanban, this book is a good place to get started (along with my course, which is about 90 minutes long, and shorter if you speed it up). I read the kindle edition of Personal Kanban, even though I don’t own a Kindle. It allowed me to read it at my PC, on my iPad, and on my Windows Phone, depending on where I found the time. Whether you pick up the book for $10 electronically or $25 on paper, it’s very reasonably priced and is a fairly quick read at just 216 pages (paper).

What’s To Like

I really enjoyed the book’s narrative and simple, straightforward style. The authors do a great job of presenting the material in a very approachable manner. The use of cartoons and photographs help to explain important points. I also liked that the book jumps into the material in the first chapter, explaining why Personal Kanban is needed, what the rules are, and why they work. By the second chapter, you’re already creating your own personal kanban using easily available and inexpensive materials.

The book’s system has only two rules: Visualize Your Work and Limit Work in Progress (or Process). These two rules drive the process, and the details of how an particular system is implemented can vary based on what works for the individual. The rest of the book explains how these rules help to maximize flow and effectiveness over utilization and efficiency.

The authors also have a blog and continue to post valuable material related to the book’s topic at PersonalKanban.com.

What to Improve

One reviewer on Amazon describes the book as “A good idea sold in too many pages.” I can relate somewhat to this reviewer, as the book, even at just over 200 pages, is at its core describing a very simple idea with a very simple implementation. This is both its blessing and its curse. The authors do not waste the reader’s time with fluff, in my opinion, but I certainly agree that the greatest value in the book comes from the first couple of chapters and the rest is supporting material.

In the kindle edition, at least, some of the illustrations/cartoons are not terribly high resolution, making some of the small text difficult to make out. The main points of the cartoons are completely legible, though, so this is a very minor concern, and probably out of the authors’ control.

Summary

I’ve reviewed the book with four stars on Amazon. I found it to be valuable and integrated many of its ideas into my course. If you’re looking to learn more about how to use kanban and lean concepts in software development, this book can be a good primer. Once you’ve finished it, I would recommend you read Kanban, Lean Software Development (related post), Scrumban (review), and finally Principles of Product Development Flow, in order from least to most advanced. My Kanban Fundamentals course is meant to cover the basics described in Personal Kanban and Kanban, primarily. I hope to produce a follow-up course that gets into more advanced lean/kanban principles and practices described in the latter titles and my own experience.

Sending Email from a Sitefinity Module with Attachments

Fri, 24 Feb 2012 21:42:06 GMT

A fairly common use case in web applications is the need to send an email, and applications built on top of Telerik Sitefinity are no different. Since modules are simply .NET DLLs, you’re free to write whatever code you like, so it’s certainly possible for you to write a module that sends emails in a way that knows nothing about Sitefinity. However, if you want to interact with Sitefinity, for instance making sure that you use the same SMTP server that is configured in the Sitefinity settings, or attaching a file from a Sitefinity library, then this post will show you how to do so. I strongly recommend that you allow the user to configure the way emails are sent via the Sitefinity UI if your module will be sending emails, as it will be confusing and annoying to users if this isn’t the case.

Sitefinity Email Settings

You can find your Sitefinity email settings by going to Administration – Settings – Advanced – System – SMTP (Email Settings). You’ll also find a separate location with settings for sending Newsletters under Administration – Settings Advanced – Newsletters. You can use either one for your custom module’s settings – which one you choose really depends on what you’re doing. If you’re sending some kind of administrator alert, then the System one probably makes more sense. If you’re letting users sign up for notifications about updates to your site, then perhaps the Newsleters section is the more logical choice. You can see where to set them in the UI here:

In my example, I’m going to use the Newsletters section, but I’ve included the code for the System setting in a comment.

Sending Email in Sitefinity

private void SendEmail(string toEmail, string fromEmail, string subject, string body)

       var manager = ConfigManager.GetManager();

       string smtpHost = manager.GetSection<NewslettersConfig>().SmtpHost;

       //string smtpHost = manager.GetSection<SystemConfig>().SmtpSettings.Host;

       var smtpClient = new SmtpClient(smtpHost);

       var message =

           new MailMessage(fromEmail, toEmail)

               Subject = subject,

               Body = body

};

       smtpClient.Send(message);

Adding an Attachment

In Sitefinity, you can use the Fluent API to work with most of the content in a site. For instance, to work with the documents in the site, you can simply write App.WorkWith().Documents() and follow this up with whatever commands you wish to send. If you need to get an instance of a document, you can call Get(). If you need to pull in the document’s raw data as a stream, you can use the DownloadContent(out stream) method. You can chain all of these things together into a single statement that gets a given document and its stream of data. One you have this, it’s easy to use the stream to add a file attachment to an email. In this example, we are simply attaching the first document that we find in the site’s document library – in the real world you would pick a particular document by its id or perhaps title.

Sending Email with Attachment in Sitefinity

private void SendEmail(string toEmail, string fromEmail, string subject, string body)

    var manager = ConfigManager.GetManager();

    string smtpHost = manager.GetSection<NewslettersConfig>().SmtpHost;

    //string smtpHost = manager.GetSection<SystemConfig>().SmtpSettings.Host;

    var smtpClient = new SmtpClient(smtpHost);

    var message =

        new MailMessage(fromEmail, toEmail)

            Subject = subject,

            Body = body

};

    // attach a document from a sitefinity document library

    // this example just gets the first document it finds

    System.IO.Stream stream;

    var doc = App.WorkWith()

        .Documents()

        .First()

        .DownloadContent(out stream)

        .Get();

    var fileAttachment =

        new Attachment(stream, doc.MimeType);

    message.Attachments.Add(fileAttachment);

    smtpClient.Send(message);

As you can see, it’s pretty easy to work with email from within a Sitefinity module or widget, leveraging the existing settings and document libraries of the site. The Sitefinity API is quite extensive, and the Fluent API can provide a very intuitive and flexible way to interact with the system.

Reviewing Scrumban the Book

Fri, 24 Feb 2012 14:10:56 GMT

I’ve been reading a bunch of kanban and lean books recently as I work on my Pluralsight course on Introducing Kanban. The most recent one I’ve finished is Scrumban, Essays on Kanban Systems for Lean Software Development, by Corey Ladas (I’m doing the reviews in LIFO order). I made a bunch of notes while reading this book, and it has a great deal of useful information. I read David Anderson’s Kanban book first, followed by Benson and Barry’s Personal Kanban. I think reading Scrumban last was definitely the right choice, though if I were recommending these books today I would most likely suggest someone start with Personal Kanban, as it’s the lightest weight of the three.

One thing that sets Scrumban apart from the other books is the narrative style and organization of the book. As it says in the title’s byline, this book is a collection of essays – there isn’t a great deal of cohesion or a consistent narrative guiding you through the book. It also tends to assume a fair bit of of knowledge on the part of the reader, which is one reason why I wouldn’t start off with this book if you’re just starting to learn about kanban and lean software development. I also don’t think the title is particularly fitting, since there is only one essay that deals with scrum and mentions the term scrumban in the whole book. I have a feeling the title was chosen mainly because it was short and would leverage the popularity of scrum to drive up book sales – whether this was the case or was successful I can’t say.

I found a great deal of value in the book, and it is certainly no rehash of the other two kanban titles listed above. There are some very important, basic concepts covered here such as the analogy of kanban tokens to money in one of the first essays. Corey does a great job of examining multiple different approaches to processes and showing their pros and cons. Things like methods for synchronizing different handoffs between related up- and downstream collaborators in a process are explained clearly and are honestly things I’d never given much thought previously. The book also does a great job of reinforcing the notion that time-boxed iterations are a stepping stone to an even more streamlined process. If you’ve ever considered the logical progression of moving from infrequent software builds, to having a daily build, to having continuous integration, you can see the same logic being applied to moving from large project phases and handoffs (e.g. waterfall) to many smaller and iterative iterations (sprints), to continuous software delivery and one piece flow (ideal).

One criticism I do have of the book is that it often didn’t define new terms and acronyms as they were introduced. I noted a bunch of them:

There were probably more that I missed because I was already familiar with the term, and of course it’s possible some of these were covered somewhere in the book and I missed them, but these were my “google these later” notes. The links above are the result of my google-fu after-the-fact.

The latter 2/3 of the book shows a bunch of different ways to model processes using task boards, and the effects of each of these designs. The analysis from these areas of the book are easily worth the price of the whole book, considering how much time they’ll save you if you’re just getting started. The book doesn’t propose one right way to go about implementing such systems, but it does a very good job of showing the pros and cons of a number of approaches.

Overall, I thought the book had some great information, but could have been organized better. I would give it 3 or 4 stars on Amazon and would recommend other books first, but if you’ve read the others and still want to learn more, there’s some great information here.

If you’re looking for a quick introduction to kanban for personal or team use, check out my Kanban Fundamentals course on Pluralsight.com.

Asus Zen Ultrabook One Month Later

Thu, 23 Feb 2012 02:26:27 GMT

I wrote a few weeks ago about my new Asus Zen Ultrabook computer. I’ve been using it as my primary laptop computer since then, and thought I’d write up a follow-up on how it’s been. Overall, I’m quite pleased with it. The performance is great, the battery life is quite good, and the instant on/off experience makes it almost as quick and easy to use as my phone or iPad. In fact, I’ve just spent the last three days on the road at a client conducting training, and driving as many as four concurrent Visual Studio 2010 instances along with three browsers, SQL Server, and PowerPoint, and everything ran great. So, the short version is, it’s a nice piece of kit and you probably won’t be disappointed with one if you pick one up.

Here are some more thoughts, broken out into a few categories.

Physical Features

The Zen Ultrabook has a smooth metal finish that makes it very solid. In fact, it’s downright dangerous looking, it’s so thin. I’ve joked to a few people that you could use the Asus Zenbook to hack apart zombies, and it would probably keep working afterward. It’s that thin, sharp, and solid. If you think thin is sexy, you’ll want to check this machine out. Its metal case also makes it very rigid. I can hold it with two fingers, open, from one corner, at arm’s length, easily.

Being a super-thin laptop, it doesn’t have some of the things fatter laptops have, like DVD drives or VGA ports. Instead it has mini-ports for video, and only two USB ports. It does have an integrated MMC/SD card reader, though, which is handy, and it comes with a USB-to-Ethernet dongle that I’ve used all of twice in the last month when I needed a hardwired connection. Otherwise, wireless works great.

The keyboard takes some getting used to. It’s not like any other I’ve used in the past, and new users including me tend to make a lot more typing errors on it than typical. It can be rather frustrating, but I’m starting to get the hang of it. The fact that the Home/End/PageUp/PageDown keys are all accessed via the Fn+Arrow keys is annoying, since I’m accustomed t having those as actual keys, but hardly a show-stopper.

The touchpad takes some getting used to, as well. It’s very big and sensitive, and supports both tap-to-click like most touchpads as well as push-in to click, which is somewhat novel Also, the buttons are not separate, but are part of the touchpad, which means that when you think you’re putting your finger on the button area to click, you can still be moving the pointer, so you have to get used to that as well. Once you do, it’s all good.

One minor issue I ran into at one client had to do with the tight placement of the ports on the right side. The mini-video port is so close to the USB port that some USB devices won’t fit into the space while you’re using the video port (e.g. presenting via a projector). It’s only been an issue once, and it’s more a failing on the part of the USB device than the laptop, since there’s generally no reason why the USB device needs to be so fat where it’s connecting to the USB port.

it’s super-light. It plus its power adapter are less than half the weight of my previous laptop.

Running Programs

I mentioned at the outset that the performance of the machine has been great. The screen is big enough to develop productively on – yeah, I’d prefer my desktop workstation with 2 or 3 big monitors, but for a portable computer, this one has been great. And it’s small enough to open comfortably on an airplane, as well, with enough battery to last 5-6 hours. Here’s the specs on the OS and system:

And here’s the Windows Performance Index:

Even with VS, Skype, several browsers, etc. all running, the system is extremely responsive. Here’s what it looks like literally as I’m writing this:

I haven’t installed or played any games on the machine, so I can’t tell you how well it plays Starcraft II or Call of Duty. For work purposes, though, including building large software solutions while on the go, it’s quite good. Here’s a final screenshot of Visual Studio, showing how much space you have:

Summary

I’m very happy with this machine. More ports, infinite battery life, and a keyboard that is a bit more like ones I’m used to are things I might ask for to improve it. But overall, it’s an awesome machine packed into a super-thin, super-light chassis.

Excel Cumulative Flow Diagram

Sun, 12 Feb 2012 16:16:42 GMT

I’m working on a Kanban Fundamentals course that should go live soon on Pluralsight. One of the topics I’m touching on is Cumulative Flow Diagrams, and how these can be used to analyze flow of a process. Some electronic kanban tools like AgileZen have some built-in support for CFD-style reports, but for instructional purposes it’s nice to be able to create one on-the-fly with whatever data one needs to illustrate a point. And of course, if you’re not using any fancy tools but would still like to benefit from the insights a cumulative flow diagram can provide, it’s nice to know how easily one can create one using Excel.

I’ve created a sample you can download and modify for your needs. This will of course be the fastest way to get started:

Sample Excel Cumulative Flow Diagram Worksheet and Chart

Creating a Cumulative Flow Diagram in Excel

To create your own cumulative flow diagram in Excel, simply create a worksheet with a column for the date, and columns for each of the states in the process you are modeling. For example, if your software development team’s process has tasks moving through states of Ready, Develop, Test, and Deployed, then you might create an Excel worksheet with columns like this:

Next, begin collecting data. At a particular time each day, and at the same time each day, not how many stories, cards, tasks, or whatever you’re using in your system to represent active work items are currently in your system. Record how many are in each state. Pay no attention to which ones, specifically, are in each state – a CFD is an aggregate tool and doesn’t focus on individual work items. After a few days, you should have some data like what’s shown above.

Once you have some data, you can create a cumulative flow diagram in Excel using Excel’s built-in charting capabilities. Simply highlight all of your data and the headings, and select Insert – Charts – Area – Stacked Area as shown here using Excel 2010:

By default, you’ll most likely get a chart that puts Ready on the bottom and Deployed on the top:

By convention, CFDs are set up so that time flows from left to right, and we achieve this by ensuring that the order of the states is such that the earliest states appear at the top and the final state appears at the bottom. You can rearrange the order of the data in your chart by right-clicking on it and choosing Select Data. Then use the arrow keys in the Legend Entries (Series) box to reverse the default ordering of the data series:

When you’re done, the data in the Legend Entries should be ordered Deployed, Test, Dev, Ready, and your chart should look something like this:

You can analyze your flow using a CFD by measuring vertical and horizontal distances within the chart. For instance, in the chart above, if we look at the vertical distance of our activity states (Dev and Test) on 3 February, we can see that we have only 3 work items in process (work-in-process, or WIP). We can also see that our Test activity is outpacing our Dev activity later in the month, with 0 WIP items on the 5th, 7th, and 8th of the month, while the Dev WIP has grown to as high as 4 items. This is identifying a bottleneck in our flow, which at this point is the Dev process.

If we analyze the diagram by measuring horizontal distance, we can determine how long it takes for a work item, on average, to make it through our process. Depending on what you’re trying to do, you may start the clock when an item enters the Backlog, or your Ready queue, or when you actually begin work on the item. For simplicity given the small dataset I’m showing here, let’s say we’re only concerned with the time it takes an item to make it through our Dev and Test activities. Once more if we look at 2 February and measure from the top of the red Dev area horizontally to the right to the top of the purple Deployed area, this will tell us approximately how long items are taking to be deployed that were begun on 2 February.

In this case, we see the cycle time is just 1 day. However, if we do the same thing for items which were begun on 3 February, we find that these were not completed until 7 February, or 4 days. Since this is just the beginning of our project and we’re still ramping up, this most likely isn’t a huge area for concern, but if you find a 300% increase in your cycle time in a mature process, it’s definitely worth investigation.

Summary

Cumulative Flow Diagrams can be a useful tool to use when analyzing flow of work through a system or process. While there are tools that can produce these charts for you, you can easily create them yourself using Excel, as shown here. Feel free to download and modify the sample Excel cumulative flow diagram file. If you found this helpful, you may wish to watch my Kanban Fundamentals course on Pluralsight.

Fixing Floating Rectangles in ASP.NET StackedBar Chart

Thu, 09 Feb 2012 19:19:47 GMT

In working on a client’s reporting system, I ran across some StackedBar charts that were using the System.Web.DataVisualization.Chart control that were having some problems. The biggest one was that the rendered bars had gaps and floating rectangles in it. This turned out to take about an hour to solve, using my best Google-fu, so I’m posting my solution and notes here, in case I run into it again and to save some other poor soul an hour’s time.

The Problem

Here’s what the chart looked like, originally.

I’ll spare you the original code, as it was a total rat’s nest, but I was able to dramatically simplify it before proceeding to fix the actual issue. A bit of searching led me to believe that the problem stemmed from not having the same number of datapoints for each X value. You can actually dump the values of the chart data into an XML format pretty easily, using this command:

The resulting XML looked something like this:

Clearly, there are two problems here. The first one is that each series has a different number of data points. The second is that the points are not in order by year. You need to fix both of these problems in order to get the correct chart behavior.

Adding Empty Data Points

My first stab at adding empty data points was to use a method that seemed well-suited to the task:

Unfortunately, this didn’t fix the chart, and upon looking at my chart.xml data, it also didn’t add in any empty points. I tried a few variations but couldn’t get it to work with my data. Eventually I found a newsgroup posting with some code to do this by hand, which I ended up adapting to my needs:

//// now fix empty data points

var xVals = new List<double>();

foreach (var series in Chart1.Series)

    for (int i = 0; i < series.Points.Count; i++)

        double currentXValue = series.Points[i].XValue;

        if (!xVals.Contains(currentXValue))

            xVals.Add(currentXValue);

foreach (var xVal in xVals)

    foreach (var series in Chart1.Series)

try

            if (series.Points.FindByValue(xVal, "X") == null)

                series.Points.AddXY(xVal, 0);

        catch (Exception)

            series.Points.AddXY(xVal, 0);

foreach (var series in Chart1.Series)

    foreach (var point in series.Points)

        if (point.YValues[0] == 0)

            point.IsEmpty = true;

I’ll probably clean up this code further and move it into its own method (perhaps an extension method on Chart) in the future. It’s not pretty, but it does the job. With this in place, the resulting XML code looks like this:

The chart, however, is still broken.

Sorting the Points

The last step is to sort the points. This is actually quite easy to do with the following bit of code:

foreach (var series in Chart1.Series)

    Chart1.DataManipulator.Sort(PointSortOrder.Ascending, "X", series);

With this in place, the resulting XML code looks like this:

and the chart looks like this:

Summary

The charting controls available in the DataVisualization namespace are very powerful. I hope this will help some folks who are trying to get their StackedColumn chart to display propertly. Unfortunately, the documentation available from Microsoft directly on these controls is rather sparse. Hopefully this will help others who are trying to use these charts (which, by the way, can certainly be used outside of ASP.NET – in my case they are being used to generate image files that are then merged into Word and PDF reports, not for display on web pages).

Team Workspace Reflections

Wed, 08 Feb 2012 15:15:04 GMT

We’ve been fans of team rooms and collaborative work environments at NimblePros for some time. In building out our new building, we took care to create several large open spaces to be used as team rooms, with plenty of room in the middle for workstations (configured for pair programming) and lots of open wall space around the outside for whiteboards and information radiators. You can see one of our team workspaces, before the furniture and whiteboards went in, on the right. The idea was to follow the Caves and Commons approach first recommended by Extreme Programming, and it’s worked very well. We gave some of our senior staff their own office spaces and we set up a group “cave” with several desks in it where folks could go to take a phone call or work individually on a task, but almost a year after our move, some of the senior staff’s offices have been emptied out as they now spend their days in one of the team rooms, and the one “cave” room very rarely sees use (but it is nice to have when it is needed, so we consider it worthwhile space).

Today there’s been a great thread on the Extreme Programming mailing list on this topic, and I thought a few of the quotes were worth sharing here:

When I created my software R&D space some years ago, I ensured that every programmer had a private office with a window.
When we did some of our really difficult projects, we created a "war room" to work in. It went better.

When XP was invented, we worked with everyone in a big room. No one on the team wanted to go back: we were all certain that it was the most productive and enjoyable project we had ever been on.

I have worked with many teams since then, and the results have been the same. Except for a very few individuals -- who have never been considered to be key team members anyway -- teams have been more productive by their own measure, in a team room.

I don't know what kind of rooms or projects these articles refer to, but I would never do a software project without the team in its own common space if I had any choice at all.

Ron Jeffries
www.XProgramming.com

This has been my experience as well. Team rooms are simply more fun, more productive, and more energizing, provided everybody is working on the same project and is motivated. As with anything, there can be problems, such as off-topic conversations distracting the team, but generally the team is able to self-police such things, at least in my experience. Another quote from this thread, in response to Ron’s above:

My experience has been basically the same. Everyone wanted their private office until they tried the common space. Then they voted to give the offices to someone else. They had more fun, got more done, and in my opinion came up with far more creative answers...
Steve Ropa

Now, if you’ve read Peopleware, it suggests that one of the biggest barriers to productivity is distracting sound, and that the best way to lower the amount of noise each worker has to put up with is to provide more space (and ideally, separate offices with doors) to each employee. I’ve worked in organizations who had open floorplans larger than football fields filled with rows and rows of cubicles, and it’s precisely this arrangement that comes to mind when I think about the advice in Peopleware. But I think there is a difference between legions of workers in cubicles working individually and small teams working collaboratively on a specific project. When you’re pairing with someone in a team room, you’re able to focus on your work and what your partner is saying to the exclusion of the rest of the room. However, you’re still half-listening to the conversation, so when someone else in the room says your name, or wonders why such-and-such class that you just checked in yesterday isn’t working, you hear it. You can share vital information, instantly, that might otherwise have blocked your teammate until the next stand-up meeting (assuming you hold them).

Last year, at one of the Hudson Software Craftsmanship group meetings, we had a discussion in which we talked about moving a team to agile. To kick off that discussion, I asked the group to describe what an agile team would look like to an observer. One of the first things that was mentioned was that they were working in a team room. Now, I don’t think team rooms are strictly necessary in order for an agile team to be successful, but I do think they’re certainly helpful.

Have you had the opportunity to work on a project in a team room? Do you agree with the ideas expressed above, or has your experience been different? I’d love to hear from some people who have had negative experiences working in team rooms. Please leave a comment if you have some experience to share.