• The Old New Thing

    User interface design for interior door locks

    • 75 Comments

    How hard can it be to design the user interface of an interior door lock?

    Locking or unlocking the door from the inside is typically done with a latch that you turn. Often, the latch handle is in the shape of a bar that turns.

    Now, there are two possible ways you can set up your lock. One is that the a horizontal bar represents the locked position and a vertical bar represents the unlocked position. The other is to have a horizontal bar represent the unlocked position and a vertical bar represent the locked position.

    For some reason, it seems that most lock designers went for the latter interpretation. A horizontal bar means unlocked.

    This is wrong.

    Think about what the bar represents. When the deadbolt is locked, a horizontal bar extends from the door into the door jamb. Clearly, the horizontal bar position should recapitulate the horizontal position of the deadbolt. It also resonates with the old-fashioned way of locking a door by placing a wooden or metal bar horizontally across the face. (Does no one say "bar the door" any more?)

    Car doors even followed this convention, back when car door locks were little knobs that popped up and down. The up position represented the removal of the imaginary deadbolt from the door/jamb interface. Pushing the button down was conceptually the same as sliding the deadbolt into the locked position.

    But now, many car door locks don't use knobs. Instead, they use rocker switches. (Forwards means lock. Or is it backwards? What is the intuition there?) The visual indicator of the door lock is a red dot. But what does it mean? Red clearly means "danger", so is it more dangerous to have a locked door or an unlocked door? I can never remember; I always have to tug on the door handle.

    (Horizontally-mounted power window switches have the same problem. Does pushing the switch forwards raise the window or lower it?)

  • The Old New Thing

    User interface design for vending machines - answer to puzzle

    • 38 Comments

    Last time, we ended a discussion of vending machine design with a short puzzle: What problems do you see with numbering the products from 1 to 99?

    I'm not saying that these are the only possible answers, but they are ones that came to mind when I thought about it.

    • Product codes less than 10 would be ambiguous. Is a "3" a request for product number 3, or is the user just being slow at entering "32"? Solving this by adding a leading zero will not work because people are in the habit of ignoring leading zeros.
    • Product codes should not coincide with product prices. If there is a bag of cookies that costs 75 cents, users are likely to type "75" when they want the cookies, even though the product code for the cookies is 23.

    Ilya Birman was the first to point out the "bounce-effect" problem, thereby ruling out product codes like 11, 22, and 33.

  • The Old New Thing

    User interface design for vending machines

    • 75 Comments

    How hard can it be to design the user interface of a vending machine?

    You accept money, you have some buttons, the user pushes the button, they get their product and their change.

    At least in the United States, many vending machines arrange their product in rows and columns (close-up view). To select a product, you type the letter of the row and the number of the column. Could it be any simpler?

    Take a closer look at that vending machine design. Do you see the flaw?

    (Ignore the fact that the picture is a mock-up and repeats row C over and over again.)

    The columns are labelled 1 through 10. That means that if you want to buy product C10, you have to push the buttons "C" and "10". But in our modern keyboard-based world, there is no "10" key. Instead, people type "1" followed by "0".

    What happens if you type "C"+"1"+"0"? After you type the "1", product C1 drops. Then you realize that there is no "0" key. And you bought the wrong product.

    This is not a purely theoretical problem. I have seen this happen myself.

    How would you fix this?

    One solution is simply not to put so many items on a single row, considering that people have difficulty making decisions if given too many options. On the other hand, the vendor might not like that design, since their goal is to maximize the number of products.

    Another solution is to change the labels so that there are no items where the number of button presses needed do not match the number of characters in the label. In other words, no buttons with two characters on them (like the "10" button).

    Switch the rows and columns, so that the products are labelled "1A" through "1J" across the top row, and "9A" through "9J" across the bottom. This assumes you don't have more than nine rows. (This won't work for super size vending machines - look at the buttons on that thing; they go up to "U"!

    You can see another solution in that most recent vending machine: Instead of calling the tenth column "10", call it "0". Notice that they also removed rows "I" and "O" to avoid possible confusion with "1" and "0".

    A colleague of mine pointed out that some vending machines use numeric codes for all items rather than a letter and a digit. For example, if the cookies are product number 23, you punch "2" "3". If you want the chewing gum (product code 71), you punch "7" "1". He poses the following question:

    What are some problems with having your products numbered from 1 to 99?

    Answers next time.

  • The Old New Thing

    Marriage as a cross-branding opportunity

    • 10 Comments

    Jennifer Aniston and Brad Pitt have decided to besmirch the institution of marriage by deciding that the "until death do us part" thing was neither legally nor morally binding.

    "Brad said that they spent the rest of the holiday working out how they would release the news of the split. They worked out together the reasons they would give and how they would protect the brand they have built up."

    Oh, nevermind. This wasn't a marriage. It was a joint branding agreement!

    My favorite Brad/Jennifer memory was when cardiologist Robert Atkins, famous for his eponymous low-carb diet, suffered a fatal head injury, and the BBC news report was illustrated with a picture of... Brad Pitt and Jennifer Aniston.

  • The Old New Thing

    Why doesn't \\ autocomplete to all the computers on the network?

    • 63 Comments

    Wes Haggard wishes that \\ would autocomplete to all the computers on the network. [Link fixed 10am.] An early beta of Windows 95 actually did something similar to this, showing all the computers on the network when you opened the Network Neighborhood folder. And the feature was quickly killed.

    Why?

    Corporations with large networks were having conniptions because needlessly enumerating all the machines on the network can bring a large network to its knees. Think about all the times you type "\\". Now imagine if every single time you did that, Explorer started enumerating all the machines on the network. And imagine how your network administrator would feel if their network traffic saturated with enumerations each time you did that.

    Network administrators made it clear in no uncertain terms that having Windows casually enumerate all the machines on their LAN was totally unacceptable.

    The needs of the corporate environment are very different from those of the home network, and Windows needs to operate in both worlds.

  • The Old New Thing

    Seattle Snowstorm 2005 (insert swooshy sound effect)

    • 50 Comments

    As others have reported, it snowed here in the Seattle area yesterday.

    One whopping inch.

    You'd think that Seattle, which gets snow a few times a year, wouldn't go completely apoplectic the moment the flakes starts falling from the sky. Especially since it all melts away in a few hours anyway.

    I didn't watch the local news last night, but I suspect it went something like this:

    Cold Open (3 minutes): LIVE REPORT FROM SEATTLE WHERE YES I THINK I CAN SEE SOME SNOW THAT HASN'T YET MELTED BUT IT COULD JUST BE FOAM FROM A SPILT LATTE.

    Custom "SNOWSTORM 2005" graphic title sequence with extra special focus on the weatherman (45 seconds)

    Lead story (5 minutes): SNOWSTORM 2005 HAS STRUCK THE NORTHWEST WITH A VENGEANCE. WE WILL GO TO A LIVE REPORT FROM <Reporter X> IN BALLARD.

    Reporter X: "Snow is white fluffly stuff that falls from the sky. It happens rarely here in the Northwest, but some parts of the country get it a lot. And here's some science trivia you can try at your next cocktail party: Snow is actually just frozen water!"

    Reporter X and anchors do some Q&A like, "Is it safe to eat snow?" and "This snowfall has been predicted for days; do you think anxiety over the coming storm affected the Seahawks' performance on Saturday?"

    Throughout, a crawl at the bottom of the screen provides critical information like "Wear sturdy boots when walking in snow."

    "STAY TUNED, COVERAGE OF SNOWSTORM 2005 WILL CONTINUE AFTER A SHORT BREAK."

    Commercial (2 minutes)

    Second story (5 minutes): COVERAGE OF SNOWSTORM 2005 CONTINUES WITH A LIVE REPORT FROM <Reporter Y> IN ISSAQUAH.

    Reporter Y: "Yes, there were reports of snow being spotted as far away as Issaquah. I'm standing here with Gladys Wilkins who claims she saw some snow as early as 7:30 today."

    Interview with Ms. Wilkins.

    Anchors banter with Reporter Y saying things like, "Gosh, I hope you've got your shovels ready."

    Commercial (2 minutes)

    Third story (5 minutes) Continuing coverage of Snowstorm 2005 with footage from the last snowstorm, driving tips ("be careful when driving, because snow is slippery"), cold weather tips ("try wearing a sweater to stay warm").

    Commercial (2 minutes)

    Weather report (4 minutes): Weatherman talks about snow and shows you so many Doppler radar graphs it'll make your head spin. He doesn't actually say anything useful, but it's fun to hear phrases like "the Fraser Valley effect" and "a weakening area of low pressure".

    Commercial (2 minutes)

    In Other News (10 seconds): Police chief's gun stolen, how to get great deals at post-holiday sales, and bunny rabbits.

    Close titles (5 seconds).

  • The Old New Thing

    Taskbar notification balloon tips don't penalize you for being away from the keyboard

    • 70 Comments

    The Shell_NotifyIcon function is used to do various things, among them, displaying a balloon tip to the user. As discussed in the documentation for the NOTIFYICONDATA structure, the uTimeout member specifies how long the balloon should be displayed.

    But what if the user is not at the computer when you display your balloon? After 30 seconds, the balloon will time out, and the user will have missed your important message!

    Never fear. The taskbar keeps track of whether the user is using the computer (with the help of the GetLastInputInfo function) and doesn't "run the clock" if it appears that the user isn't there. You will get your 30 seconds of "face time" with the user.

    But what if you want to time out your message even if the user isn't there?

    You actually have the information available to you to solve this puzzle on the web pages I linked above. See if you can put the pieces together and come up with a better solution than simulating a click on the balloon. (Hint: Look carefully at what it means if you set your balloon text to an empty string.)

    And what if you want your message to stay on the screen longer than 30 seconds?

    You can't. The notification area enforces a 30 second limit for any single balloon. Because if they user hasn't done anything about it for 30 seconds, they probably aren't interested. If your message is so critical that the user shouldn't be allowed to ignore it, then don't use a notification balloon. Notification balloons are for non-critical transient messages to the user.

  • The Old New Thing

    How can code that tries to prevent a buffer overflow end up causing one?

    • 65 Comments

    If you read your language specification, you'll find that the ...ncpy functions have extremely strange semantics.

    The strncpy function copies the initial count characters of strSource to strDest and returns strDest. If count is less than or equal to the length of strSource, a null character is not appended automatically to the copied string. If count is greater than the length of strSource, the destination string is padded with null characters up to length count.

    In pictures, here's what happens in various string copying scenarios.

    strncpy(strDest, strSrc, 5)
    strSource
    W e l c o m e \0
    strDest
    W e l c o
    observe no null terminator
     
    strncpy(strDest, strSrc, 5)
    strSource
    H e l l o \0
    strDest
    H e l l o
    observe no null terminator
     
    strncpy(strDest, strSrc, 5)
    strSource
    H i \0
    strDest
    H i \0 \0 \0
    observe null padding to end of strDest

    Why do these functions have such strange behavior?

    Go back to the early days of UNIX. Personally, I only go back as far as System V. In System V, file names could be up to 14 characters long. Anything longer was truncated to 14. And the field for storing the file name was exactly 14 characters. Not 15. The null terminator was implied. This saved one byte.

    Here are some file names and their corresponding directory entries:

    passwd
    p a s s w d \0 \0 \0 \0 \0 \0 \0 \0
    newsgroups.old
    n e w s g r o u p s . o l d
    newsgroups.old.backup
    n e w s g r o u p s . o l d

    Notice that newsgroups.old and newsgroups.old.backup are actually the same file name, due to truncation. The too-long name was silently truncated; no error was raised. This has historically been the source of unintended data loss bugs.

    The strncpy function was used by the file system to store the file name into the directory entry. This explains one part of the odd behavior of strcpy, namely why it does not null-terminate when the destination fills. The null terminator was implied by the end of the array. (It also explains the silent file name truncation behavior.)

    But why null-pad short file names?

    Because that makes scanning for file names faster. If you guarantee that all the "garbage bytes" are null, then you can use memcmp to compare them.

    For compatibility reasons, the C language committee decided to carry forward this quirky behavior of strncpy.

    So what about the title of this entry? How did code that tried to prevent a buffer overflow end up causing one?

    Here's one example. (Sadly I don't read Japanese, so I am operating only from the code.) Observe that it uses _tcsncpy to fill the lpstrFile and lpstrFileTitle, being careful not to overflow the buffers. That's great, but it also leaves off the null terminator if the string is too long. The caller may very well copy the result out of that buffer to a second buffer. But the lstrFile buffer lacks a proper null terminator and therefore exceeds the length the caller specified. Result: Second buffer overflows.

    Here's another example. Observe that the function uses _tcsncpy to copy the result into the output buffer. This author was mindful of the quirky behavior of the strncpy family of functions and manually slapped a null terminator in at the end of the buffer.

    But what if ccTextMax = 0? Then the attempt to force a null terminator dereferences past the beginning of the array and corrupts a random character.

    What's the conclusion of all this? Personally, my conclusion is simply to avoid strncpy and all its friends if you are dealing with null-terminated strings. Despite the "str" in the name, these functions do not produce null-terminated strings. They convert a null-terminated string into a raw character buffer. Using them where a null-terminated string is expected as the second buffer is plain wrong. Not only do you fail to get proper null termination if the source is too long, but if the source is short you get unnecessary null padding.

  • The Old New Thing

    A rant against flow control macros

    • 53 Comments

    I try not to rant, but it happens sometimes. This time, I'm ranting on purpose: to complain about macro-izing flow control.

    No two people use the same macros, and when you see code that uses them you have to go dig through header files to figure out what they do.

    This is particularly gruesome when you're trying to debug a problem with some code that somebody else wrote. For example, say you see a critical section entered and you want to make sure that all code paths out of the function release the critical section. It would normally be as simple as searching for "return" and "goto" inside the function body, but if the author of the program hid those operations behind macros, you would miss them.

    HRESULT SomeFunction(Block *p)
    {
     HRESULT hr;
     EnterCriticalSection(&g_cs);
     VALIDATE_BLOCK(p);
     MUST_SUCCEED(p->DoSomething());
     if (andSomethingElse) {
      LeaveCriticalSection(&g_cs);
      TRAP_FAILURE(p->DoSomethingElse());
      EnterCriticalSection(&g_cs);
     }
     hr = p->DoSomethingAgain();
    Cleanup:
     LeaveCriticalSection(&g_cs);
     return hr;
    }
    

    [Update: Fixed missing parenthesis in code that was never meant to be compiled anyway. Some people are so picky. - 10:30am]

    Is the critical section leaked? What happens if the BLOCK fails to validate? If DoSomethingElse fails, does DoSomethingAgain get called? What's with that unused "Cleanup" label? Is there a code path that leaves the "hr" variable uninitialized?

    You won't know until you go dig up the header file that defined the VALIDATE_BLOCK, TRAP_FAILURE, and MUST_SUCCEED macros.

    (Yes, the critical section question could be avoided by using a lock object with destructor, but that's not my point. Note also that this function temporarily exits the critical section. Most lock objects don't support that sort of thing, though it isn't usually that hard to add, at the cost of a member variable.)

    When you create a flow-control macro, you're modifying the language. When I fire up an editor on a file whose name ends in ".cpp" I expect that what I see will be C++ and not some strange dialect that strongly resembles C++ except in the places where it doesn't. (For this reason, I'm pleased that C# doesn't support macros.)

    People who still prefer flow-control macros should be sentenced to maintaining the original Bourne shell. Here's a fragment:

    ADDRESS	alloc(nbytes)
        POS	    nbytes;
    {
        REG POS	rbytes = round(nbytes+BYTESPERWORD,BYTESPERWORD);
    
        LOOP    INT	    c=0;
    	REG BLKPTR  p = blokp;
    	REG BLKPTR  q;
    	REP IF !busy(p)
    	    THEN    WHILE !busy(q = p->word) DO p->word = q->word OD
    		IF ADR(q)-ADR(p) >= rbytes
    		THEN	blokp = BLK(ADR(p)+rbytes);
    		    IF q > blokp
    		    THEN    blokp->word = p->word;
    		    FI
    		    p->word=BLK(Rcheat(blokp)|BUSY);
    		    return(ADR(p+1));
    		FI
    	    FI
    	    q = p; p = BLK(Rcheat(p->word)&~BUSY);
    	PER p>q ORF (c++)==0 DONE
    	addblok(rbytes);
        POOL
    }
    

    Back in its day, this code was held up as an example of "death by macros", code that relied so heavily on macros that nobody could understand it. What's scary is that by today's standards, it's quite tame.

    (This rant is a variation on one of my earlier rants, if you think about it. Exceptions are a form of nonlocal control flow.)

  • The Old New Thing

    PulseEvent is fundamentally flawed

    • 44 Comments

    The PulseEvent function releases one thread (or all threads, if manual-reset) which is/are waiting for the pulsed event, then returns the event to the unset state. If no threads happen to be waiting, then the event goes to the unset state without anything happening.

    And there's the flaw.

    How do you know whether the thread that you think is waiting on the event really is? Surely you can't use something like

    SignalSemaphore(hOtherSemaphore);
    WaitForSingleObject(hEvent, INFINITE);
    

    because there is a race between the signal and the wait. The thread that the semaphore is alerting might complete all its work and pulse the event before you get around to waiting for it.

    You can try using the SignalObjectAndWait function, which combines the signal and wait into a single operation. But even then, you can't be sure that the thread is waiting for the event at the moment of the pulse.

    While the thread is sitting waiting for the event, a device driver or part of the kernel itself might ask to borrow the thread to do some processing (by means of a "kernel-mode APC"). During that time, the thread is not in the wait state. (It's being used by the device driver.) If the PulseEvent happens while the thread is being "borrowed", then it will not be woken from the wait, because the PulseEvent function wakes only threads that were waiting at the time the PulseEvent occurs.

    Not only are you (as a user-mode program) unable to prevent kernel mode from doing this to your thread, you cannot even detect that it has occurred.

    (One place where you are likely to see this sort of thing happening is if you have the debugger attached to the process, since the debugger does things like suspend and resume threads, which result in kernel APCs.)

    As a result, the PulseEvent function is useless and should be avoided. It continues to exist solely for backwards compatibility.

    Sidebar: This whole business with kernel APCs also means that you cannot predict which thread will be woken when you signal a semaphore, an auto-reset event, or some other synchronization object that releases a single thread when signalled. If a thread is "borrowed" to service a kernel APC, then when it is returned to the wait list, it "goes back to the end of the line". Consequently, the order of objects waiting for a kernel object is unpredictable and cannot be relied upon.

Page 378 of 441 (4,404 items) «376377378379380»