]]> Thu, 06 Nov 2008 23:51:01 -0800 http://virb.com/mike6024/posts/text/915712 http://virb.com/mike6024/posts/text/915711 Our third installment is signed, sealed and delivered. Despite a temporary change of cohosts and change of location, it... well... we got through it. That's all that counts. Check it out!

Streaming live video by Ustream

Streaming live video by Ustream

namespace Bitter
{
    namespace Path
    {
        public static class Url
        {
            public static string Combine(string domain, string page)
            {
                string combinedUrl = String.Empty;
                Uri baseUri = null;

                // create the URI object from the string domain
                try
                {
                    baseUri = new Uri(domain);
                }
                catch (Exception ex)
                {
                    baseUri = null;
                }

                // try to combine and create the new URI
                if (baseUri != null)
                {
                    Uri value = null;
                    if (Uri.TryCreate(baseUri, page, out value))
                        combinedUrl = value.ToString();
                }

                return combinedUrl;
            }

...

We all know that it means that you need adminstrator rights, or to log in to an admin account in order to install something or perform some operation that only admins can do. Well recently I've been working on an install and on the auto-updating feature of Bitter, so I really wanted the ability to show this so that users immediately knew that it required admin rights. But how do you do this in C#? Well, of course, there's no simple Button.ShowShield() method or anything as easy as that. You need to import a dll and then call a method with a certain constant. Fun, eh? Anyway, I wrapped all that into a class and thought I'd share. If anyone finds any bugs or improvements let me know. Enjoy!

class ShieldButton : Button
{
]]> Sat, 25 Oct 2008 22:43:56 -0700 http://virb.com/mike6024/posts/text/892639 http://virb.com/mike6024/posts/text/892638 Yesterday was a successful run (at least in our eyes) of our first show. The recording starts a few minutes in, pesky record button, but we have most of it. We have the video stored up on ustream in case you missed it. We'll be broadcasting again next Thursday, so don't miss it!!! Unless you have something to do... then watch the recorded version!!!

Streaming live video by Ustream

]]> Sat, 25 Oct 2008 22:43:55 -0700 http://virb.com/mike6024/posts/text/892638 http://virb.com/mike6024/posts/text/889684 Aaron Lerch and I have started a new venture. No, it's not "The Aaron and Mike Show". Ok, maybe it is. Basically we're going to be talking tech and probably making fools of ourselves along the way. It's being broadcast at 4pm EST live and we'll keep the recordings around for later viewing. Check it out.

But there's also been talk of The Mike and Aaron Show too. So stay tuned...

]]> Fri, 24 Oct 2008 04:07:19 -0700 http://virb.com/mike6024/posts/text/889684 http://virb.com/mike6024/posts/text/828202 New software for the Zune for both the desktop and the device was released today.

You can download it, but the Zune desktop software should do that for you. Anyway, it looks like some new features are managing your Zune identity and a new search box on the desktop.

And on the device, there's games, a clock, tagging a song you hear using the FM radio  as well as... purchasing media wirelessly! Awesome. Now if only I could get the wireless to work on my Zune...

]]> Wed, 17 Sep 2008 01:48:35 -0700 http://virb.com/mike6024/posts/text/828202 http://virb.com/mike6024/posts/text/813733 According to this other Mike Hall, Vista isn't all it's cracked up to be. Apparently it's too difficult to understand, especially that darn Windows logo:

It's completely alien to the user until they get used to it. It's silly little things like where you used to have the Start menu -- it's now a Windows graphic which is harder to explain on a support helpline.

Yeah, training people to click on the logo instead of the "Start" text will take several hundred man hours. Other companies have had "problems" too:

Transfer of files is actually slower than in previous versions

And even though much of that problem has been addressed in SP1, we won't mention that.

Putting a Vista machine on a desk costs more money

Wait a second here... so you're telling me that the newest, up-to-date OS with all the new features and better security takes better hardware to run? Ok, wait... slow down... It does more AND it needs more RAM and proc speed? Wait wait... So you're saying I don't get all that for free. Ok, you're still going too fast for me...

What people love to forget is that the same things were said when XP came out. "Why go with XP? We love Windows 2000!" XP was the new, glitzy OS with all the bells and whistles. There were compatibility problems. It took more RAM and beefier processors. But that's how this game works. But people just love to blame Vista. They want to blame Vista.

What's worse is that they don't even want to try it out first, because if they did, they'd probably like it.

]]> Mon, 08 Sep 2008 22:09:26 -0700 http://virb.com/mike6024/posts/text/813733 http://virb.com/mike6024/posts/text/783648 When should design trump usability? Can a pretty site be a little less usable if it's extra beautiful? Or is that always a no-no?

In traditional desktop applications, it's a common rule of thumb to not hide functionality behind things such as right-click menus, but to expose them more generally through a top level menu or toolbar. Sometimes in web design, web sites themselves can have a learning curve. It may not be immediately apparent how a site works or what to click on. Its learnability may be a little lower in order to accommodate a slicker design. The web site simply becomes less intuitive. Hyperlinked images start looking like regular images and text hyperlinks start looking like regular text until the mouse rolls over it. That's negative points in the world of user experience.

The actual level of usability needs to be considered too. Preferably your web site is not just usable, but competitively usable. Users should prefer to use your website rather than someone else's. Since the iPhone has been out a while now, some people have come to realize that on-screen keyboards aren't all they're cracked up to be. Even though it is beautiful to behold...

you just can't beat the tactile response of a hardware keyboard...

So when do you go with usability rather than a beautiful design? Or is beauty sometimes enough to compensate for a less than stellar user experience?

]]> Thu, 21 Aug 2008 12:30:05 -0700 http://virb.com/mike6024/posts/text/783648 http://virb.com/mike6024/posts/text/758261 Never assume that the user will never encounter your crazy error condition. "I'll put this in a message box for me to see it" is what you might think. "They'll never see this in the field" is a tempting thought. But then your users might end up seeing something like this:

I can see a line number from a C++ file and some variables being printed to the screen, but what am I supposed to do with that? Is this error bad enough that I should reboot? Should I tell the vendor? Ok, now which application actually popped this error? Was it a browser? Outlook? or maybe Vista itself? I really have no clue. And if my mom ever got this error, she'd be even more lost than me.

So even though you're sure that the error condition in your if-else block will never happen and there's no way the user will ever see it, just remember this blog post.

]]> Wed, 06 Aug 2008 23:34:52 -0700 http://virb.com/mike6024/posts/text/758261 http://virb.com/mike6024/posts/text/724576 What's the best way to balance innovation and convention? creativity and expectations? novelty and normality? When you have a good idea to improve the UX of your product when do you choose to use that rather than stick to what users are used to seeing? If you don't have the option of doing user research and putting this in front of real users' faces, what do you do?

I'll start off with a story. A couple months ago, another developer and I came up with a fairly innovative way to improve how we do filtering in our product. This product hasn't been released yet. We have other products that do similar things, but our product is completely new... unreleased... so this is time to improve it and try new things, right? So we bring our idea into one of the UI review meetings we have every week, and well... let's say things didn't go as planned. We heard comments ranging from "why is it changing?" to "what's wrong with the old way?" to "this is completely unusable". Mind you, no one there had any real data either. They were just stating their opinion. We had several use cases where our method was superior and more powerful than what the product currently had, but that didn't matter. They couldn't see the value in the new paradigm we introduced.

In Observing the User Experience, Mike Kuniavsky talks about a company "Bengali" and their cutting edge, question all your assumptions, state of the art product "Typhoon". Typhoon was supposed to be the next generation web site. A revolution in the industry. The product that sets the standards in the coming age. The problem is that it didn't follow any current conventions or standards or anything else that users of the day were used to. Worse yet, Bengali didn't do any usability research until it was too late. Only then did they find out that users didn't know what to do with it. It was too cutting edge... too revolutionary... too new.

In our UI review, it was pointed out that the filtering mechanism we have now works well and that people are used to it. And that's a completely valid point. "If it ain't broke, don't fix it", right? But that just leads to uninspiring, stale products. Nothing really new ever gets created. So when do you innovate and when do you stick to conventions?

]]> Thu, 17 Jul 2008 20:21:25 -0700 http://virb.com/mike6024/posts/text/724576 http://virb.com/mike6024/posts/text/721472 One of the things that was hard for me to get past when transitioning from C++ to C# was the lack of a 'const' keyword. Sure C# has 'const' (albeit a weaker version), 'readonly', and "final', but none of them have quite the same semantics as the good ol' C++ const. In C++, I could do something like this:

void DoStuff()
{
    const int MaxAmount = CalculateMaxForToday();
    if(MaxAmount > 5)
    {
        // do stuff
    }
    .
    .
    .
    // do some more stuff
    .
    .
    .
    // do stuff at end
    Sum += MaxAmount;
}

What I like about that is that I declared MaxAmount as a constant integer and it cannot be changed for its entire lifetime (at least without some semi-major hacking to get around the compiler complaining about it). What I did there was I said that MaxAmount will be constant. I don't intend it to change for its entire scope. I like to think about that as "Intent Programming". I program my intentions into the code. No comment is required. I don't need to say "// MaxAmount shouldn't change". The compiler will enforce the const-correctness for me.

What that also means is that when I get moved off the project and someone else comes on to maintain the code, my intentions will still be enforced. The compiler will enforce them and will protect that variable from accidental or even intentional modification. If the new guy doesn't see MaxAmount being used at the end of the function, he may decide that it's safe to change it. He may decide to re-purpose it it in the middle of that function around the "do some more stuff" section in my example. In C++, the compiler will prevent this. In C#, there's no way to do this. Declaring a variable as 'static readonly' will accomplish this for static variables, but for local variables it just ain't gonna happen.

This is also why I love the 'using' keyword in C#. I have heard that it was tacked on as an afterthought when designing C#, but I love it nonetheless. It allows you to do stuff like:

public void DoDotNetStuff()
{
    .
    .
    .
    using (System.IO.Stream stream = wc.OpenRead(url))
    {
        avatar = image.FromStream(stream);
        stream.Close();
    }
    // can't use stream over here
    .
    .
    .
}

Outside of the using block, stream is out of scope. It's the same as declaring it inside its own scope. You try to use it outside the using block and:

error CS0103: The name 'stream' does not exist in the current context

As long as System.IO.Stream implements IDisposable, you can exactly control the lifetime of your variable and you don't even have to bother messing with the Dispose method. Your variable is scoped, disposed and garbage collected all in one neat and tidy package. You programmed your intent for the usage of that variable right there in the code itself. No comments required.

Sometimes this is called 'Self Documenting Code'. I tend to think of Self Documenting Code as a style of code organization and a usage of long names to describe what the code is doing. With intent programming, you're using the features of the language itself to help declare your intent.

]]> Wed, 16 Jul 2008 04:20:32 -0700 http://virb.com/mike6024/posts/text/721472 http://virb.com/mike6024/posts/text/685244 I was called out by Dan Rigsby to do this, so here she goes:

1. How old were you when you started programming?

   I believe I was 12 or 13.

2. How did you get started in programming?

   I remember learning some BASIC in school in either 6th or 7th grade. Ya know, you draw a blocky gun and make it fire a one pixel bullet across the screen. I remember that being pretty fun. Also, right around the same time I started playing with QBASIC at home.

3. What was your first language?

   BASIC/QBASIC

4. What was the first real program you wrote?

   Not counting school, the first real program I wrote was a spaghetti code version (chock full of GOTO's) of a Choose Your Own Adventure book.

5. What languages have you used since you started programming?

   BASIC, QBASIC, C, C++, MIPS Assembly Language, VB, ADA, Java, C#, ASP.NET, Javascript

6. What was your first professional programming gig?

   I was a lab TA for the CS101 Java course at Purdue, so that was my first job involving programming, but my first job actually programming was at Raytheon. I worked there for six years before coming to Interactive Intelligence in 2006. At Raytheon, I worked on various project for the Army and Navy involving mortar aiming applications, handheld applications, route planning applications for helicopters and many other things. If I tell you anymore I'd have to kill you.

7. If you knew then what you know now, would you have started programming?

   Definitely. Whenever I get asked what my dream job would be I always reply that it would be doing what I'm doing now (programming) or touring in a band. I deeply enjoy them both. But I must admit that programming for myself and writing whatever I want to write at the time would definitely be better than the maintenance programming I sometimes still have to do.

8. If there is one thing you learned along the way that you would tell new developers, what would it be?

   Don't waste time. I can think of numerous times in college and after college that I just screwed around and did other things when I could have been honing my skills more and keeping myself up to date. I'm trying to get myself back up to date now and it would have been easier if I had just spent the time after college to do so.

9. What's the most fun you've ever had ... programming?

   I love programming for fun. Right now, my extracurricular programming activity is writing Bitter a Twitter/social networking client. In my spare time, I've also written a chat program, an email application, an account/password manager, an RSS aggregator and several Pocket PC applications including a file explorer, an RSS aggregator, a network scanner, and various other tools. I just find it a great way to learn and to me it's extremely fun.

10. Who are you calling out?

    I want to call some fellow bloggers and non-bloggers alike (to see if they'll actually start):

    • Aaron Lerch
    • Scott Bauer
    • Jeff Moser
    • Kyle Brown
    • Jake Robinson
    • Evan Byl
    • Brian McGreer
    • Todd Zerbe

]]> Wed, 25 Jun 2008 10:51:31 -0700 http://virb.com/mike6024/posts/text/685244 http://virb.com/mike6024/posts/text/676255

I conducted an initial test run of a card sort today for my Twitter client Bitter. A card sort is a usability technique in which you hold sessions with potential users of your application and you, well, have them sort cards. Each card will contain a label used in your application. In an open card sort, the users will create groupings of cards themselves and name each grouping. In a closed card sort, the users will group the cards into the group names you provide them.

If your application is a web site, a card sort could help you organize the pages and links that belong under each section for your site's navigation. If your application is a traditional desktop app, a card sort could help you organize the menu items under a top level menu. For my card sort, I used the labels from my options dialog (and even some potential future labels I plan to add) and had the user sort them.

I expected to end the card sort session with several groupings and have a better idea of how others may view the labels. I did indeed end up with that, but discovered several other things in the process that I didn't expect. There were a couple assumptions I had made about how the options were to be used with the currently logged in user and the card sort showed me that those assumptions may not necessarily be made by other users.

Another thing I found was that you need to carefully think about and decide what to put on your cards. You have the choice of simply putting the label on the card, or you can put the label and a description of the label on each card. If you put just the label, then you'll likely have the same problem as me of context-sensitive labels. For example, I have some labels named "New Tweets", "New Replies" and "Sent Direct Message" among others. By themselves, you aren't quite sure what they refer to, but once you see them grouped under the "Sounds" section it becomes more obvious. So should the cards stay pure and say precisely what the label will say in the application or should you muck with your independent variables and change the cards to include context like "New Tweets Sound"? That's something you need to weigh the pros and cons of and determine for yourself and also probably consider when analyzing the results of the card sort.

Also, let your participant talk during the session. Let them ask questions. All this is valuable information. You can then ask yourself why the participant said this or that or why they asked what a certain card meant. You may think the answer is obvious, but maybe it's not. But if they do ask you what a specific card means, ask them what they think it means. That's yet more valuable information.

It's also a good idea to video record the whole thing. It's impossible to take notes and get everything during the session. Also sometimes you'll see things on the recording that you didn't see during the session. Just make sure you get permission first.

Overall, even though this was just an initial test run of a card sort, I can already see the benefits. I did this run through to see what works and what doesn't work and now have a pretty good idea. If you are writing an application whether in your own free time or professionally, a card sort is a good idea. It doesn't even have to be formal. Asking a coworker to take a few minutes and come over to your office for a quick card sort would work fine. Often times we just get so close to our applications, that we lost perspective. We get tunnel vision on how it'll be used and how things will be used and interpreted. A card sort is simply a tool to get other perspectives and to rid yourself of tunnel vision.

]]> Fri, 20 Jun 2008 12:51:35 -0700 http://virb.com/mike6024/posts/text/676255