Time Waster of the Day: Google Scribe the latest whatchamacallit from those future robot uprising apologists at Google Labs takes the guess work out of thinking by autocompleting not just the word you are presently working on, but every single word that follows.

Surely, this is the beginning of the end for us all, but, in the meantime, why not waste a minute or two getting it to write grammatically correct nonsense you can slip into your next TPS report to see if your boss even reads them. (Spoiler Alert: He/she doesn't.)

[gizmodo.]

Fearmongering of the Day: The TSA's latest see-something-say-something scarexploitation poster appears to equate harmless aircraft spotting a hobby as old as the technology itself and that was once encouraged by the government with terrorist activity.

Flawless logic, as usual.

[gizmodo.]

Mistakes are made every day in the design and development world. It's nothing to be ashamed of; it happens. In fact, mistakes are one of the most powerful learning tools at our disposal. Our mistakes impart important lessons that we carry with us as we continue to hone our skill set. Own your mistakes. Never shy away from them; they are the milestones in our development.

So often we view mistakes negatively and let them get us down. We believe they indicate failure and that our otherwise perfect record will be forever marred. No one is perfect; we all make mistakes. They indicate failure only if we fail to learn from them.

How often have you stayed late, trying to get something done and did some embarrassing mistake instead? We can learn from our mistakes and mistakes of our colleagues. Image credit

The online design and development community is a wonderful resource in this respect. Not only are members open about their mistakes, they share their experiences as learning opportunities for others this is helpful for those of us who have not yet suffered through the same bumps in the road.

With this in mind, we turned again to our Twitter followers and Facebook fans to find out about the worst design or programming mistakes they have ever made. Now we share them with you, our readers, so that we can all learn from them and avoid making the same mistakes.

Related Posts

• 9 Common Usability Mistakes in Web Design is a useful post that covers some common mistakes made when designing for the Web.
• Speaking of common mistakes, here is another entry from our archive that lets you in on some problems faced by e-commerce designers: 15 Common Mistakes in E-Commerce Design.

[Offtopic: by the way, did you know that we are publishing a Smashing eBook Series? The brand new eBook #3 is Mastering Photoshop For Web Design, written by our Photoshop-expert Thomas Giannattasio.]

Bait And Switch

The first common mistake we should learn from and which several of our followers have had to face is the old bait and switch. It occurs across the spectrum, for the newb and the accomplished professional, because it's an easy mistake to make as the working hours add up. What is the bait and switch? It happens when you're working on one version of a website or project and, at some point during the tinkering, you accidentally switch it for the active website or project before it's ready.

When we're in a constant back-and-forth workflow, getting mixed up is easy, at which point the bait and switch can happen. And it causes all kinds of chaos and headaches. Awareness and caution are needed to prevent this error from being part of your personal experience. Before you finalize changes or processes, be sure you're working with the right file and uploading to the correct location. This isn't a sure-fire prevention plan, but it will certainly improve your chances.

What Our Followers Said

• I accidentally put a half-finished (with massive broken bits) update of a website over top of the current live one without a back-up.
• I sent $10,000 worth of product to a customer while testing an ordering portal.
• I deleted an actual repository instead of a working copy. #svn
• Worst programming mistake: editing off a live server and then uploading an old version of the website. All files lost!
• Sat on the development FTP for half an hour, being mad that the live website wouldn't update!
• Moved the entire directory of websites on a live server into a different folder, then lost it or deleted the in-house CMS
• Programming mistake: writing data to the wrong database.
• Uploading to the dev website FTP and wondering why the live website wasn't changing, which sent me around the bend in the process!

Falling Behind On Back-Ups

Given that back-up-related mistakes usually come to light once you realize you've just pulled a bait and switch, we'll tackle these next. Problems with back-up files are common in the design and development community, and they are openly lamented. For some reason, though, many of us still find ourselves panicked when we realize we have no current back-ups of the project we're working on. And it usually hits us just after we lose the active version of the project and need it replaced.

We can take steps to save elements of our work and prevent episodes like this from becoming remorseful blog posts. You can be either low-tech or high-tech when you address this potential problem, but you need to do something. It could be as simple as making a list of details to check daily, and backing up data could be the final step. Alternatively, you could pay for an automated back-up service that guarantees completion of the task. There are several options, each with pros and cons, so find one that works for you and implement it post-haste.

What Our Followers Said

• I moved a dynamic, CMS-contained website across to a new server. Forgot to back up, then deleted templates in the process. D'oh!
• Mistake: not backing up a compiled Flash slideshow, replacing it, then realizing the new version was completely broken.

Measure Once, Cut Twice

The next mistake we'll cover happens fairly often. For any number of reasons, we end up measuring once and cutting twice, so to speak. The measurements we work with vary greatly from project to project and from Web to print, so we need to be alert to what we are sizing and aiming for. Sometimes it isn't so much the measurements as it is the content that requires a re-cut.

Often calculations, measurements and the concept phase need more time than expected. Turning off the computer and getting back to the sketch board or a notebook is often very useful to avoid mistakes. Image credit

Chalk it up to being overzealous or getting sloppy in our work as we push toward deadlines. If these are the reasons for our re-cuts, prevention is easy: just avoid those things which is easier said than done. Still, if we mind our p's and q's and double-check everything before submitting it, our chances of embarrassment decrease. Follow the carpenter's old rule of thumb, Measure twice, cut once it benefits us designers and developers, too.

What Our Followers Said

• Mistake: having 20,000 cards printed that didn't fit into a lanyard card holder
• Got my colleague's phone number wrong on her business card We ordered 2,000.
• This isn't really a programming mistake, but the most embarrassing mistake I've made in Web design was buying a domain name that had the client's name in it but part of the name was wrong. Good thing domains are cheap!
• I managed to drop an m' off millimeters' in InDesign. Ended up with an 88-meter-wide business card. Schoolboy!
• I think most of us have experienced the horror of hitting Send' on an e-blast, only to quickly realize it's wrong.
• Mistake: when I post something and then two weeks later or more, I find out something's wrong with it.
• A couple of years back, I made a beginner's design mistake with print: envelopes and paper didn't match.
• Sent PDF to the printing house for 1000 leaflets. Received them and realized that the phone number was wrong. Then, sent corrected PDF, received leaflets and realized that the wrong PDF was sent. We had 1000 useless leaflets with the right number but with the iStockphoto' watermark on every (lo-res) picture. Third time it was OK.
• I dropped an L' from the word public' in a school prospectus (and website). Honest mistake!

Miscommunicate Expectations

Another problem encountered by designers and developers that you can learn from before encountering it is a breakdown of communication with a client or boss. Many of us let things become unclear or slip by, which makes us unsure whether everyone involved in a project is on the same page. Usually this is caused by a lack of confidence in ourselves or fear that asking for clarification would reflect poorly on us. Whatever the reason, we decide not to revisit the issue and instead proceed with a shaky understanding of what we're supposed to do.

Every time we communicate with our boss or client, we open ourselves up to the possibility that one or two ideas might get lost in translation. We should be as clear and concise as possible in our discussions so that work stays on track at least on our end we can't control others. If we're dealing with someone who is unfamiliar with the design and development field, understanding what they're asking for can be tricky. Take notes, and go over them with clients at the end of meetings so that everyone understands where things stand. Good notes prevent communication blunders.

What Our Followers Said

• I underestimated the amount of content that two different clients wanted. Not a clear picture from the start.
• For my part, I must say, not reading a ticket well enough and spending two days coding something that wasn't asked for. Over-enthusiastic FTW!
• Emily Buck: My mistake was telling my current employer than I have some experience in Web design (meaning HTML and some CSS); now it's part of my job to learn how to code ASP and maintain and redesign our entire e-commerce website. Ugh. I'm a print designer!
• I'm in the same situation as Emily. Job description and interview included some Web,' and now I'm trying to learn PHP and run a full searchable retailer list for my company! Thank God for online tutorials!

Careless Coding

When it comes to coding, we can easily drop the ball. Coding is an in-depth process, in which many different layers are stacked on top of each other, and one can get lost in it. This is one reason why developers comment in their code: so that they leave trails of breadcrumbs throughout their projects. This is a good habit to form, but sometimes it leads to an embarrassing faux pas or frustrating hours of rebuilding, as revealed by our followers.

With just one misfired keystroke, a project can go from a coder's dream to a virtual nightmare, with no perceptible way out. As if that's not enough, our coding comments can bite us in the back end, especially if we've thrown some nonsensical, fun or unprofessional bits into the code and forgot to remove them. We need to be mindful as we code and avoid distractions as much as possible to avoid burying mistakes so deep that they reveal themselves only after hours of careful combing. Also, take one last look through your comments to be sure you're not leaving something that you'd rather others not see.

What Our Followers Said

• I left some profanity in a client's HTML once while testing text-indent (off-screen position). Very, very embarrassing.
• Accidentally leaving things like Mooooo' and Baaaaa' in code that has gone live!
• I used to write haiku in my code to mark my place, and I think I forgot a few out there somewhere not anymore!
• I once did (as root) `rm -rf tmp /` instead of `rm -rf tmp/` on a Friday afternoon. Painful weekend.
• A typical one: Using = instead of == in an if statement. Always takes quite some time to figure out.
• Typed rm -rf .* on the server. @wsttn wasn't happy when I deleted everything.
• Using a body * { text-align: center; } on a log-in form, but accidentally placing it in the default style sheet instead of the specific log-in style sheet. Our largest customer didn't like it when it went live.
• I removed the ID from the Submit payment' button, and the website failed to take bookings for six hours. Lost 20,000.
• Forgot the where clause when testing SQL to a user table. No fun, I tell ya!

Forgetting The Filler

Sometimes we forget to redact our coding comments and leave in an embarrassing tidbit or two. There are also times when we accidentally leave in filler content. That's not necessarily a problem unless the client does not recognize it as filler, because then they might not remove it either. Remember that clients, especially the less technically savvy ones, are probably extremely paranoid about deleting anything, so any filler you forget to pull will inevitably be published to the masses.

Again, it comes down to vigilance. We can't stress enough on top of all the other stresses in the design and development field the importance of double- and triple-checking all of these elements before labeling anything as complete. Certainly do this before turning anything over to the client. Making a generic checklist for every project you take on will help you avoid these mistakes. Remind yourself somehow to watch for elements that tend to slip through the cracks.

What Our Followers Said

• Forgetting to remove nonsense words (used for testing) in an assignment and losing marks. Otherwise, perfect code.
• Two words: dummy data. Strictly Lorem Ipsum' ever since.
• One time I left an unkind phrase about a client in the comments, and they found it later on.

Wrong Tool For The Job

The last mistake we'll discuss in depth usually occurs early on in our experience in the design and development field: using the wrong tool for the job. It does happen, and more often than we'd like. When you're unfamiliar with a field, you'll sometimes use the wrong platform yet believe you're on solid ground. At some point, you find out that the program, a supposed godsend, is not compatible with your client's program or the program of others involved in the project.

Wrong tools doesn't necessarily mean your coding or designing applications, it also can mean a wrong environment or computer setup. On the photo above, the setup looks solid and well-organized. Image credit.

Communication can assist in this area, though not as much as research. Find out from your client exactly where the project is going, and contact them yourself to ensure that files will be delivered in the proper format. You can leave this to the client, but you are responsible for ensuring compatibility, so it's best not to leave it to someone else. Also, as you transition to new areas, research the tools of the trade to avoid making this mistake.

What Our Followers Said

• I tried to deliver my very first program for Notts County FC to the printers in MS Publisher. I cringe even now.
• The first Photoshop website I ever did was a sliced PSD with all of the content in images That was back in 1999/2000.
• Using Drupal to do quick 'n' dirty' websites. They were dirty, but they sure weren't quick.
• Designing a database app: rather than de-normalizing data, adding/removing table columns on the fly. Long time ago!
• Hard-coding a navigation across 10 pages instead of using an include. Was new to Web dev at the time.
• Depending on an external source for data and, because that crashed, our website crashed. Almost cost me my job.

More Mistakes To Learn From

Below are several more community-contributed pearls of wisdom that we can learn from. We'd like to thank our dedicated followers who revealed their biggest mistakes so that we could benefit from their toil and trouble.

• Mistake: severely undercharging for a massive job. My very first freelancing job. Was not worth the time and effort!
• There was a time in the '90s when I thought Papyrus was beautiful. *Hangs head in shame*
• I once created an iteration of a logo using Comic Sans, and it was chosen! I'm not proud, but I was young and naive at the time.
• Used Comic Sans for something serious.
• How about 90,000 alert emails sent to four people over one weekend (myself, a colleague and website owners) = 360,000 emails.
• Deleted the shopping cart table from a live website instead of deleting one of the records in the table.
• The worst programming mistake I made was to develop an admin area with cookies only (without other security systems).

Further Reading

Here are a few relevant articles you might want to check out. Definitely worth reading if and when you get the chance.

• 43 Web Design Mistakes You Should Avoid
  An article from Daily Blog Tips that identifies dozens of mistakes that designers make, so you can avoid them.
• The 10 Most Common Mistakes Web Designers Make
  A helpful post from the Smashing Network via our sister website Noupe.
• 10 Mistakes Freelance Graphic Designers Make When Starting Out
  This useful post from WAHM targets beginners.
• The Top 12 SEO Mistakes Designers Make
  Another informative post that teaches by walking you through the mistakes of others.
• Top Mistakes New Designers Make When Learning Graphic Design
  Graphic Design Blogs' post for beginners to help them steer clear of certain mistakes while learning.

What about you?

What is the worst design or programming mistake you've ever made? And if you'd like to participate in other discussions and contribute to articles like this one, follow us on Twitter and like us on Facebook. Thank you.

(al)

Robert Bowen for Smashing Magazine, 2010. | Permalink | Post a comment | Add to del.icio.us | Digg this | Stumble on StumbleUpon! | Tweet it! | Submit to Reddit | Forum Smashing Magazine
Post tags:

EVERY age, every race, has its leaders and heroes. There were over sixty distinct tribes of Indians on this continent, each of which boasted its notable men. The names and deeds of some of these men will live in American history, yet in the true sense they are unknown, because misunderstood. I should like to present some of the greatest chiefs of modern times in the light of the native character and ideals, believing that the American people will gladly do them tardy justice. (Summary from the text)

Filed under: DC, Interviews

Permalink | Email this | Linking Blogs | Comments

The Agile community (to the degree that such a thing exists at all; it's a little like talk about the software industry) appears to me to be really confused about what done means.

Whatever done means, it's subject to the Relative Rule. I coined the Relative Rule, inspired by Jerry Weinbergs definition of quality (quality is value to some person(s)). The Relative Rule goes like this:

For any abstract X, X is X to some person, at some time.

For example, the idea of a bug is subject to the Relative Rule. A bug is not a thing that exists in the world; it doesn't have a tangible form. A bug is a relationship between the product and some person. A bug is a threat to the value of the product to some person. The notion of a bug might be shared among many people, or it might be exclusive to some person.

Similarly: done is done to some person(s), at some time, and implicitly, for some purpose. To me, a tester's job is to help people who mattermost importantly, the programmers and the product ownermake an informed decision about what constitutes done (and as I've said before, testers aren't there to make that determination themselves). So testers, far from worrying about done, can begin to relax right away.

Let's look at this in terms of a story.

A programmer takes on an assignment to code a particular function. She goes into cycles of test-driven development, writing a unit check, writing code to make the check pass, running a suite of prior unit checks and making sure that they all run green, and repeating the loop, adding more and more checks for that function as she goes. Meanwhile, the testers have, in consultation with the product owner, set up a suite of examples that demonstrate basic functionality, and they automate those examples as checks. The programmer decides that she's done writing a particular function. She feels confident. She runs them against the examples. Two examples don't work properly. Ooops, not done. Now she doesn't feel so confident. She writes fixes. Now the examples all work, so now she's done. That's better.

A tester performs some exploratory tests that exercise that function, to see if it fulfills its explicit requirements. It does. Hey, the tester thinks, based on what I've seen so far, maybe we're done programming but we're not done testing. Since no onenot testers, not programmers, not even requirements document writers; imagine!is perfect, the tester performs other tests that explore the space of implicit requirements. The tester raises questions about the way the function might or might not work. The tester expands the possibilities of conditions and risks that might be relevant. Some of his questions raise new test ideas, and some of those tests raise new questions, and some of those questions reveal that certain implicit reqiurements haven't been met. (The tester is done testing, for now, but no one is now sure that programming is done.) The programmer agrees that the tester has raised some significant issues. She's mildly irritated that she didn't think of some of these things on her own, and she's annoyed that others are not explicit in the specs that were given to her. Still, she works on both sets of problems until they're addressed too. (Done.) For two of the issues the tester has raised, the programmer disagrees that they're really necessary (that is, things are done, according to the programmer). The tester tries to make sure that this isn't personal, but remains concerned about the risks (things are not done, according to the tester). After a conversation, the programmer persuades the tester that these two issues aren't problems (oh, done after all), and they both feel better. Just to be sure, though, the tester brings up the issues with the product owner. The product owner has some information about business risk that neither the tester nor the programmer had, and declares emphatically that the problem should be fixed (not done). The programmer is reasonably exasperated, because this seems like more work. Upon implementing one fix, the programmer has an epiphany; everything can be handled by a refactoring that simultaneously makes the code easier to understand AND addresses both problems AND takes much less time. She feels justifiably proud of herself. She writes a few more unit checks, refactors, and all the unit checks pass. (Done!) One of the checks of the automated examples doesn't pass. (Damn; not done.) That's frustrating. Another fix; the unit checks pass, the examples pass, the tester does more exploration and finds nothing more to be concerned about. Done! Both the programmer and the tester are happy, and the product owner is relieved and impressed.

Upon conversation with other programmers on the the project team, our programmer realizes that there are interactions between her function and other functions that mean she's not done after all. That's a little deflating. Back to the drawing board for a new build, followed by more testing. The tester feels a little pressured, because there's lots of other work to do. Still, after a little investigation, things look good, so, okay, now done.

It's getting to the end of the iteration. The programmers all declare themselves done. All of the unit checks are running green, and all of the ATDD checks are running green too. The whole team is ready to declare itself done. Well, done coding the new features, but there's still a little uncertainty because there's still a day left in which to test, and the testers are professionally uncertain. On the morning of the last day of the iteration, the programmers get into scoping out the horizon for the next iteration, while testers perform some final exploratory tests. They apply oracles that show the product isn't consistent with a particular point in a Request-For-Comment that, alas, no one has noticed before. Aaargh! Not done. Now the team is nervous; people are starting to think that they might not be done what they committed to do. The programmers put in a quick fix and run some more checks (done). The testers raise more questions, perform more investigations, consider more possibilities, and find that more and more stopping heuristics apply (you'll find a list of those here: http://www.developsense.com/blog/2009/09/when-do-we-stop-test/). It's 3:00pm. Okay, finally: done. Now everyone feels good. They set up the demo for the iteration.

The Customer (that is, the product owner) says This is great. You're done everything that I asked for in this iteration. (Done! Yay!) except, we just heard from The Bank, and they've changed their specifications on how they handle this kind of transaction. So we're done this iteration (that is, done now, for some purpose), but we've got a new high-priority backlog item for next Monday, whichand I'm sorry about thismeans rolling back a lot of the work we've done on this feature (not done for some other purpose). And, programmers, the stuff you were anticipating for next week is going to be back-burnered for now. Well, that's a little deflating. But it's only really deflating for the people who believe in the illusion that there's a clear finish line for any kind of development worka finish line that is algorithmic, instead of heuristic.

After many cycles like the above, eventually the programmers and the testers and the Customer all agree that the product is indeed ready for deployment. That agreement is nice, but in one sense, what the programmers and the testers think doesn't matter. Shipping is a business decision, and not a technical one; it's the product owner that makes the final decision. In another sense, though, the programmers and testers absolutely matter, in that a responsible and effective product owner must seriously consider all of the information available to him, weighing the business imperatives against technical concerns. Anyway, in this case, everything is lined up. The team is done! Everyone feels happy and proud.

The product gets deployed onto the bank's system on a platform that doesn't quite match the test environment, at volumes that exceed the test volumes. So the bank's project manager isn't happy (not done). The testers diligently test and find a way to reproduce the problem (they're done, for now). The programmers don't make any changes to the code, but find a way to change a configuration setting that works around the problem (so now they're done). The testers show that the fix works in the test environments and at heavier loads(done). Upon evaluation of the original contract, recognition of the workaround, and after its own internal testing, the bank accepts the situation for now (done) but warns that it's going to contest whether the contract has been fulfilled (not done). Some people are tense; others realize that business is business, and they don't take it personally. After much negotiation, the managers from the bank and the development shop agree that the terms of the contract have been fulfilled (done), but that they'd really prefer a more elegant fix for which the bank will agree to pay (not done). And then the whole cycle continues. For years.

So, two things:

1) Defintions and decisions about done are always relative to some person, some purpose, and some time. Decisions about done are always laden with context. Not only technical considerations matter; business considerations matter too. Moreover, the process of deciding about doneness is not merely logical, but also highly social. Done is based not on What's Right, but on Who Decides and For What Purpose and For Now. And as Jerry Weinberg points out, decisions about quality are political and emotional, but made by people who would like to appear rational. However, if you want to be politically, emotionally, and rationally comfortable, you might want to take a deep breath and learn to acceptwith all of your intelligence, heart, and good willnot only the first point, but also the second

2) Done is subject to another observation that Jerry often makes, and that I've named The Unsettling Rule:

Nothing is ever settled.

• We deployed new caches that can handle high request rates while keeping results fresh as we continuously crawl and re-index the web.
• We introduced user-state data into our back-ends to keep track of the results pages already shown to a given userthis way we don't re-fetch the same results repeatedly.
• We optimized page-rendering JavaScript code to help ensure web browsers could keep up with the rest of the system.

Have you ever wondered how some Facebook pages show specific content or offers only to fans? If so, look no further.

One of the most popular FBML tags is fb:visible-to-connection. A favorite of marketers, this FBML tag allows a Facebook page to show different content to fans and non-fans. When a non-fan clicks the Like button viola! the non-fan content disappears and the fans-only content replaces it. As a method of motivating a visitor to become a fan of your page, this can be very effective.

This FBML tag is oftenand erroneouslyreferred to as a hack, but it was created by Facebook to do exactly what it does: to display the content inside the tag on a user's or a Facebook page's profile only if the viewer is a friend of that user or is a fan of that Facebook page.

Examples of Brands Using Fans-only Content

There are many ways to motivate your visitors to Like your page. Here are a few examples from brands on Facebook:

Levi's promises Instant access to exclusive content.

1-800 Flowers offers a discount code for 20% off your next order.

Teesey Tees keeps it mysterious: See what the deal is.

DIGISTORE offers Discount Codes, Unadvertised Specials, Free Monthly Giveaways.

You get the picture. We have great content here, BUT FIRST you gotta Like us!

Of course, you should make sure that your teaser to non-fans is sufficiently compelling for them to Like your page. Many pages require a visitor to become a fan before displaying certain content, but they don't convey the value of the content. Teesey Tees, above, comes very close to this.

Following are instructions on how to add fans-only content to your page.

Add the Static FBML Application to Your Page

First, you'll need to add the Static FBML application to your page. Here is a tutorial.

NOTE: Static FBML can only be added to a Facebook page (i.e., Business Page, Company Page, Brand Page). It cannot be added to a personal profile.

What Is FBML?

FBML is Facebook's own proprietary mark-up language that enables your tab content to interact with the Facebook API (Application Programming Interface). It is as easy to use as HTML.

Most FBML tags, including the ones I use in this article, have an opening tag and a closing tag. The content for each tag HTML, CSS and/or more FBML is placed between these opening and closing tags.

Creating Your Fans-only Content on Your Custom Tab

Once you've added the Static FBML application, the implementation of this FBML tag is pretty easy. The only part that is somewhat tricky is getting rid of the white space the fans-only content creates even though it's not yet visible.

Facebook uses the visibility:hidden style to hide the fan content until the user Likes the page. However, this style rule still reserves the space for the content; it just doesn't show the content. Consequently, the non-fan content is pushed down the page! However, this is easily solved with a bit of CSS absolute positioning. I incorporate this approach into the following examples.

The code for the FBML box:
<div id="wrapper">
<fb:visible-to-connection>
FANS-ONLY CONTENT GOES HERE
<fb:else>
<div id="non-fans">NON-FANS CONTENT GOES HERE </div>
</fb:else>
</fb:visible-to-connection>
</div>

As shown above, all the tab content will be contained in the wrapper DIV.

<div id=wrapper> opens this containing DIV. CSS styles are applied to the ID wrapper via the stylesheet.

All the fans-only and non-fan content is placed between the opening <fb:visible-to-connection> tag and closing </fb:visible-to-connection> tag. This content can be HTML, FBML and CSS.

The fans-only content comes first, followed by the non-fan content which immediately follows the opening <fb:else> FBML tag.

The non-fan content is contained within the <div id=non-fans> and </div> tags. CSS styles are applied to the ID non-fans via the stylesheet.

Immediately following the non-fan content is the closing </fb:else> tag, followed by the closing </fb:visible-to-connection> tag and, finally, the </div> tag to close the wrapper DIV.

Here is the Static FBML box with the above code, and the link to an external stylesheet:

Here is the CSS for the external stylesheet (with example URL):
#wrapper {
width:520px;
margin:0 auto; border:0; padding:0;
position:relative;
}
#non-fans {
width:520px;
position:absolute; top:0; left:0;
}

Your external stylesheet should have only the CSS style rules. Don't include the <style> </style> tags!

If you can't use an external stylesheet

If you don't have a server where you can upload a separate stylesheet, you can inline the styles inside the HTML tags. Although this isn't ideal, it's an option if you can't create a separate stylesheet, host it on a server and link to it with the <style> tag.

Here is the above example, with the styles for the <div> tags inlined (notice we don't need the IDs if we use this approach):

Testing and Troubleshooting

Testing and troubleshooting this particular FBML tag is a bit tricky, because when logged in as a user who is a page admin, you will see both fans-only and non-fan content when viewing the tab.

• Create a user account for testing: The most efficient way to test is to create a Facebook account for testing only, or use a friend's or colleague's account. (Creating a new personal profile for testing may violate Facebook's Terms of Service See #4, Registration and Account Security even if done with good intentions.) You can be logged in to Facebook as one user (the admin account) in one browser and logged in as the test account in a different browser (I use Firefox and Safari). Then you don't have to keep logging in and out of Facebook as admin, then as tester, etc.
  When testing, you'll need to toggle back and forth between Liking and Unliking a page. To Unlike a page, click on the Wall tab. Near the bottom of the left column of the Wall, you'll see Unlike:
  
  Click that to Unlike the page, and you can click the Like button to re-Like the page. Repeat as necessary.

• Use an external stylesheet, NOT inlined styles: Most browsers will correctly display your page if you have inlined the CSS with the <style> tag, but NOT Internet Explorer 8!
  Because millions of people use this particular browser, your CSS should be in its own file (with the extension .css) and be referenced from your FBML page, with the <link rel=stylesheet type=text/css href=URL-TO-EXTERNAL-STYLESHEET />. You'll need to have this file hosted somewhere on the web where you can link to it.

• Double-check all URLs: If any files (images, CSS, etc.) are not being displayed or accessed, be sure to test the URLs for these files directly in your browser, typing or pasting the URL in the address bar to make sure you can access the file directly.
  
  If you can't access the file directly, then your URL is incorrect.

• Check for proper syntax: Make sure that URLs are surrounded by matching quotes (single or double is fine, but they must match) and that they are plain-text, straight-up-and-down quotes (not fancy or curly quotes).

• Check your Tab on the Most Popular Browsers and on Mac AND Windows: You want to be sure your tab is displaying properly on the most popular browsers (Firefox, Internet Explorer, Safari and Chrome, at the very least) and on both Mac and Windows. What displays well in Firefox, Chrome and Safari may not (and often doesn't) display well on Internet Explorer.

What About Facebook's Announcement on Killing Off FBML?

On August 19, 2010, Namita Gupta announced the impending phase-out of FBML. However, I expect that support for Static FBML and the fb:visible-to-connection tag will be around indefinitely. Static FBML is Facebook's own application and just several months ago they offered Static FBML custom tabs as a consolation prize to users who were distraught over the killing off of the Boxes tab. I expect it will be supported well into 2011 and perhaps beyond.

Have you tried fan-only content on your Facebook page? What has been your experience? Please leave your comments in the box below.

We had told you in previous blog posts that we were working hard to prepare for some important releases, and this past week proves that we were not fooling! From a new look on our homepage, including an "Introduction to StatusNet" video, to a new beta service for RSS feeds, to the latest mobile beta, this week has been full of releases, and they will not stop here!

Latest updates

Check out the StatusNet website and you will find a StatusNet video on our homepage! It is informational and fun! There is also a blog post on the Introduction to StatusNet Video on our website.

There is a new service to post RSS feeds to StatusNet and it is in Beta called dlvr.it. The service is similar to Twitterfeed but it is more feature-rich and has direct posting to StatusNet, among other social streams.

For all you mobile microbloggers, StatusNet Mobile beta 4 is now available for Android and iPhone. Check it out and tell us what you think!

Lastly, there have been some recent changes to the licenses for the StatusNet themes. It might be worth checking to see what they are!

Recent Mentions of StatusNet

In "OStatus Interview with James Walker", the latest interview of a series of OStatus interviews, James Walker of StatusNet talks about how StatusNet uses OStatus and what role he played in the creation of OStatus. Head over to OStatus for more details!

For more of the latest press mentions for StatusNet, you can visit our press section.

Upcoming Events

The PodCamp Montreal event will be taking place this weekend, September 16th and 17th. StatusNet is one of their bronze sponsors, and as such, Evan Prodromou (CEO and founder of StatusNet) will be attending.

Reminders

Are you implementing OStatus, an open standard for distributed status updates? If you are and you would like to answer a few questions on OStatus and how you are implementing it, please contact me by email at dderouin@status.net.

Also, we would really like to hear your thoughts and we value your contributions and so feel free to add community news now for next week's post on our public wiki.

This is Derek reporting to you from StatusNet in Montreal. Don't forget to subscribe to Status on Status.net, download the StatusNet Desktop Client, and upgrade to the latest version StatusNet 0.9.4!

Fictional Biology of the Day: Jason Freeny's latest anatomical vinyl doll the Toy Story Alien.

[moist.]

Earlier: Dissected Dunny; Visible Uglydoll;

Late Links:

• Paris Hilton smuggled what in her where?

• Scientists determine men's most attractive dance moves. Noticeably absent: The Hustle.

• Grandma's ashes mistaken for poor quality cocaine.

• Bikini Wednesday: Holly Madison.

• Cleavage Wednesday: Ashley Greene and Paris Hilton.

• Pretty In Print: Christina Aguilera in Cosmopolitan UK; Lindsay Lohan in Vanity Fair.

• Get To Know A Hottie: Lea Viglione.

• International Beauty of the Day: Adriana Abenia.

• Katy Perry is a cocktease.

• Dragon*Con missed connections.

• Don't you just hate it when you go to an orgy and someone steals your pussy?

• Holy Taco: Losing Your Virginity: A Step-By-Step Guide.

• Manofest: The 30 Greatest Moments In Pedobear History.

• Late List: Top 30 Hottest Jewish Women Under 40.

• Bonus List: Top 40 Reality TV Women in Bikinis.

[photo: geekologie.]

Running an uptime monitoring service as we do, over time it's become obvious to us that a large portion of website problems are caused by DNS issues, and in many cases those issues were a direct result of bad DNS settings. In other words, there is a lot of downtime and other website errors that could have been avoided if the DNS servers of that website had been correctly configured from the start.

That's why we added a free DNS Health test to our Pingdom Tools section this July. It will take a domain name and perform a series of tests to verify that its DNS settings are good and that the DNS servers it's using are set up correctly.

Now that thousands of webmasters have tested their DNS settings with this service, we thought it might be fun to share some general statistics with you.

Above: Two examples of test results from the DNS Health test.

How common are incorrect DNS settings?

A good place to start is to show you how many of the tests were successful and how common warnings or errors have been so far. An interesting note is that less than one third of the tests have passed without any remarks whatsoever.

Test results so far:

• 31% passed with flying colors, all tests ok.
• 29% passed, but with at least one warning, i.e. not necessarily an error, but some setting (or lack thereof) that could potentially cause a problem.
• 34% passed with at least one error detected, i.e. with some setting that doesn't work or is incorrect.
• 6% had really critical errors, i.e. were completely broken in one way or another.

As you can see, a full 40% of the tests had errors of some kind in them. Granted, the DNS Health test is quite thorough and tests a lot of things, but it's still a revealing number.

How many DNS servers do websites use?

One big no-no when you have a website is to only have one single DNS server. If that one DNS server fails and there is no redundancy, DNS lookups will stop working completely, and the website becomes unavailable. Out of the domain names tested, as many as 1 in 20 (4.4% to be exact) only had one DNS server.

Here is what the distribution looks like for the domain names tested so far:

• 4.4% have 1 DNS server.
• 66.4% have 2 DNS servers.
• 14.5% have 3 DNS servers.
• 8.1% have 4 DNS servers.
• 6.6% have 5 or more DNS servers.

One domain name had as many as 16 DNS servers listed. Now that's redundancy.

The DNS Health test has already helped many

Seeing that they have problems with their DNS settings, many webmasters have already taken action. How do we know? We can see that a significant portion of the tested domain names have been tested more than once, almost half of them with improved results, presumably due to actions taken either by the webmaster or his/her hosting company.

We love that the tool is having a real effect, prompting real improvement in a lot of websites' DNS settings. It's already helped hundreds of webmasters track down DNS issues and resolve them. Why not try it out on your own domain name(s), if you haven't already?

As we've previously discussed, IE9 includes support for HTML5 canvas. You can test it out right now by downloading the latest platform preview. In our testing of sites that use the latest web standards, we are pleased to see that many canvas sites just work in IE9. For those of you using <canvas> on your site, we have two tips to make sure it works properly across browsers and in IE9: use feature detection instead of browser detection, and use <!DOCTYPE html>.

Be sure to use feature detection instead of browser detection

If you are using browser detection, such as automatically falling back to a non-canvas implementation if you detect that the user is using an IE User Agent string, you may be blocking HTML5 content from rendering in IE9. Instead of doing browser detection, you should do feature detection to check if the user's browser has a certain capability. For instance, you can use this code to check if your user's browser supports canvas:

if (document.createElement("canvas").getContext) {
	// Code requiring canvas support
} else {
	// Canvas isn't available. Put non-canvas fallback here
}

This eliminates the need for you to make assumptions about current browser feature support and ensures your site will continue to work as browsers evolve. We explain more about feature detection in this post.

How to check if the user's browser supports Canvas:

• DO: Canvas feature detection code
• DON'T: Browser detection using User Agent string
• DON'T: Conditional comments

Make sure your site is in IE9 mode

By default, if your site is following web standards, such as using a standards DOCTYPE, IE9 will render it in standards mode. You can check if your site is in this mode by bringing up the Developer Tools (press F12) and checking to see if your site is in IE9 standards Document Mode.

Canvas is a new feature only supported in IE9 standards mode a design decision we took to ensure that legacy document modes remain fully backward compatible. If you see a Document Mode for your site other than IE9 standards, HTML5 elements like canvas won't be displayed. For example, if you don't have a DOCTYPE in your page, IE9 will display the site in Quirks Mode. To ensure your page works as expected in IE9, we recommend that you add a strict DOCTYPE to your webpages. For example, you could add the W3C HTML5 DOCTYPE:

<!DOCTYPE html>

Or you can use a common strict DOCTYPE such as this:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

You can read more about how IE determines the document mode here.

Interoperability and Canvas

Interoperability is a high priority for IE9, to the point where we recommend sending IE9 the same standards-based markup your site sends to other browsers. Most canvas sites should just work on IE9 if the site was originally developed for another browser. That being said, there are a few behavior differences between browsers. For instance, consider the shadow demo from the Canvas Pad test drive site.

This is one example of a canvas feature that is rendered a little differently in each browser. We are making IE9 interoperable whenever possible, but for some canvas features, other browsers do not have a complete or correct implementation. In these cases, we follow the W3C spec. We submit test cases to the W3C as a way to help ensure everyone agrees on how the spec should be interpreted and implemented. To learn more about our shadow implementation, check out our canvas tests from the IE Test Center.

The purpose of the W3C spec is to define a standard that all browsers should follow. If we find examples where browsers uniformly behave differently from the spec, we feel that spec should be updated to reflect the interoperable behavior, if it makes sense for web developers. For instance, HTMLFrameElement did not contain the contentWindow attribute in the W3C spec; however IE8, Firefox, and Chrome all support this attribute. We filed a bug with a proposed change, and the HTML5 editor updated the latest revision of the spec.

If something looks unexpected in IE9 and you believe it is an interoperability issue or an area where we deviate from the spec, please let us know by filing a bug with Microsoft Connect. One of our goals around the platform previews and the beta of IE9 is to give our users a chance to give us as much feedback as possible, so don't hesitate to let us know if you think you see a bug!

Thanks,

Elizabeth Ford and Jatinder Mann

Program Managers, Internet Explorer

I am sure that there are a lot more library innovation labs, but I am fascinated by the concept of offering individual library innovators' new developments and lab product and service development activities out there for use and public or peer comment. Sharing is a good thing.

These strategies are used in the private sector by vendors and we're seeing more in the pubic sector with libraries doing them too.

Check out these library ones:

Harvard Library Lab: Libraries need product development
http://dysartjones.com/2010/08/harvard-library-lab-libraries-need-product-development/

Harvard Library Lab
http://osc.hul.harvard.edu/liblab

DCPL Labs (DC Public Library)
http://dclibrarylabs.org/

Unversity of British Columbia Library Lab
http://www.library.ubc.ca/labs/

And this is a fairly good list site:

Directory of Experimental Library Tools

Links include:

Allen County Public Library (Fort Wayne, Indiana) ACPLib2.0
Ball State University Libraries Web Laboratory
Brown University Library Software Development and Distribution
Deakin University Library (Australia) Experimental Options
District of Columbia Library DCPL Labs
Hong Kong University of Science and Technology Library Sandbox
Johns Hopkins University Library Betas
Jnkping University Library (Sweden) Library Lab
Massachusetts Institute of Technology (MIT) MIT Libaries' Betas
National Library of Australia LibraryLabs
New York Public Library NYPL Labs RSS Updates
Ohio State University OSU Labs RSS Updates
North Carolina State University Digital Library Initiatives Projects
University of Alabama Web Laboratory RSS Updates
University of Illinois at Urbana-Champaign UIUC Library Labs
University of Jnkping Library Lab
University of Michigan MLibrary Labs RSS Updates
University of Minnesota Digital Library Development Lab
University of Nebraska Lincoln BetaZone RSS Updates
University of Pennsylvania PennLabs
University of Texas LIBwidgets
University of Viriginia Library Lab
Vanderbilt University Test Pilot RSS Updates

Check out these vendor ones:

The granddaddy model' is:

Google Labs
http://www.googlelabs.com/

Other Google Labs linked from the main page include:

Calendar Labs
Latest ideas from the Calendar team
Gmail Labs
Dozens of Gmail experiments
Google Code Labs
Experimental developer products
Google Maps Labs
Experimental Maps features
Google Wave
Real-time communication and collaboration
Search Experiments
Alternate search views and more
Toolbar Labs (IE only)
Language and location-based experiments
YouTube TestTube
YouTube's ideas incubator

Gale Labs

Gale Showcases Gale Labs During American Library Association Conference

Adobe Labs
http://labs.adobe.com/

OCLC launches Innovation Lab
http://www.oclc.org/nextspace/015/labs.htm

It would be great to see more. I've written in the past that we have an issue with od deas not difusing fast enough through library land. I worry that one source of this delay could be a reticence to share new projects before they're ready for prime time. These labs might be the right context for sharing good ideas and projects early without the expectation of perfection.

Do you know of any more library labs (libraries or library vendors)? Tell us in the comments.

Stephen

There's been plenty of debate lately about whether Twitter has become mainstream or not, but examples continue to pile up of how the social network/microblogging platform has worked its way into our lives, to the point where it has become a form of media unto itself. Whether it will ever become mainstream in the sense that it gets used by your aunt or grandmother is almost irrelevant the reality is that, for all its flaws, Twitter is a publishing tool, and an increasingly powerful one. And it can be used by anyone, journalist and non-journalist alike.

One of the most recent examples came several days ago, when a Japanese journalist who was kidnapped in Afghanistan managed to trick his captors into letting him post a message about his location to Twitter. It's not clear from the news reports whether his tweets helped get him released or not, but it is yet another example of how easy Twitter makes it to broadcast that kind of news and not just to one or two people, the way email or text messaging does, but to potentially hundreds or even thousands (in 2008, Twitter helped American photojournalist James Buck spread the news that he had been arrested by Egyptian police while covering an anti-government protest).

Two other examples of Twitter as a news platform are the recent hostage-taking and shootout at Discovery Channel headquarters in Maryland, and the earthquake that hit near New Zealand last week. In the first case, reports about a gunman in the Discovery building started coming in before the news was on a mainstream news outlet. And in the case of the earthquake as in similar cases involving earthquakes in China and forest fires in California reports flooded the Twitter network while most mainstream media outlets were still unaware that it had even occurred. One resident said she relied on news she got from Twitter more than the radio, because it was a lot faster (although it should be noted that she is a Twitter fan and web consultant).

Obviously, Twitter reports aren't going to contain a complete accounting of an event like an earthquake or a shooting, but it has become just as obvious that they can be a powerful tool for man on the street or eyewitness accounts, whether it's the fires in California or a plane landing in the middle of the Hudson River. In the case of the Discovery Channel situation, reporters described how useful this was because it acted as an early alert system on what was happening. In fact, earlier this year researchers looked at the flow of content on the network and found that Twitter is far more of a news medium than it is a traditional social network.

Since the protests in Iran last year, there has been a lot of debate about how important Twitter was during those demonstrations, and whether it was actually used by dissidents or merely by sympathizers in the West. But there's no question that it helped spread the news of events such as the shooting death of protester Neda Soltan which many saw as a key moment in the protests and that it was important enough that the Obama government contacted the company to ask that it delay scheduled maintenance on the network while the protests were going on. The network has been used in a similar way in protests in Burma and elsewhere.

The thread that ties all of these events together is simple: Twitter, like blogging did before it, puts the tools of publishing in anyone's hands. And yes, that means the information flowing through the network is not always accurate hoaxes are a routine part of the stream but it also means that there are thousands more eyeballs and brains studying those reports than there would be at any mainstream media outlet. The bottom line is one that journalism professor Jay Rosen reiterated during a recent address to journalism students in Paris: the people formerly known as the audience have the tools to become part of the media now, and that is changing our society in ways that we are only beginning to appreciate.

Related content from GigaOM Pro (sub req'd): What We Can Learn From the Guardian's Open Platform

Post and thumbnail photos courtesy of Flickr users Waldo Jaquith and George Kelly

Shared by Josh Bancroft
4.1 brings Field Test mode back? Neat.

Speedier performance for more or less the same money is always welcome. That's exactly what you get from the new Intel Core i5 760. In almost every regard, it's identical to the existing Core i5 750 processor.

It's therefore a quad-core chip based on Intel's 45nm Nehalem processor architecture. What it does offer, however, is a speed bump from 2.66GHz to 2.8GHz. Not exactly a spectacular explosion in performance, we admit. But then Intel is only asking for an extra fiver.

In any case, even after a year on sale, the Core i5 750 is still an excellent all round performer. The slightly quicker Core i5 760 is only going to be better. The only snag is the arrival of AMD's new Phenom II X6 1055T beast. Six cores for a similar 150 or so price tag is awfully hard to resist.

Fire up any of Intel's Core i5 processors and you'll be greeted by four little green graphs in Windows Task Manager. That indicates the presence of four logical processors and therefore support for crunching a quartet of software threads in parallel.

But not all logical processors are equal. Intel's Core i5 600 series chips are actually dual-core models that support two threads per core thanks to HyperThreading. Core i5 700 series CPUs lack HyperThreading. Instead, you get four bona fide execution cores and one helluva lot more performance. Effective as HyperThreading is, it's no substitute for a real processor core.

Despite a relatively modest 2.8GHz stock clockspeed, it's therefore no surprise to find the Intel Core i5 760 flattens the Core i5 661 and Core i5 655K in literally every performance benchmark. You have to wonder why anyone would want to pay more for one of those Core i5 600 series chips. Intel would no doubt justify the price premium by pointing to the Core i5 600's integrated graphics.

Anyway, a much tougher nut for the Core i5 760 to crack is AMD's new six-core processor. The Phenom II X6 1055T is actually slightly cheaper despite giving the Core i5 760 a pretty solid schooling in our multi-threading tests. As ever, however, the 760 hits back with awesome gaming performance. It also shows the Phenom chip who's boss in our file decompression test.

It's also disappointing to find the new 760 does not appear to offer any additional overclocking headroom. In our testing, the older Core i5 750 actually hits higher frequencies.

We liked:

If you fancy four cores for the price of two, it's hard to argue against the Core i5 760. It's cheaper than many of Intel's latest dual-core processors and hammers them for all round performance. At this price point, it's also the finest gaming CPU on the market.

We disliked:

Intel has a nasty habit of artificially hobbling some of its mainstream processors. So it is for the Core i5 760. By switching off HyperThreading, Intel has compromised the 760's performance in highly threaded applications such as video encoding and handed the advantage to AMD's similarly priced six-core Phenom II X6 1055T. Shame.

Verdict:

Replaces the Core i5 750 as our favourite gaming chip. No HyperThreading is a bit of a bummer.

Follow TechRadar Reviews on Twitter: http://twitter.com/techradarreview

• Read more processor reviews
• TechRadar Reviews Guarantee

Filed under: Humor, Let's Be Friends Again

Permalink | Email this | Linking Blogs | Comments

A few days ago, 4Chan decided they were going to make William J. Lashua's 90th birthday one he'd never forget . The big day was yesterday, and sure enough, he received a huge pile of cards from Internet well-wishers and a few charming party-crashers even stopped by.

The Best Links:

1. Birthday bash spirals online
2. 4Chan Finally Uses Power For Good
3. Via The Daily Wh.at

View List

Creator vs Destroyer: As a law of nature - creator can not be destroyer. Similarly in software, a programmer can not be critic of his own code.

Constructive Criticism: A good programmer will always love and admire his code, but will never have that third eye' (that a tester has) to locate bugs in the code. A programmer is fond of listening to praises' for a well written code than listening about the shortcomings in the program written by him.

Vision of a tester: A programmer will always think of the pass conditions in most of the cases and will bother less about the negative scenarios. A simple example could be that the programmer has to write a code to accept a password that has to have minimum one special character, two numerals and length not less than 8 characters. Once this condition is fulfilled, the programmer will be more than satisfied but what about n number of different test cases that a tester creates just to check this simple requirement.

Fear Factor: Even sometimes when a programmer knows about a flaw in his coding, seeking a major change and coming into his notice at a later stage, he will like to oversee it and also try it to be to be overseen by others. He may fear that highlighting a shortcoming in a code written by him at this critical juncture may loosen up his superiors trust in him, which is usually dear all everyone at any cost.

Thinking Pattern: Walking on the Same Road everyday makes one perfect on that road but what about other road patterns, walking backwards etc. Continuous Coding, Coding and Coding make him a perfect coder but only a perfect coder.

Documentation: Usually a coder writes code perfectly but with very little or no documentation. At times, he himself forgets what logic has he written for a specific requirement and then he has to refer to his own code (and waste some time) to find it out.

Self Testing: The confidence (or over confidence) stops a coder to introspect or examine his own coding by doing smoke testing or jotting down some test cases and scenarios to run them and get a pass through for his own satisfaction.

Tight Schedules: A programmer is always having his task basket full and has delivery schedule tight. That also becomes one of the reasons for passing on some bugs (in a hurry).

Shared by phillip
I remember reading this years ago.

For the opening piece in our series on Gates leaving daily life at Microsoft, one goal was to give a clear picture of the Microsoft co-founder's role inside the company, as a gauge of the impact his departure will have. As part of that, I went back through the internal e-mails turned over in the antitrust suits against the company, looking for new insights into his personality.

Read on past the jump for one of the gems that turned up, showing Gates in the role of chief rabble-rouser. (Original document: PDF, 5 pages.) It shows that even the Microsoft co-founder -- who champions the "magic of software" -- isn't immune to the frustrations of everyday computer users. Keep in mind that this was more than five years ago, so it doesn't necessarily reflect the specific state of things now. At the bottom, see what Gates said when I asked him about the message last week.

---- Original Message ----

From: Bill Gates
Sent: Wednesday, January 15, 2003 10:05 AM
To: Jim Allchin
Cc: Chris Jones (WINDOWS); Bharat Shah (NT); Joe Peterson; Will Poole; Brian Valentine; Anoop Gupta (RESEARCH)
Subject: Windows Usability Systematic degradation flame

I am quite disappointed at how Windows Usability has been going backwards and the program management groups don't drive usability issues.

Let me give you my experience from yesterday.

I decided to download (Moviemaker) and buy the Digital Plus pack ... so I went to Microsoft.com. They have a download place so I went there.

The first 5 times I used the site it timed out while trying to bring up the download page. Then after an 8 second delay I got it to come up.

This site is so slow it is unusable.

It wasn't in the top 5 so I expanded the other 45.

These 45 names are totally confusing. These names make stuff like: C:\Documents and Settings\billg\My Documents\My Pictures seem clear.

They are not filtered by the system ... and so many of the things are strange.

I tried scoping to Media stuff. Still no moviemaker. I typed in movie. Nothing. I typed in movie maker. Nothing.

So I gave up and sent mail to Amir saying - where is this Moviemaker download? Does it exist?

So they told me that using the download page to download something was not something they anticipated.

They told me to go to the main page search button and type movie maker (not moviemaker!).

I tried that. The site was pathetically slow but after 6 seconds of waiting up it came.

I thought for sure now I would see a button to just go do the download.

In fact it is more like a puzzle that you get to solve. It told me to go to Windows Update and do a bunch of incantations.

This struck me as completely odd. Why should I have to go somewhere else and do a scan to download moviemaker?

So I went to Windows update. Windows Update decides I need to download a bunch of controls. (Not) just once but multiple times where I get to see weird dialog boxes.

Doesn't Windows update know some key to talk to Windows?

Then I did the sca