​Day 00002 at Vertigo; I'm the new guy. I upgraded my JAPH for Vertigo:

map{print "$_ "}
split(/\d/, 
	join('', 
		map /(\w)\w/gi, 
		qw(Jaubsctd1a Aenfogthhiejrk2b Vlemrmtniqgnov3c Hoapcqkresrt)
	)
);

Recently, I stumbled across an old Engadget post about how hackers were loading Android onto their WinMo phones. Since I had a HTC Touch Pro 2 (WinMo 6.1), one of the supported phones, I decided that I too wanted a 'HackDroid'.

After reading a few blog postings about how it could be done, eventually I stumbled across single website that had a cab file for installation, a short video of the installation experience, and all the tools in a single place.

What I liked about the project is that you do not need to flash the device with new firmware, making this a fairly row risk procedure. Android doesn't replace the native WinMo OS, but instead is stored on the phone's SD card, and after Android is booted, replaces WinMo in the RAM. If anything goes wrong, none of the phone's permanent ROM is changed, so rebooting takes the phone back into WinMo.

After watching a video of the installation experience, I borrowed a microSD card from a friend and gave it a try.

The version installed by the cab is v2.2 (Froyo), originally released May 20, 2010. The cab also placed a shortcut icon in my home screen which kicks off the boot process.

Android booting up:

After about a minute of warmup time, I was presented with the login screen. Success!

Desktop:

I immediately called work to tell them I was feeling sick and wouldn't be in for work the next day:

Unfortunately, the camera hardware drivers aren't working yet, so I saw this when I tried to take a picture.

The app store worked, and I was able to download games and utilities. The game of the year seems to be Angry Birds, so I made that my test case. Although it's slow, and there were some rendering issues, the game downloaded, installed, and ran.

Here's an example of a rendering issue. Sometimes graphic elements would get scrambled.

Pandora worked great:

The rough edges do show at times. For instance, I did have to run the installer three times before I successfully booting into Android; a friend had a similar experience.

Also, the system is a little unstable, so expect to pull the battery once in a while. Once, I adjusted the sound during a call and the phone went to speakerphone at max volume, and then proceeded to lock up. I could still hear the caller on the other side of the line, confused. This was pretty embarrassing, since I was in the office at the time.

In the end, it seems like a great start to this project, and I'm really excited with what they've done so far.

 

Conan's take

This article in Fortune describes how Conan O'Brien discovered the power of social media in reviving his career. His show on TBS is now considered to be at the forefront of online social-savvy: clips from the show are released on YouTube to generate interest (a move that most players in the broadcast world oppose, taking licensed shows off of YouTube), and each show warrants a new Twitter hash tag. The TV audience and the live audience at the taping participate in a real-time conversation on Twitter and actually get to participate and drive the content:

"Between his bits, O'Brien would come backstage and ask, "How's the tweets? How's the audience?" By reading the hashtag stream, Bleyaert recalls, O'Brien and his team could see, for example, that "some guy in the fifth row was using Twitter to try and pick up a 'girl in the white hat, three rows in front of the stage,' " and O'Brien would instantly incorporate that into his next bit."

• Focus on engagement
• Give your fans a megaphone to tell the world what they think
• Allow 2-way participation in the content being viewed
• Provide tools that make the content more relevant to specific users
• Allow rapid creation of clips to provide shareable content while it's still relevant

Some examples:

NBC's Sunday Night Football Extra 2010 and NHL Extra 2011:

1. Allow users to have a (moderated) conversation with each other via Twitter within the application
2. Allow users to participate in an ongoing conversation throughout the game by asking questions of Mike Florio from Pro Football Talk
3. Provide a way for fans to wear their colors online by voting for their team in a Twitter Battle, driven by Twitter hash tags.
4. NBC posts highlight clips of key plays within a minute or two of their happening live (via the Silverlight Rough Cut Editor). This allows fans to very quickly share out that bone-crunching tackle while the content is still hot and relevant.
5. Built a preview window that allows fans to share specific plays of their choosing with their friends. This empowers users to find the content they care about and drive what they discuss online, not restricting them to editorially-selected clip content. This is content that is relevant to each specific user, and provides a tool for users to create their own take on the content, allowing another avenue for participation in the event.
   

Microsoft's PDC 2010:

1. Added a Twitter hash tag per session to allow users to discuss the content live in real-time
2. Allowed real-time Q&A and Polling to allow the online audience to interact with the presenter and affect the content being presented.
3. Quickly created clips and on-demand content with the Rough Cut Editor.
4. Allowed bookmarking of specific locations in each session to allow users to share and discuss content relevant to them.

I was recently playing around with WCF services, seeing what I could learn about duplex communications. I came up with the idea to build a demo application that would connect a HTML5 “audience” website with a Silverlight 4 “presentation” application. The specific idea was to have a GrokTalk audience use their iPads to send messages from Safari with AJAX calls to a WCF service, which would, in turn, forward data to a Silverlight application that would display the results. In turn, SL4 would return messages through WCF back to the HTML5 web clients, updating the browser with refreshed information.

I'm between projects. What the heck?

Well, that was the original, albeit admittedly contrived, idea. As it turns out, this original architecture did not pass the POC phase. While exploring the idea, however, I learned a bit about the current strengths and limitations of WCF's PollingDuplex binding and will summarize what I discovered here.

With the release of Silverlight 4, a new mode, called MultipleMessagesPerPoll, was added to PollingDuplex binding. For previous versions of Silverlight, duplex communications between WCF and Silverlight were achieved by having the client poll the server, and the server using its response as an opportunity to send data back to the client. One limitation of this initial PollingDuplex implementation is that the client cannot respond to the incoming server responses. A more severe limitation is that the server could only send one message per response. With the server only able to send one response per poll cycle, the queue for outgoing messages to the client could become quickly backlogged, even in a matter of a few seconds.

With Silverlight 4, PollingDuplex binding now has the MultipleMessagesPerPoll mode available. Now when WCF receives a poll request from the client, it is able to send multiple messages to the client using HTTP chunking. In fact, WCF attempts to hold open the response connection for as long as it can, until it times out or it experiences interference from the network. As soon as the connection is lost, the client sends a new request and the process repeats itself. Yavor Georgiev provides a more detailed explanation here.

While the MultipleMessagesPerPoll mode is a definite improvement over the original PollingDuplex implementation, it turns out to have some limitations. First, for the non-server operating system (XP/Vista/Windows7), WCF will either reject or queue new client requests after the first 10 simultaneous connection are made. For server operating systems, the picture is a bit brighter. While IIS6 allows each long running connection to consume a thread from the pool (placing a serious limitations on the number of possible clients), with IIS7 on Windows Server 2008, asynchronous connections do not require their own thread, allowing for thousands of concurrent connections.

A more serious problem, however, then surfaced. A known issue with the current release of Silverlight causes faults in the PollingDuplex client channel:

This behavior is a regression introduced in SL4 GDR1 and is visible when the following conditions are put together:

-Use of PollingDuplex 
-DuplexMode is set to MultipleMessagesPerPoll 
-Http stack is set to BrowserHttpWebRequest (the default stack) 
-Client browser is IE8 with SL4 GDR1 or later runtime 
-A poll completes after ServerPollTimeout and there is no content to consume by the client

Should you have all these conditions filled the client channel will fault. The issue will not manifest if you use any other browser.

After giving a presentation on building premium media experiences up in Seattle earlier today, I'm sitting in SeaTac airport right now on a lengthy delay due to bad weather in San Francisco. I'm flying Virgin America, and the folks at the desk let us know that our 7:00 flight will likely be delayed until 10:20 due to weather. However, since the weather could change at any moment, the flight may take off at any time, and we should check in every 15 minutes to make sure we don't miss the flight. So, that means that not only is my flight delayed for 3 hours, but I'm stuck in the boarding area.

The agent (who I later learned is named Angie), also announced "Please check in every 15 minutes – we'll do everything we can to notify you if the departure time changes." I rolled my eyes at this statement – how many times have I heard airlines promise to do "everything they can" for me, when they actually mean they'll do absolutely nothing for me? Feeling a bit snarky, I walked up to Angie and told her that I'd like to go get some dinner at a restaurant in the airport. I asked her whether she would send me a text message if the departure time changed. She replied, "I can't text you, but I'd be happy to call your cell phone!"

I was floored. Perhaps I'm too jaded an air traveler, but it's so rare to hear a high-level promise like that from an airline and actually see people on the ground follow through on it with such personalized service. I happily went on my way to a nice relaxed dinner, and despite the nasty delay that will get me into SFO after the BART stops running, I feel like a very happy customer right now.

One of the greatest advantages that small companies in insurgent positions in the market have over their larger competitors is the ability to discard far-reaching policies and bureaucratic edicts. Instead, these smaller, more agile organizations can empower their employees on the ground to adapt to the situation at hand, and just do whatever it takes to delight each customer they encounter. These type of organizations understand that the best marketing mechanism they posses are the daily interactions they have with each of their customers. To quote Cake, these organizations "use a machete to cut through red tape".

I like to think that when we at Vertigo interact with our customers, we take a very similar attitude towards the way we work. Not being bound by the restrictive rules typical of a larger organization gives us the freedom to experiment with new approaches that make sense for each client, whether that be a new architecture, unusual support hours, or a design process that eschews the usual conventions. As an organization constantly on the leading/bleeding edge of new technologies, we're always trying to strike a good balance between breaking new ground and finding an efficient way to put our best practices into place on a larger scale. To me, the key is to preserve the ability of each project team to adapt to the circumstances of their particular client's needs, while still making use of established patterns wherever possible to save time and add polish to existing features.

Hats off to Angie and to Virgin America for continuing to serve as an example for nimble, small organizations who win by delighting their customers!

My wife is a big fan of Lush soaps, and I've noticed that the cans of lush products in our shower had stickers with people's faces on them.

This is what Lush's website has to say about these stickers:

"What has held us together for over 30 years is the pleasure we take from our work. Pouring a soap, mixing a cream, creating a fragrance, or rhythmically pressing 1,000 shampoo bars by hand give our lives meaning. This makes us proud of what we produce and so we like to put our own individual 'mark' on each product before we sell it. The face sticker smiling out at you from every LUSH product tells you when it was made, the 'best before' date, and who was proud to make the product, by hand."

This is a great way to personalize a product and engage with customers. I wasn't surprised to read that this attitude extends to Lush's social media strategy, which uses tools such as Facebook and Twitter to engage on a personal level with their customers. The linked article describes how this approach is handily beating the "Post corporate messaging on Facebook" approach being used by Lush's closest competitor, The Body Shop.

This got me thinking about software, and how we organize teams of people to build it. One of the most important factors in producing high quality software is to ensure that each member of team building it is intrinsically motivated and takes personal pride in the entire product they're producing. In other words, that each member of the team is willing to put their face on a sticker and proudly slap it on their work.

When building complex software systems with large teams, potentially across several different partner companies, one of the keys to bringing together a successful project on time and on budget is the cohesion of all the team members. The biggest pitfall in these large projects is often that each team member or partner company concentrates strictly on the piece of the system they are building, and disconnected silos of functionality end up forming. The left hand doesn't know what the right is doing, and when it's time for all the pieces to come together, they don't!

The way Lush operates ensures that a specific person is responsible for (and proud of) an entire product that they're delivering. This is in contrast to other companies that may see each employee as a siloed station along an assembly line.

Similarly, successful software projects have team members who take ownership of the project as a whole, and not just their silo. People in the mindset of putting a sticker with their face on a product will keep track of dependencies between the different silos, perform testing across multiple partner companies to ensure that the bridge between each component is reliable and proven, and ensure that they're proud of the entire product their team is building, rather than just their specific functional area.

This is one reason that I believe in assigning vertical areas of ownership to each member on a team. If a single person is responsible for an entire feature, from the UI to the middle tier logic to the database, they will know exactly how it is supposed to work, which design makes sense, and will drive the feature to completion and testing. Most importantly, it guarantees that the feature works end-to-end, and drives features to become real and working as fast as possible. Of course, even in the vertical approach, designers will still work primarily on the UI, and a SQL expert may do the bulk of the DB work. The key is that each vertical feature has an owner looking after it, regardless of the owner's particular skill set.

In horizontal areas of ownership, where one person owns the DB, another owns the cloud services, and another owns the UI, a siloed attitude of "that's not in my purview" can arise. There's also no driving force to making a feature work end-to-end, as people can see their part as "complete" even when it isn't wired up and working.

As a project lead, I want to see Jim's face on a sticker slapped on to the "Login" feature, and Mary's face on a sticker slapped on the "Post to Facebook" feature. That lets me know that those features have dedicated owners who take pride in the entire user experience of each part of the application, and who focus on delivering a real, working feature, rather than a disconnected component.

What does your team do to put your faces on the products that you build by hand every day?

When Microsoft announced that this year's Professional Developers Conference would be limited to 1,000 attendees and held on the Microsoft Campus in Redmond, some were surprised at the departure from the typical conference site at the LA Convention Center and the smaller than usual limit on the number of attendees. In fact, the 2010 PDC turned out to be the largest PDC that Microsoft has ever done. By making use of Silverlight and IIS Smooth Streaming technology, Microsoft was able to extend the traditional reach of the PDC to a much larger global audience than had ever previously been possible.

Vertigo is proud to have participated in this groundbreaking event by building an interactive Silverlight Media Framework-based video player and PDC conference application that allowed the widest level of participation ever for a PDC. The online consumption numbers that Steve Ballmer mentioned in his PDC Summary are pretty staggering, considering that only 1,000 people physically attended the conference:

"In addition to more than 30,000 developers at 250 PDC events worldwide, another 100,000 developers viewed the event online using Silverlight, with 10% of the online audience taking advantage of simultaneous translation into Japanese, Spanish, French and Chinese. This is incredible reach."

Beyond this amazing breadth of reach is the depth of participation that the online PDC experience enabled. By integrating real-time Q&A, polls, and Twitter conversations, users watching remotely don't just watch remotely – they actually get to participate in the sessions as if they were right there in the room. Additionally, international users enjoyed simultaneous translation into 5 different languages to allow a level of understanding of the content that may not have been possible outside the online experience.

Let's take a look at some of the features of the application:

Live HD Streaming of 2 Video Feeds per Session with DVR Capability
 

The PDC player shows 2 synced up video feeds simultaneously: the "slide deck/code view" feed, which shows what the presenter is actually doing on the presentation computer, and the feed showing the actual presenter in a smaller video rectangle. These feeds can be swapped so that the more interesting feed can be seen in the larger video window at any time. Users enter live presentations at the live point, but can DVR back to any point in the presentation they wish via the timeline. Users can also use the DVR controls to jump back 15 seconds if they missed something, or to rewind or fast forward while watching the video content.

Live Multi-Language Audio
 

In order to extend the reach of the PDC internationally, Microsoft Studios organized a phalanx of translators in their facility during the conference to provide live audio translation in 4 languages (Chinese, Japanese, French, and Spanish) for each of the 4 sessions – that's 16 different translations happening simultaneously and live. The player allows users to switch seamlessly to an alternate audio track to listen to these translations. This is a huge feature, as it allowed international viewers to understand the content being discussed in a way they may never have been able to except in this unique online experience.

Live Closed Captioning
 

The complement to live audio translation, live presentation of Closed Captions for each of the 4 simultaneous sessions (again provided by the folks at MS Studios) provided a way for users with hearing disabilities or those users who did not have the ability to play audio in their environment to consume the content.

Sharing/Deep Linking

Each of the PDC's sessions can be shared out via Twitter. In addition to this, a specific location within a video can be deep-linked to using the bookmark feature to allow users to direct their colleagues to specific segments of a video covering a topic of interest. For example, here's a deep link to Eric Schmidt discussing the PDC online experience on Channel 9 Live (this is a great discussion of what it took for all the partners involved to make the PDC online event come together). The Channel 9 feed is a 7 and a half hour video, but the bookmark/deep linking allows me to single out the topic within the Channel 9 show that I'm interested in.

Multiple Content Delivery Networks (CDNs)
Because the PDC's online video content is distributed internationally, the team set up a system to identify which CDN would provide the best video delivery experience to the user and have the player select that network as the video delivery endpoint. For instance, users in China were directed to stream video cached by ChinaCache. Users in the United States currently pull video content from Windows Azure's CDN, and live feeds were delivered by Akamai.

Real-Time Polling and Q&A
 

A key goal of the PDC online experience was to allow users to engage with the live sessions and participate in the same way that a user in the same physical room as the session would. To this end, the player allowed users to ask questions and receive back answers, and to participate in polls initiated by the presenter of the session. These were driven by services running on Windows Azure to ensure scalability for a large number of users.

Twitter

The final piece of the puzzle in bringing an online conference into social parity with the experience of physically attending the conference is to allow attendees to engage with other attendees, and to foster discussions and conversations among the audience about the material. Each session at the PDC was given an identifying hash tag, and users could engage in a conversation with each other about the material in real-time as it was being presented via Twitter from within the PDC application. An advantage to the online approach is that these discussions can happen in parallel with the session itself without causing a distraction or interruption to the session (and anything a user might miss while conversing can simply be re-watched by DVR-ing backwards).

Ratings and Metrics

Another key goal of the PDC online experience was to track metrics data about both the health of the video ecosystem (number of video failures, number of video starts, etc.), and the value of each session's content to the users. At the conclusion of each session, users are asked to rate and comment on the session. Here's the cool part: that feedback is then consumed in real-time by the PDC application and used to guide other users to what the community considers to be the most important content. More on this in the next section:

PDC Now

The PDC Now page allowed for a central hub and landing page for the application that guides users to the most valuable content. Live content was always featured front-and-center, but the deep value of this page lies in its display of the ratings and metrics data gathered from all of the active players on the internet. As you can see above, users can browse content based on data such as the most popular or most watched videos, or view sessions based on which were the most highly rated by viewers. The player also displays data about the number of users currently viewing each session (see the yellow arrow above).

Guide

The guide section (of which both a Silverlight and HTML version were built) provided additional ways for users to explore content – by the PDC schedule, by session, or by speaker. While browsing for content on the Guide or PDC Now pages, the active video simply minimizes to the bottom-right corner and continues to play with audio. This allows users to explore content without losing track of the information being presented in their active session.

Skip Into

Each live session begins with a few minutes of video slate while the encoders are fired up but the session has not yet started. However, we don't want users to have to sit though that slate once the session becomes Video on Demand content. We also don't want to spend time editing out the slate, so a solution was devised to allow the player to use a "Skip Into" time to begin the video at the exact time the session actually starts.

Download Materials

Users can access all the relevant Powerpoint decks as well as downloadable WMV copies of the session videos in the Download Materials section.

News Feed

The RSS-based news feed allows users to keep in touch with the latest news from the conference.

Windows Phone 7 App

Vertigo also built a Windows Phone 7 app that allows smooth streaming video content to be viewed using the Silverlight Media Framework for Windows Phone. See Ben Riga's blog post for more details.

Dream Team
Pulling off an event as large and broad-reaching as the PDC online experience is a huge effort involving many partners. For a look at all of the partners involved in this effort and their roles:

• ChinaCache

  Natively delivering content into China via their CDN.

• Azure CDN

  Delivering all on-demand video via the Azure CDN solution.

• MS Studios
  Provided closed captioning, audio translation, and origination of the video streams in Redmond.
  
  
• MS DPE Team

  Organized all partners and deliverables and oversaw the PDC online event operation.

• IIS Media Services Team

  Provided support for smooth streaming technology.

• MS Silverlight Team

  Provided support for Silverlight technology used by the player.

• Evertz
  Manufacturer of the Closed Captioning encoders.

I want to send a big thank you both to the talented designers and developers at Vertigo who helped the PDC application become a reality, as well as all of our partners on this project who worked very hard to make the streaming live video experience itself a reality.

Full Screen
Let's end it with a screenshot of what the player looks like in full screen, where the secondary video transitions to a Picture-in-Picture mode:

I'm proud to announce the launch of Vertigo's latest live HD video experience: NBC's Sunday Night Football Extra 2010!  You can check out the live action every Sunday Night this season.

We first worked with NBC last year, building the Sports Emmy®-nominated SNF Extra 2009 application.  We've since partnered with NBC to build the 2010 Vancouver Winter Olympics video experience, as well as this year's US Open (golf) and Wimbledon live HD video players. Vertigo's team for this project has returned to Sunday Night Football again this fall with the ambition to design the most engaging live sports experience ever created for the web. 

A great way to get a feel for the application in only a couple of minutes is to watch this video http://bit.ly/snfextrapromo, which provides a quick high-level run down of all the features in the application.  For some more depth, let's crack open the application, take a look at some of the goals we set out with, and discuss how we solved some tricky design challenges to create an industry-leading live video experience for the web!

Great looking, High Definition video
Using Microsoft's IIS Smooth Streaming technology and working with our partners at iStreamPlanet and Akamai, the video you see in this player will once again serve as the standard for clean, smooth, multi-bitrate, adaptive HD video on the web.  The core video player is built using the open source Silverlight Media Framework, which Vertigo developed in cooperation with Microsoft.

Picture-in-Picture (PIP)

One of the major goals for this project was to make the entire application more engaging to users.  What better place to start driving engagement than in the actual video being consumed?  The PIP provides the following:

• The PIP control allows viewers to see the action from an alternate camera angle while watching the simulcast feed in the main window. 
• The menu on the PIP provides a streamlined way to switch to another camera angle, or to swap the main video into the PIP and start watching an alternate angle in the main window.
• Great viewing experience: This year, we decided to make the PIP a first-class video player in its own right. 
• Full Screen Scaling: To provide a great experience on televisions and large monitors, the PIP will scale up in size when users move into full screen mode.  This keeps the PIP relevant, even from across the room.
• Draggable: Don't like where the PIP is positioned?  Drag it anywhere you'd like!
• Collapsible: If you'd like a totally clean video experience, you can use the Minus button to collapse the PIP and remove it from your field of view.

  The Ultimate Timeline

One reason that Sunday Night Football is such a fun event to work on is all of the interesting data we have to work with.  One of the biggest challenges we faced was how to visualize all of that data without creating a noisy or distracting user interface.  We also had to envision how to allow users to socially interact with all of this data, and how to create data of their own that might be interesting to their own social circles.  Here's how we addressed these challenges:

• Positional Thumbnail Preview: When mousing over the timeline, the player displays a preview image of what's happening in the video at the point you're hovering.  This allows users to quickly browse an entire game and look for interesting action.
• Play by Play Data: We use team-color-coded markers on the timeline to indicate when key plays occur. When mousing over one of the key play timeline markers, data from the NFL displays inside the timeline preview image indicating the details of the play that happened.
• Deep Linking to Plays: Users can select any point on the timeline to share a deep link into that location within the video with their social network.  This feature allows a user to brag to her friends about a big sack on a 3^rd down on Facebook, or to tweet the location of a close-up shot of a player who attended her high school a few years ago on Twitter. 

     

Flexible Video Modes

We have so much great functionality this year that we faced a major design challenge in deciding where to put it all!  Job #1 of a good online video player is to provide big, beautiful video with minimal distractions and visual noise, but our audience of football fans also loves statistics, social interaction, highlight clips and updates from the sidelines. To have our cake and eat it too, we decided to create 2 video modes: "Big Video", and "Engage". 

The application starts in Big Video Mode, where you get a large space to watch the action with optimal video size and quality.

Big Video Mode:

When you want to dive in to all of the additional content and fun features offered by the player, clicking the reveal button transitions to a (still very respectably sized) video window, exposing all the additional functionality.  This approach allows interaction with the statistics and social features while still watching the video.

Engage Mode:

Multi-speed DVR Controls

To give our users full control over the action, we provide instant replay, slow motion, and 4x/8x fast forward and rewind DVR controls.  Direct every play, see that last catch over and over, and even decide on that last penalty call for yourself!

Twitter Battle

When it comes down to it, football fans tune in to see a battle on the gridiron every Sunday.  To let fans be a part of that battle, we included the Twitter Battle as a leading social feature.

• Users are encouraged to Vote/Tweet for their favorite team.
• "Tug of war" results are shown within the app
• The Tweets contain links back to the player to garner larger audiences and add fuel the battle

 Twitter Integration, Ask Mike Florio

Some of the most popular features in the 2009 SNF application were the interactive Chat with Mike Florio that allowed fans to see their questions answered in real time, and Andrea Kremer's tweets from the sidelines.  However, those features were scattered across the application.  To improve on the concept of interactive Chat with Mike Florio and tweeting with Andrea Kremer, we unified and aggregated all of the Twitter streams including: Q&A from Mike Florio, Andrea's tweets from the sideline, and even stand-out tweets from the fans in the Twitter Battle! 

Highlight Clips

While SNF Extra 2010 gives users greater control than ever over their game experience, sometimes you just want a nice big thumbnail to take you to that last touchdown.  NBC's editors can also use the Silverlight Rough Cut Editor to create drive cut-downs and other aggregated highlight content on the fly. 

Statistics

For those fans that love to keep up to date on all the details, the Statistics section provides in-game updates every 1 minute.

Team Effort
I'd like to thank the entire team at Vertigo for all of your dedication, enthusiasm, and creativity in creating a beautiful, innovative piece of software.  I'd also like to thank our partners at NBC Sports, iStreamPlanet, Microsoft, Akamai, Ascender, Inlet, and TweetRiver for your commitment and expertise that make the Sunday Night Football experience possible!

I turn on a light each night to attract insects for toads (which seems a little odd now that I think about it). The other night I went outside to look at the moon and planets, and I noticed that I had forgotten to turn on the light. On my way back to the house, there were several toads waiting in their usual spot, looking at me wondering what happened to their light.

We came across another red-eyed devil (type of katydid) over the weekend. They are more unique since they are quite large, and very aggressive. When provoked, they rear back in defensive stand and will bite if possible. The bite does not hurt too bad since they don’t inject any type of poison, but can break the skin. Here are photos of one we found before.

I have seen several roadrunners on the land lately. Here is one that jumped up on a fence outside my work window a while back.

At first they were cute, little wild pigs sneaking up to our yard in the late evening eating spilled bird seed and food we put out for the deer. But now they are really a pain… they come up every night, tip over the bird baths, move landscaping rocks around, and root up the plants. I tried larger rocks, but they keep persisting in their quest to root up everything. I can hear them outside my window when working late, mocking me, with their squealy pig laughter while they root up another trailing purple lantana.

Vertigo is in attendance at NAB, where we're talking about our recent work delivering High Definition Media content over the web. You can swing by the Microsoft booth to talk with myself or Mike Moser, where we'll be showing off some cool demos. On Tuesday, we'll run a quick tutorial every hour on the hour demonstrating how to build a SMF 2.0-based video player in just a few minutes.

Also – be sure to check out our video players running in Inlet and Omneon's booths demonstrating live ad insertion.

I just got back into the office after spending a week in Las Vegas for the annual Microsoft MIX Conference. Vertigo had a huge presence at MIX this year, where the media work we've focused on for the last year was on display.  I personally had a great time, and I want to thank everyone who worked hard to make this conference a success!

Here's a summary of the videos on the MIX site that relate to Vertigo's work. 

Keynote:

Smooth Streaming:

Olympics:

Scott and I presented a session focusing on the work we did for the Olympics, how things worked behind the scenes, and why it matters.  You can watch it here:

http://live.visitmix.com/MIX10/Sessions/EX33.

Jason Suess (the Olympics PM at Microsoft) did a presentation focusing on the possibilities that the new open-source Rough Cut Editor provides, and how we used it during the Olympics:

http://live.visitmix.com/MIX10/Sessions/CL26

Silverlight Media Framework:

Eric Schmidt ran a presentation on the Silverlight Media Framework that Vertigo has developed and released on CodePlex:

http://live.visitmix.com/MIX10/Sessions/CL25

• Presentation Deck
• Example Code (Dependencies Removed)
• Download SMF: http://smf.codeplex.com
• Download the Smooth Streaming Media Element here

What exactly is being broadcast live for the 2010 Winter Olympic Games in Vancouver?

It depends on where you live and the relationship to your cable or satellite provider.

First, these tips only apply to U.S. digital Internet broadcast, which NBC has the rights to. Other countries, your mileage may vary since they are negotiated separately with the governing body, the IOC.

A list of all the live events for the US can be found here: NBC Live Full Replays

I can save you some trouble: only hockey and curling are live. That’s about half the competition in terms of hours, but it’s a lot. You will need to navigate the through the “entitlement” process in order to see it. For Comcast, you need your username@comcast.net and password to authenticate. It's a one-time deal, per browser. I know it's a pain, but the live content is worth it.

NBC announced the planned, live digital coverage in a press release on Feb. 8. http://bit.ly/NBCOlyLive. Essentially, 400 hours live, with more than 1000 hours of full-event replays, all in Silverlight.

If you live in the US and you don’t pass the crazy satellite/cable checks, you can still enjoy Olympic content, just not full-replay and live. You can watch all the highlights you want, shortly after the live event.

My favorite highlight so far is the red mitten shortage. Seriously though, this goal shot by US Women's hockey is amazing: http://bit.ly/lamoureuxs.

I hear that Canadian IP addresses will enjoy all the events live, courtesy of CTV at http://www.ctvolympics.ca/. They are using a simliar version of the player Vertigo built for NBC. I think the same goes for Norway: http://www.nrkol.no/index.html.

As we're nearing the opening ceremonies for the 2010 Olympic Winter Games, our team is busy testing failure and recovery scenarios. We want to ensure that even if something goes wrong in our video delivery stream, users will have as seamless an experience as possible, and will have their video quickly and automatically restored. In the event that a catastrophic failure occurs in the video delivery stream, we make several attempts to automatically re-connect to resolve the problem:

Failing that, we provide a means to manually retry the reconnection attempt, or to simply browse to other video content.

In order to test the different scenarios that can lead to these kinds of errors, we often use Fiddler as a debugging tool. We often use the Autoresponder feature to return "502 Unavailable" responses to requests for valid, working video chunks in order to trigger these error scenarios for testing purposes. The other day, I encountered a situation where I needed to trigger an error in full-screen mode. As you may know, in Silverlight full screen mode, clicking on another application outside the full screen Silverlight app will exit full screen mode. I needed to trigger a video failure via Fiddler in full screen mode, but could not use Fiddler without exiting full screen and invalidating my test.

The solution to this problem is to use Fiddler on another computer as a remote proxy. This allowed me to do anything I wanted on my main computer, controlling the responses to the network traffic on another machine. Thanks to Olga Lepekhina and David Woods for pointing me to this solution.

To make it work, open up Fiddler on another computer on your network. Open up Tools -> Fiddler Options, and open the Connections tab. Check the box for "Allow remote computers to connect", and restart Fiddler:

On your main computer, go to Internet Explorer's Internet Options and click the LAN settings button on the Connection tab. Check the "Use a proxy server for your LAN" box. You can then enter the IP address of the other machine (the one running Fiddler), along with port 8888. (You may need to click the Advanced button to enter these settings).

This works in Firefox too, via a similar procedure:

Last month, our team at Vertigo announced the release of the NBCOlympics.com HD video player and Deep Zoom photo experience powered by Vertigo for NBC's coverage of the 2010 Olympic Winter Games. These players are live today, and you can use them to explore a wide range of content from previous years, as well as interviews with athletes and other previews. See our post here for the full details.

Our team is pleased to announce that an additional set of features was released last week! A dive into those new features appears in the second part of this post.

Part 1: Original Features

The video and photo experiences for NBCOlympics.com released in November featured:

Video Experience

• HD-quality video using Microsoft's IIS Smooth Streaming Technology
  Gorgeous HD-quality video in full 720p, streamed in a manner that adaptively adjusts to any connection speed.
  
  
• DVR "Trick Play" control
  Direct your own video experience using slow motion, fast forward, and rewind. The "dongle" control also allows for more fine-grained control to find the exact moment you're looking for.
  
  
• Rich Data Integration
  Go deep and find out all you need to know about every key play with Key Events and Play by Play data, including a fully interactive video timeline.
  
  
• Embedded Player
  Embed a lightweight version of our player in your blog!
  
  
• Advanced advertising integration
  A sophisticated advertising engine that includes support for DVR functionality. This also includes capability for affiliate branding integration.
  
  
• Error handling and recovery
  We've put a great deal of effort into ensuring that the video our users experience is delivered in a highly reliable manner. If something goes wrong, our player has a lot of smarts built in that allow it to analyze problems and quickly recover or offer other options for viewing.
  
  
• Logging
  The NBCOlympics.com player powered by Vertigo will be one of the best instrumented web applications ever built. With so many users connecting to so much video, it is important to keep close tabs on everything that's going on. We're using the following logging providers:
  • Conviva for real-time health monitoring
  • Omniture and Quantcast for metrics and activity tracking
  • Nielsen for usage tracking
  • Microsoft for video health logging
    
    
• Alerts
  Stay up to date with the latest events.
  
  
• Boss Button
  Because sometimes it's just too tempting to watch all that great content even when you're at work…

Photo Experience

• Slideshow mode allows easy one-by-one viewing of automatically advancing galleries.
• Grid Mode allows free-form and quick navigation of larger galleries.
• Scroll to zoom in and out of photos

Part 2: Extra Feature Set Released Last Week

This set of improvements consists of a range of goodies that enhance the video experience by allowing you to explore the tremendous amount of content available much more deeply. Let's take a look:

Support for live video
The opening ceremonies on February 12th are almost here, and the player is now ready to handle streaming of live coverage of the Olympic games!

Video Content Explorer
The video content explorer (accessible from the "Explore More Videos" button) allows users to view the full range of Olympic video content within the full screen mode of the player. You can explore videos recommended to you based on what you're currently watching, the most popular videos across the site, featured videos, or hot clips under "Must See".

Top Athletes
The Top Athletes tab allows you to explore video content from a different angle – you can browse through your favorite international athletes and find all of their related video content.

Sports
Similarly, the sports tab allows you to explore videos within a specific Olympic sport.

Schedule
When the Olympic games start, there will be a lot of activity to keep track of! Found in the "Inside This Video" overlay, the schedule view allows a time/schedule-based approach to exploring video content, and also provides a glimpse of upcoming events.

Related Athletes
If you're interested in more information about the athletes participating in the video you're watching, you can find full details in the Related Athletes pane, accessible from the "Inside This Video" overlay. If you want to explore even further, you can flip over each athlete's "trading card" to find a list of all videos in which they appear.

Twitter
Keep tabs on the latest community buzz about the event you're watching with the built in Twitter client.

I'd like to send a big thank you out to everyone on Vertigo's Olympics team as well as our partner organizations for their dedication and hard work in bringing together this unique experience. We're looking forward to seeing it in action during the winter games in February!

It was a good week at PDC09 for the Hard Rock Worldwide Memorabilia application.

At the show, the Surface team dedicated a Surface (sounds kinda repetitive) to all things Hard Rock, which included the custom attract and memorabilia applications Vertigo and Duncan/Channon created with Hard Rock. It was the same Surface experience you’ll get (minus the atmosphere, music, cocktails, food, etc.) when you visit Hard Rock’s new cafe on the Vegas strip.

We also got word that the Worldwide Memorabilia application was runner up in Microsoft’s Touch First Developer challenge.

There were over 40 entries across six different countries. Runner-up … so close. There must be fabulous prizes for runner-up though. Maybe an autographed photo of the Surface team? Or perhaps a toaster. Either would be exciting.

Paul Osburn
Engineering Director

In Windows Vista, it was possible to run as administrator by right clicking on a file and choosing “Run as administrator”. However, it wasn’t possible to run as a different user. When developing software, this can be really useful for testing—seeing if your program works with a specially-configured limited user, for example.

In Windows 7 it appears to be the same issue; here’s the menu obtained by right-clicking in Windows 7:

However, in Windows 7, holding down the SHIFT key and then right-clicking adds a new option: “Run as different user”:

This then allows the execution of the program or file by any user:

Warning:

In the past on x86 Vista, I used the ShellRunAs program from Windows Sysinternals to do this. When I tried this on my x64 Windows 7 machine, I found that it did not work correctly. The program ran, but my program was unable to open its own config file, and so it didn’t run correctly. I’m guessing that this might be an issue with ShellRunAs and x64. Since this functionality is now built into Windows 7 and works with x64, this isn’t really a problem for me.

For a bit more about this, see http://forum.sysinternals.com/forum_posts.asp?TID=19939.

After building Surface applications over the past year we realized that we’ve learned some things along the way. Sharing some of those lessons learned (and documenting them so we can find them later) seemed like the next step. If you can add to or improve upon what we’ll post in the blog, make sure to leave a comment. We like learning new things.

I’m not big on the obligatory ‘first post,’ so I’ll end the introduction there and get right to it.

For one of our projects I needed to create a circular ScatterViewItem that the user could interact with. It should contain everything in it … that is to say, it should clip its contents. A clipping path was the obvious choice.

So I tried using an EllipseGeometry for the clipping path of the ScatterViewItem:

<s:ScatterViewItem Background="DarkMagenta" Width="80" Height="80">
    <s:ScatterViewItem.Clip>
        <EllipseGeometry RadiusX="40" RadiusY="40" Center="40,40"/>
    </s:ScatterViewItem.Clip>
</s:ScatterViewItem>

This works great until you try resizing the item. The clipping geometry doesn’t stay in sync with the ScatterViewItem as the size changes. Makes sense since I’m hard-coding the radius and center values.

As the size of the ScatterViewItem changes we need to update the size and center of the EllipseGeometry. The simplest way I found to do this is to override the GetLayoutClip method for the ScatterViewItem.

protected override Geometry GetLayoutClip(Size layoutSlotSize)
{
    return new EllipseGeometry(
        new Point(layoutSlotSize.Width / 2, layoutSlotSize.Height / 2), 
        layoutSlotSize.Width / 2, 
        layoutSlotSize.Height / 2);
}

Each time the item goes through its layout logic the custom clip will be applied using the current width and height values for the ScatterViewItem. I created a user control and sub-classed the ScatterViewItem. This made it easy to override the GetLayoutClip method.

Using the new custom ScatterViewItem looks like this:

<c:CustomScatterViewItem Background="Chartreuse" Width="80" Height="80"/>

Now I’m able to resize the circular ScatterViewItem and as I resize it, the clipping path is updated as expected. Plus its bright green, which is nice.

Paul Osburn
Engineering Director, Surface

I was bitten by a water moccasin (also called cottonmouth) a while back. The kids and I were coming back from a July 4th fireworks display and decided to stop by a stream to see what was out at the time. We came across a water snake and I thought it would be a good idea to get a better look. I was sure it was a non-venomous water snake so I reached down and picked it up.

I was wrong… I could tell from the burning in my finger and the immediate swelling it was a water moccasin. We drove home to drop off the dog and I told the kids we’ll have to go to the hospital, but it was not serious, I would get some anti-venom and a few aspirin and be sent home.

 
Driving to hospital, hand and fingers starting to swell.

I drove to the hospital which was around 30 minutes away. The swelling increased and my entire hand was swollen. We got to the hospital and the doctor was worried since it continued to swell, now it was half way down my forearm and I could not move my finders. They were worried I would need surgery and called in a helicopter so I could be transported to Austin.

This was unexpected. I asked if I could drive to Austin and they said no, I asked if the kids could fly in the helicopter with me and they said no. This was not good… my wife was out of town, it was midnight, I could hear a helicopter landing outside, and they wanted to know what to do with the kids.

In first hospital, before transferred to Austin. Swelling down to elbow.

They called our neighbor but they did not answer. Luckily they called back and said they would be able to pick up and watch the kids. I said bye to the kids as I was wheeled out of the hospital and loaded into the helicopter. It was an interesting flight into Austin, and also very expensive, it cost $16,000.

The Austin emergency room was really busy and I was in the hallway for 1 – 2 hours. It turns out that hospital emergency rooms are pretty interesting at 1:00am – 3:00am on a Saturday night. My arm was swollen to my elbow and they gave me some morphine. I thought it was supposed to be trippy or something, but it was only scary since it was hard to breathe.

I went to the ICU next even though I was not critical, but they wanted to closely monitor the affects of the venom. There is a concern from swelling but more concern from internal bleeding, organ damage, and permanent tissue damage. I was in ICU for a few days and then released from the hospital since the swelling started to subside and there were not any signs of internal or tissue damage.

The total cost billed to the insurance company was $47,000 and the insurance company allowed $36,000. This included the expensive $16,000 helicopter ride.

It was not the snake’s fault, it was just defending itself from some goof picking it up. There are stories about water moccasins attacking people; it usually happens to a friend of a friend, often times skiing on a lake or swimming in a query, and involves a nest (or colony or pack) of snakes that aggressively attack the victim. This is an urban legend.

• Water moccasins are solitary, they don’t live in colonies or packs.
• They don’t attack, they try to get away and only bite as a last resort (like when someone picks them up or steps on them).
• They don’t repeatedly bite and don’t always inject venom.
• More people die each year from bee stings or falling off ladders. People still have serious problems and permanent damage, but it’s very uncommon to die from a water moccasin bite.

Lessons learned.

• Take a closer look the next time you pick up a water snake.
• Drive yourself to the hospital in a car with automatic transmission if possible.
• Make sure to lock your car when going into the emergency room since it might be sitting there for a while.
• Try to position yourself with a good view when flying in an EMS helicopter.
• Speak up if you take morphine and you can’t breathe, I guess it could be difficult depending how much trouble you have breathing, but wave your arms or something.

Most snakes encountered are harmless and non-venomous, I happen to come across one that was venomous, but it was entirely my fault I was bitten.

'Twelve plus one' contains the same letters as 'eleven plus two'. I did not come up with this, but thought it was interesting.

I'm proud to announce the launch of NBC Sport's Sunday Night Football Extra live HD video experience, designed and built by our team here at Vertigo, in partnership with Microsoft and NBC. Tune in tonight, 2009-09-10 at 5 PT/8 ET to watch the Pittsburgh Steelers take on the Tennessee Titans on NFL opening day. Our team has spent the last couple of months bringing this compelling, immersive video experience to life using Microsoft's Smooth Streaming technology.

Follow the action tonight at http://snfextra.nbcsports.com. Some key features:

• Stunning HD Quality video
Moving to full-screen mode allows you to access 720p at 3.45 Mbps - great looking HD video. Try hooking up your laptop to your TV and watching in full-screen mode!

• Adaptive streaming using Microsoft's Smooth Streaming technology
Your Sunday Night Football viewing experience will be automatically adjusted to best match your internet bandwidth and your computer's performance. If you have a fast internet connection, you'll automatically see the best quality video.

• Live Alternate cameras: Action from any angle
While you watch the action in the main feed, you can keep an eye on four alternate camera angles, showing you the action from the sidelines, the endzone, the center-field cable, or to focus on the stars of the game. You can switch these camera views into the main video window at any time to focus on the details.

• DVR controls give you the power to direct your own experience
With DVR controls such as slow-motion, rewind, fast-forward, and instant replay, you can create your very own Sunday Night Football experience! Want to see an instant replay of that great tackle Bob Sanders made? Want to see Adam Vinatieri split the uprights again in slow motion? Instant response as you move through the timeline.

• Interactive Timeline and Key Plays Menu
That timeline at the bottom of the video is smarter than your average video scrubber bar! The team-colored diamonds surrounding the timeline the key plays throughout the game, allowing you to quickly jump to the action. This markers track the action live, appearing as soon as the action happens in your video. Open the menu to get more details about each play.

• Interactive Q&A with NBC's Mike Florio
Wondering if Peyton Manning will miss Marvin Harrison this year? Chat with NBC's Mike Florio during the game, and have your questions get answered by the experts!

• Stats
Real-time stats data come in live with the game to give you all the info you need.

• Highlight clips
Highlights of the big plays come in soon after the plays happen so you can review all the best moments of the game.

I'd like to send a big thank you out to all the folks on this team and at our partner organizations for all of their hard work in creating this one of a kind video experience!

Obligatory screenshot:

I put on my swimsuit and felt a sharp burning sting. It turns out a scorpion was inside my swimsuit and stung me 3 times in the leg before I could get them off... it could have been a lot worse.

It was a little more serious than usual since my lips were tingling for a while afterwards.

I find scorpions really interesting, it was not their fault, they were just hiding in a nice dark area when some big human distributed their new home. ]]>http://blogs.vertigo.com/personal/KeithC/Blog/Lists/Posts/Post.aspx?ID=44Thu, 06 Aug 2009 17:53:40 GMT0http://blogs.vertigo.com/personal/KeithC/Blog/Lists/Posts/Post.aspx?ID=44#CommentsKeithC

I think Microsoft’s decision to make SQL Azure more like SQL Server (and less like Windows Azure Storage) is great. Relational databases are complex, and having to learn a whole new technology for cloud usage seemed like a very significant barrier to entry. In addition, this makes it much easier to design an application that could be run on-premises or in the cloud—you don’t need a completely different data storage technology. (By the way, I like Azure Storage—it’s just that the previous version of SQL Data Services offered very similar functionality to Azure Storage, and we didn’t really need two of them!)

I’m less comfortable with some of the security aspects of SQL Azure. Specifically, if I understand correctly, developers and DBAs will access their cloud database instance using SQL Server authentication—in short, a username and password.

The issue here is that usually there are a lot of layers of security between attackers and the database in a traditional deployment—for example, usually the database is behind a corporate or hosting firewall. This firewall prevents users from outside the organization from accessing the database instance. Often this firewall needs something like a digital certificate or a smart card to gain access—this makes the firewall fairly formidable to attackers.

However, with SQL Azure, (as I understand it) there is no firewall—the only thing between you (and millions of potential attackers) is a username and password. (Presumably there’s also the equivalent of a database or server name.) The point is that the password becomes very important in this scheme—you should be sure to pick a really strong password. (There’s also an interesting Wikipedia article about strong passwords.)

At least until I understand better, I’d be a bit uncomfortable using SQL Azure for really sensitive data—modern computers and networks are fast enough that even a really strong password just takes time. I’m hoping that I’m being too paranoid here—perhaps there is a whole layer of security in SQL Azure that I’m just not aware of yet. But picking a strong password still never hurts!

Recently Microsoft announced pricing of Windows Azure. There are different pricing models, but the consumption-based model is the one that’s currently well-defined.

I was curious about what all the hourly rates would add up to for a few representative types of sites using Azure. Therefore, created some assumptions about usage for some different types of sites to see what the monthly bill would come out to.

Just to be clear, these are just estimates—for any given application, the monthly charges could be quite different! Also, I don’t have much experience with how much load a single web role in Azure can support, so the estimates about how many would be necessary for a given level of traffic are just guesses.

Small web application

Let’s assume we want to host a small web application on Azure. It only has a few users, but we want it to be fairly available, so we need to have at least two web roles, so when one is updating or the hardware is failing, the other one is available.

Assumptions:

• Web Edition of SQL Azure is sufficient (up to 1 GB database)
• 1000 hits / day
• 2 web roles are sufficient to support the traffic
• 10 KB web site requests
• 100 KB web site responses
• Average of one .NET Services call per hit (for authentication)
• 31 days per month
• Billing does not round up for bandwidth—I have no idea if they do or not, and it’s just pennies either way
• They do round up for .NET Services calls that are less than 100K (it says so on their pricing page)

Total monthly charge: $189.20

Here’s a chart of how the various resources compare in cost for this example:

Medium web application

Assumptions:

• Business Edition of SQL Azure is needed (up to 10 GB database)
• 10,000 hits/day
• 4 web roles are sufficient to support the traffic
• 10 KB web site requests
• 100 KB web site responses
• Average of three .NET Services calls per hit

Total monthly charge: $463.57

Small video delivery site

This is a small site that allows users to watch videos online. I was curious what the costs would be for a site that uses a lot more bandwidth and storage than the examples above.

Assumptions:

• Uses Azuze Storage to store videos
• 1000 hits/day
• 2 web roles sufficient to support the traffic
• 10 KB web site requests
• 10 MB web site responses (a reasonable sized video)
• 100 GB of storage space for videos in Azure storage
• One storage transaction request per web request

Total monthly charge: $240.13

Thoughts

For each of these examples, the web roles dominated the cost—partly because I had at least two of them (see next paragraph). Bandwidth was relatively inexpensive, even for the video site. In addition, the .NET Services and storage costs were relatively low in all of these examples. However, for some sites and services, the bandwidth or other resources might become the dominant cost—for example, a service that mainly served many large videos or files directly from Azure storage. Interestingly, even the business edition of SQL Azure is cheaper than two web roles for a month.

One interesting tradeoff is that you need to have at least two web roles to ensure that your application is available, given failures and updates. For a really small application it seems like overkill (and really adds to the expense if the application doesn’t consume a lot of other resources). However, I’m hard-pressed to imagine a situation, even with a relatively small application, where it would be fine for it to be unavailable for minutes at a time on a relatively frequent basis. Note that you could save quite a bit in hosting costs if you were able to go with a single web role.

Another question is how this compares with traditional, on-premises hosting. It seems like one factor is the timeframe of the deployment. If it’s a very short-lived site (like an event site), then this is incredibly cost effective—you don’t need to buy a bunch of servers and deploy and configure them, but the site isn’t up for long enough to incur huge charges in Azure. For a longer-lived site, it’s not quite so clear cut, but it does still seem compelling, especially considering the level of redundancy and stability that you get.

Yet another question is how it compares with traditional hosting. Generally, it tends to be more expensive than dedicated hosting, but also much more flexible. Often hosting providers require contracts with specific levels of resources—if your needs change, it can be difficult to change the resourcing level—especially if expected demand doesn’t materialize.

I was working with a WCF service client application that failed. First, I had to modify the try-catch and using blocks. Then, I was able to see the real problem.

This came as no surprise to me since it needed to send and receive large amounts of data. I updated my configuration file with a new binding to use 1MB instead of 64KB. (I was using a TCP binding.)

<bindings>
<netTcpBinding>
<binding name="myTcpBinding" maxReceivedMessageSize="1048576" />
</netTcpBinding>
</bindings>

I also updated the endpoint element in the service element by adding the bindingConfiguration attribute with the binding's name as its value. I performed both changes on the client and the server.

However, I still received exactly the same message because changing maxReceivedMessageSize wasn't enough. I also needed to update the maxBufferSize attribute of the same binding element.

<bindings>
<netTcpBinding>
<binding name="myTcpBinding" maxBufferSize="1048576" maxReceivedMessageSize="1048576" />
</netTcpBinding>
</bindings>

My WCF service client kept giving me the generic fault message.

I enabled fault text in the configuration file.

<serviceDebug includeExceptionDetailInFaults="true" />

However, it still gave me the generic fault message. Here's how my client-side code looked.

try
{
using(var client = new ControlServiceClient())
{
client.DoSomething();
client.DoSomethingElse();
}
}
catch(Exception ex)
{
Debug.WriteLine(ex);
}

The problem is the placement of the using block. If one of the methods in it throws an exception, program flow moves to the catch block. However, leaving a using block invokes the Dispose method of the IDisposable interface. In this case, the service client's implementation of Dispose will invoke Close which throws another exception, hiding the first one. To fix it, I moved the using statement outstide of the try-catch block and introduced a call to Abort.

using(var client = new ControlServiceClient())
{
try
{
client.DoSomething();
client.DoSomethingElse();
}
catch(Exception ex)
{
client.Abort();
Debug.WriteLine(ex);
}
}

Invoking Abort does not throw an exception and prevents the Dispose implementation from invoking Close.

While investigating MVVM in Silverlight 2, I came across a problem putting a UserControl in a DataTemplate used by an ItemsControl. I started with the following XAML for the DataTemplate used by my ItemsControl in the page.

<UserControl.Resources>
<DataTemplate x:Key="ListDataTemplate">
<a:DetailControl DataContext="{Binding}" />
</DataTemplate>
</UserControl.Resources>

I don't know why but the data didn't bind correctly in my DetailControl so for every row in the data bound to the list control I ended up with user controls in my list that had no data. Wrapping the user control in a Grid in the DataTemplate corrected the problem.

<UserControl.Resources>
<DataTemplate x:Key="ListDataTemplate">
<Grid>
<!-- Data-binding fails if I don't wrap it in a panel. -->
<a:DetailControl DataContext="{Binding}" />
</Grid>
</DataTemplate>
</UserControl.Resources>

Based on a post by Matt Hawley, I created a few extension methods to the HtmlHelper class to provide resource/localization support.  My version is a little simpler, since it assumes the use of the standard MVC views (WebFormView).  Here are the steps you’ll need to perform to create a similar class.

1. Reference the required assemblies and namespaces
   

   using System.Web;

   using System.Web.Mvc;

2. Declare a static class (I prefer it in the same namespace as the class your extending)
   

   namespace System.Web.Mvc

   {

       public static class HtmlHelperExtensions

       {

       }

   }

3. Create a global resource method; this method will be used to access .resx files in <ApplicationRoot/App_GlobalResources

   public static string GlobalResource(this HtmlHelper htmlHelper, string classKey, string resourceKey)

   {

       object resource = HttpContext.GetGlobalResourceObject(classKey, resourceKey);

       string resourceString = resource as string;

       return resourceString;

   }

4. Create a local resource method; this method will be used to access .resx files in the App_LocalResources relative to your views
   For example: \Views\Home\App_LocalResources\Index.aspx.resx
   Note that the name of the resourse file must match the name of your view!

   public static string LocalResource(this HtmlHelper htmlHelper, string resourceKey)

   {

       WebFormView webFormView = htmlHelper.ViewContext.View as WebFormView;

       if (webFormView != null)

       {

           string virtualPath = webFormView.ViewPath;

           object resource = HttpContext.GetLocalResourceObject(virtualPath, resourceKey);

           string resourceString = resource as string;

           return resourceString;

       }

       else

       {

           return null;

       }

   }

5. Call Html.GlobalResource or Html.LocalResource from your view, depending on which resource you're trying to access
   

   <link href="<%= Html.LocalResource("IndexCss") %>" rel="stylesheet" type="text/css" />

   or
   

   <title><%= Html.GlobalResource("Strings", "ApplicationName") %></title>

If you look closely, you'll notice that the GlobalResource call takes two parameters, the first is the name of the resource file (without the extension) and the second is the resource value to retrieve. The reason for this is because you will very likely have more than one global resource file, and you can specify which file to retrieve resources from this way.

Recently, I encountered a requirement for my WPF application (actually a Surface application) where I needed to navigate between two controls. One control, we'll call it Control1, can be dragged around the screen by the user. The other control, we'll call it Control2, has a similar shape to Control1, but is larger, and has a fixed location on the screen. Essentially, I needed Control1 to morph into Control2.

To summarize the requirements:

• Control1 is moveable around the screen.
• Control2 has a fixed location on the screen.
• Control1 needs to appear to morph into Control2.

I'm using the Model-View-ViewModel pattern for this application, which helps me leverage WPF's data binding support. My hope was that I would be able to implement this transition from Control1 to Control2 by using storyboards and data binding. I wasn't certain, however, that data binding was supported in animation properties.

To fake Control1 growing into Control2, and moving across the screen to its home position, I decided to use an animation of Control2's ScaleTransform and TranslateTransform properties. Since Control1 is moveable, the begin values of the animation must be set dynamically. Hopefully, I would be able to bind the begin points of Control2's animations to properties in the view model of its container. I added a Point property to hold this data, which would need to be set when the user triggers the transition to Control2.

public class ControlContainerViewModel : INotifyPropertyChanged
{
  private Point _control1location;

  public Point Control1Location
  {
    set
    {
      _control1location = value;
      PropertyChanged("Control1Location");
    }
    get { return _control1location; }
  }
} 

The storyboards in the container for Control1 and Control2 are shown below. Notice the highlighted values, which are bound to my Control1Location property. The animation occurs over the span of one second, so notice the KeyTimes of "00:00:00" and "00:00:01". For the sake of brevity, I left out the ScaleTransform animation, as well as KeySplines.

<Storyboard x:Key="TransitionControl1ToControl2">

<!-- Make Control2 visible at the beginning and hide Control1. -->
<ObjectAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Control1" Storyboard.TargetProperty="(UIElement.Visibility)">
  <DiscreteObjectKeyFrame KeyTime="00:00:00" Value="{x:Static Visibility.Hidden}"/>
</ObjectAnimationUsingKeyFrames>

<ObjectAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Control2" Storyboard.TargetProperty="(UIElement.Visibility)">
  <DiscreteObjectKeyFrame KeyTime="00:00:00" Value="{x:Static Visibility.Visible}"/>
</ObjectAnimationUsingKeyFrames>

<!-- Animate Control2 from Control1's position to its home position. -->
<DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Control2"
Storyboard.TargetProperty="(UIElement.RenderTransform).(TransformGroup.Children)[3].(TranslateTransform.X)">
  <SplineDoubleKeyFrame KeyTime="00:00:00" Value="{Binding Path=Control1Location.X}"/>
  <SplineDoubleKeyFrame KeyTime="00:00:01" Value="0"/>
</DoubleAnimationUsingKeyFrames>

<DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Control2"
    Storyboard.TargetProperty="(UIElement.RenderTransform).(TransformGroup.Children)[3].(TranslateTransform.Y)">
  <SplineDoubleKeyFrame KeyTime="00:00:00" Value="{Binding Path=Control1Location.Y}"/>
  <SplineDoubleKeyFrame KeyTime="00:00:01" Value="0"/>
</DoubleAnimationUsingKeyFrames>

</Storyboard>


<Storyboard x:Key="TransitionControl2ToControl1">

<!-- Animate Control2 to Control1's position. -->
<DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Control2"
    Storyboard.TargetProperty="(UIElement.RenderTransform).(TransformGroup.Children)[3].(TranslateTransform.X)">
  <SplineDoubleKeyFrame KeyTime="00:00:00" Value="0"/>
  <SplineDoubleKeyFrame KeyTime="00:00:01" Value="{Binding Path=Control1Location.X}"/>
</DoubleAnimationUsingKeyFrames>

<DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Control2"
    Storyboard.TargetProperty="(UIElement.RenderTransform).(TransformGroup.Children)[3].(TranslateTransform.Y)">
  <SplineDoubleKeyFrame KeyTime="00:00:00" Value="0"/>
  <SplineDoubleKeyFrame KeyTime="00:00:01" Value="{Binding Path=Control1Location.Y}"/>
</DoubleAnimationUsingKeyFrames>

<!-- Make Control1 visible and hide Control2 at the end of the translation animation. -->
<ObjectAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Control1" Storyboard.TargetProperty="(UIElement.Visibility)">
  <DiscreteObjectKeyFrame KeyTime="00:00:01" Value="{x:Static Visibility.Visible}"/>
</ObjectAnimationUsingKeyFrames>

<ObjectAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Control2"
    Storyboard.TargetProperty="(UIElement.Visibility)">
  <DiscreteObjectKeyFrame KeyTime="00:00:01" Value="{x:Static Visibility.Hidden}"/>
</ObjectAnimationUsingKeyFrames>

</Storyboard>

So as long as I set the value of the Control1Location property before starting this animation, it should all work…right?

It turns out that this almost worked. For some strange reason, the storyboard properties do not seem to know they're bound until the second time the animation is run. I tried every way imaginable to notify the UI that the property was set, but each time the animation was first run, the bound animation keyframe values were 0.0, which I assume meant they were unset. The second time running the animation, the set values would be bound correctly. The issue wasn't related to raising the PropertyChanged event a second time—just running the animation a second time.

By much trial and error, I discovered an admittedly hacky way to apparently get the binding to "wake up" before running the first animation.

// HACK: This is a hack to get the storyboard bindings to "wake up" for first time use.
// Without it, the first run of the storyboards does not seem to respect the bindings.
// Any subsequent run of the storyboards works correctly.

BindingOperations.IsDataBound((Storyboard)Resources["TransitionControl1ToControl2"],
    Storyboard.AccelerationRatioProperty); // Arbitrary property.

BindingOperations.IsDataBound((Storyboard)Resources["TransitionControl2ToControl1"],
    Storyboard.AccelerationRatioProperty); // Arbitrary property.

It seems that calling any of the static BindingOperations methods against the two storyboards causes the binding to wake up. I chose a lighter-weight method IsDataBound(), and picked an arbitrary property that was not used in my storyboards. I'm convinced that this same wake up is occurring on the first run of the animation, but by calling a BindingOperations method we're forcing the wake up beforehand.

Okay, it's not pretty, but it gets the job done. J

Lately, my eyes have been feeling a lot of strain after hours and hours of developing everyday which has also led to headaches. I didn’t used to have this problem but I guess age is finally catching up to me. After doing some research I realized that this is a very common problem but there are some solutions (of varying success). Some people who suffer from chronic eye strain due to heavy computer use recommend taking frequent breaks away from the monitor. Others recommend tweaking the brightness, contrast and gamma of the computer’s video output until you find that magical setting that is easy on the eyes yet doesn’t destroy the quality of the image – not easy to do. After having tried both of those recommendations, the strain on my eyes did get a little better but only slightly so. Then I heard about Gunnar Optiks glasses.

It might seem a little strange to wear what are basically sunglasses while sitting at your computer but the concept is very similar to sunglasses that you wear while outdoors which protect your eyes from harsh light and ultra-violet radiation from the sun. The Gunnar glasses help protect your eyes from harsh indoor fluorescent lights and the light emitted by your computer monitor. I can’t honestly say that I understand exactly how they work but I can honestly say that they do work, almost completely eliminating the eye strain I used to feel.

Not everything is rosy with these glasses however. For one thing, the price is pretty steep. The particular model of glasses I purchased on Amazon.com was $120 which seemed a little crazy to me at the time. However, if they help keep my eyes healthy and allow me to sit for longer periods at the computer without needing to take a break then they will pay for themselves very quickly.

The other problem I have with the glasses is the yellow tinting which is not distracting at all but does slightly discolor what I’m looking at on screen. If I’m working on something which requires that I get the color precisely right then I need to pull the glasses down briefly. It’s not a huge problem for me but something to keep in mind if you’re a graphic designer for whom precise color is very important.

I should also say that I wear contact lenses and the glasses in no way interfere with them. In fact, one of Gunnar’s advertised benefits is that the curvature of the lenses and the frame causes the humidity around your eyes to rise slightly so they don’t get dried out as easily. I can’t attest to whether this is true but I’ve never had a problem with dry eyes.

So, the upshot of all this is that I would strongly recommend these glasses to anyone who uses a computer for 6+ hours per day and already has a problem with eye strain or suffers from light sensitivity. They did take me a couple of days before I felt comfortable using them on a regular basis but now I can’t imagine sitting at the computer without them.

http://www.gunnars.com/

A Silverlight project I'm working on fell victim to "Ugly American Programming" this week – we neglected to thoroughly test the application in non-English languages. This is particularly important for Rich Internet Applications that run on each user's client machine. Each user can have a different culture set in the Regional and Language Options, which looks like this in Vista:

The problem we ran into was that European users were getting a FormatException when executing double.Parse(value) where "value" was set to a decimal number such as "0.05".  In European cultures, double.Parse() expects a comma in lieu of a decimal. For example, when I change my regional settings from English to French, the format for decimals changes from "X.Y" to "X,Y". 

English:

French:

It's good practice to always specify "CultureInfo.InvariantCulture" as a second argument to double.Parse() to avoid these problems:

double.Parse(value,CultureInfo.InvariantCulture);

I should really know better – I see this number format every day on my drive in to work courtesy of the folks who programmed my Swedish car:

One aspect of software development that we at Vertigo strive for is making the workflow between engineers and designers as efficient as possible. For a Silverlight or WPF project, this means engineers should write their UIs to editable in Expression Blend. A designer can then create the visual design by using Blend to edit the same codebase that the engineers are working on. This is a more efficient workflow than having designers feed engineers large chunks of tool-generated XAML to be manually migrated into the "dev" codebase.

Hopefully, soon, I or some of my colleagues will begin posting about some of the core concepts required to make a Silverlight or WPF project "Blendable." Unfortunately, this post is much less interesting.

Here's the problem I encountered: All of a sudden, some of my previously-Blendable WPF controls woudn't load in Expression Blend.

The exception displayed in the Blend designer window was something like "could not find resources/mycontrolname.xaml." For the life of me, I and my colleague could not figure out what we did to break Blendability.

Here's a short list of commonalities between the controls that broke:

• They are SurfaceUserControls (user controls for the Surface PC).
• They load "design-time" data when viewed in design mode, such as Blend or Visual Studio's designer (Cider).
• They contain FlowDocument viewers (one contains a RichTextBox and one contains a FlowDocumentScrollViewer).
• The FlowDocuments loaded into the viewers are constructed by loading loose FlowDocument-compliant XAML with the XamlReader.Load() method (System.Windows.Markup).

I'm not sure what exactly was causing the issue, but here's the solution that fixed the problem:

Uninstall Windows Update KB 962902, which is Expression Media 2 SP2.

That was it. If anyone has any knowledge of this issue, please let me know. Thanks!

This morning, I participated in the MSDN DevCon (http://msdndevcon.com/Pages/SanFrancisco.aspx), talking about our experience with WPF.

Family.Show v3. You can find the latest build, released today, at http://www.vertigo.com/familyshow.

Tim Sneath's announcement is here: http://blogs.msdn.com/tims/archive/2009/02/23/announcing-family-show-v3-our-wpf-reference-application.aspx

WPF Samples and XAML Cheat Sheet. I’ll get this packaged up and uploaded tonight.

MIX ‘09. I showed some great WPF samples from the MIX 10k Challenge. My favorites were Jags 10K, Typist, and Forest (WPF). My top two Silverlight entries were Chain Reaction and the Genetic Algorithm simulator.

WIN 7. I showed the crazy-boot-off-the-VHD feature in Win7. I love it. It’ll be a good week before I can figure out the steps to blog about it, but in the meantime, know that Windows 7 is coming, and it looks great.

Recently, I’ve been creating a simple Silverlight app to display a bunch of weather images because, living in Florida, it’s always good to know what kind weather might be coming your way. Basically, there are a number of public images I want to display such as national weather fronts, webcam images from the beach and visible/infrared satellite maps which are all publically accessible URLs. Silverlight has a handy Image control with a Source property so I figured it would be very easy to add a bunch of these to a Silverlight control and either manually or automatically update them.

However, one thing I quickly realized was that the images were not being updated even though my app was definitely requesting the latest image from the server. A brief debugging session revealed the problem: even though I was telling the Image controls to reload their Sources, no outbound URL request was ever being made after the first one. A little Googling led me to the discovery that Silverlight practices automatic image caching which is nice except that there appears to be no way to turn it off.

While image caching is probably the appropriate behavior under most circumstances, there are some situations such as mine and maybe some financial apps in which you want to be displaying the most up-to-date image from the requested URL. Microsoft should have provided a switch to turn caching off completely or maybe just on a per-request basis.

So this was an annoying setback but there is a pretty simple solution. It appears that Silverlight simply uses the URL of the image as the caching key so all you really need to do is change the URL slightly while still giving the web server the correct information about the image you want. The easiest way to do that is to append a querystring parameter that is never the same, such as a GUID or an integer counter. Really it could be anything but I find that appending a GUID is the simplest method and pretty much guaranteed to always be unique within this context.

In order to test this I created a small Silverlight app with 2 Buttons and an Image control. One button requests an image using the same URL all the time and therefore will always get the image from the cache after the initial request. The second button appends the GUID to the image’s URL and tricks Silverlight into thinking that it’s a request for a different image than what is already in its cache.

Here is the XAML and code-behind for the control:

   1: <UserControl x:Class="SLWxControl.Page"

   2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 

   3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 

   4:     Width="700" Height="520">

   5:     <Grid x:Name="LayoutRoot" Background="LightSlateGray">

   6:         <Grid.RowDefinitions>

   7:             <RowDefinition Height="50" />

   8:             <RowDefinition Height="*" />

   9:         </Grid.RowDefinitions>

  10:         <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">

  11:             <Button Name="btnReload" Width="120" Height="30" Content="Reload" Grid.Row="0" 

  12:                     Click="btnReload_Click" />

  13:             <Button Name="btnReloadNoCache" Width="120" Height="30" Content="Reload (No Cache)" 

  14:                     Grid.Row="0" Click="btnReloadNoCache_Click" Margin="4" />

  15:         </StackPanel>

  16:         

  17:         <Image Name="imgBeach" Grid.Row="1"/>

  18:     </Grid>

  19: </UserControl>
 

   1: public partial class Page : UserControl

   2: {

   3:     private const string IMAGE_URL = 

   4:         "http://sciencecentercam.fas.harvard.edu/axis-cgi/jpg/image.cgi?resolution=hugesize&camera=1&compression=50";

   5:  

   6:     public Page()

   7:     {

   8:         InitializeComponent();

   9:         LoadImage(true);

  10:     }

  11:  

  12:     private void LoadImage(bool allowCaching)

  13:     {

  14:         string imageUrl = (allowCaching) ? IMAGE_URL : string.Format("{0}&guid={1}", IMAGE_URL, Guid.NewGuid());

  15:         imgBeach.Source = new BitmapImage(new Uri(imageUrl, UriKind.RelativeOrAbsolute));

  16:     }

  17:  

  18:     private void btnReload_Click(object sender, RoutedEventArgs e)

  19:     {

  20:         LoadImage(true);

  21:     }

  22:  

  23:     private void btnReloadNoCache_Click(object sender, RoutedEventArgs e)

  24:     {

  25:         LoadImage(false);

  26:     }

  27: }

The only problem I can see with this solution is that Silverlight will continually cache these images so this might cause a dramatic memory leak in the app which could be very bad. I have yet to figure out how to manipulate the cache or whether it’s even possible to do so. If it is possible then the preferred solution might be to check for the existence of an image in the cache first and then delete it before trying to request an updated image from the server.

Beauty is more important in computing than anywhere else in technology because software is so complicated. Beauty is the ultimate defense against complexity.

—David Gelernter, Machine Beauty: Elegance and the Heart of Technology

Microsoft recently released the final versions of their unit testing components for Silverlight 2. While Scott Guthrie and Jeff Wilcox have blogged about it, their blogs targeted pre-release versions (specifically Beta 2), and things have changed quite a bit since then. I've been working on some cross-cutting Silverlight classes recently, and thought I would take the opportunity to build some unit tests for what I was working on. It turns out that configuring a unit testing environment isn't very straightforward, so I thought I would provide an updated (and simplified) set of instructions here.

Step 1: Download the Silverlight Toolkit Source

1. Head over to http://www.codeplex.com/Silverlight
2. Under the Get Started section, click the Download the latest release link
3. Download the Silverlight Toolkit - Binaries, Samples, Documentation, Unit Tests and Sources

Step 2: Update your Silverlight installation with the unit testing binaries

1. Navigate to the Source\Binaries folder of the extracted Silverlight Toolkit source downloaded in Step 1
2. Copy the Microsoft.Silverlight.Testing.dll and Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll files to the C:\Program Files\Microsoft SDKs\Silverlight\v2.0\Libraries\Client

Step 3: Download the Silverlight Unit Test Framework

1. Go to http://code.msdn.microsoft.com/silverlightut
2. Click the download new templates link

Step 4: Configuring Visual Studio 2008

1. Navigate to the extracted Visual Studio Templates downloaded in Step 3
2. Copy SilverlightTestClass_CSharp.zip to C:\Users\<YourUserNameHere>\Documents\Visual Studio 2008\Templates\ItemTemplates\Visual C#
3. Copy SilverlightTestProject_CSharp.zip to C:\Users\<YourUserNameHere>\Documents\Visual Studio 2008\Templates\ProjectTemplates\Visual C#

If you prefer Visual Basic, copy the VB versions to the corresponding Visual Basic template folders.

Step 5: Double-Check Visual Studio

1. Open Visual Studio
2. Select File -> New -> Project
3. Select Visual C#, (the root, not one of the sub-types; this part is critical)
4. Under the My Templates section, select Silverlight Test Project

Hope this helps!

The MSDN documentation is incorrect. In the current released version of Silverlight 2, 2.0.31005.0, you cannot use attribute syntax for the Figures property of a PathGeometry in XAML. For instance, the following will fail, throwing a XamlParseException.

<Path Fill="Black">

<Path.Data>

<PathGeometry Figures="M0,0L9,0 9,9 0,9Z" />

</Path.Data>

</Path>

This is true for path geometries used in clipping regions as well. The following will fail in the same way.

<Rectangle Width="23" Height="23" Fill="Black">

<Rectangle.Clip>

<PathGeometry Figures="M0,0L9,0 9,9 0,9Z" />

</Rectangle.Clip>

</Rectangle>

Instead, you must use the more verbose element syntax.

<Rectangle Width="23" Height="23" Fill="Black">
<Rectangle.Clip>
<PathGeometry>
<PathGeometry.Figures>
<PathFigure StartPoint="0,0" IsClosed="True">
<LineSegment Point="9,0" />
<LineSegment Point="9,9" />
<LineSegment Point="0,9" />
</PathFigure>
</PathGeometry.Figures>
</PathGeometry>
</Rectangle.Clip>
</Rectangle>

This is not true for the Data property of a Path. The following will work as expected.

<Path Fill="Black" Data="M0,0L9,0 9,9 0,9Z" />

I recently attempted to add keyboard support for deletion to a DataGrid control in a Silverlight application.

To help decide which event I should use—KeyUp or KeyDown—I decided to see how Microsoft Excel handled the Delete button. A quick test revealed that Excel deleted on KeyDown, and I figured if it was good enough for Excel, it was good enough for my app.

Therefore, I coded up the Delete button to use the KeyDown event, and (thoughtfully) added a confirm MessageBox dialog for the user asking if they actually wanted to delete the item. However, as soon as I started testing it, I noticed that it worked fine in Firefox but it would sometimes cause IE to crash and close.

After doing some debugging, I found that a serious-sounding exception (System.ExecutionEngineException) was getting thrown at the MessageBox.Show call (here it is recreated in a new project):

My first thought was that it was a bug with IE—mainly because of the violence of the crash. However, at lunch, I mentioned this to a colleague, and he mentioned that a crucial difference between KeyUp and KeyDown is that KeyDown repeatedly fires as long as the key is held down, whereas KeyUp does not. He suggested that the exception (and subsequent browser crash) might be caused by multiple events being fired.

A bit more research revealed that this was the issue. I was getting multiple events fired from the KeyDown, which were then trying to display more than one MessageBox at the same time. Since the MessageBox is modal, only one can be displayed at a time, and trying to display another caused the error.

Changing to the KeyUp event fixed the entire issue!

A common user interaction is the humble MessageBox. Doing a quick web search of “silverlight messagebox” tends to produce a number of results lamenting how MessageBox is not available in Silverlight, and discussing various techniques to simulate a MessageBox.

While it’s true that there wasn’t a MessageBox until the Release Candidate, there IS a MessageBox class in the final (RTW, Release To Web) version of Silverlight 2.0!

It’s System.Windows.MessageBox. It’s a bit limited:

• It doesn’t display an icon on Windows (although according to the docs, the Macintosh version does display an icon!)
• It offers a choice of a single button called OK or two buttons: OK and Cancel.

One nice part of the MessageBox is that it allows customization of the title bar text (unlike the Javascript alert() and confirm() dialogs). And it’s a bit less code than other alternatives, and it’s more visually consistent across various browsers than the Javascript alternatives. Here’s the code to generate a MessageBox with all the options:

MessageBox.Show("This is the messageBoxText",
                "This is the caption", 
                MessageBoxButton.OKCancel);

This renders like this on Windows Vista:

If you only want the OK button, just pass MessageBoxButton.OK as the last parameter:

Finally, there’s a simpler overload that only takes the messageBoxText:

MessageBox.Show("This is the messageBoxText");

This generates a MessageBox with only the OK button and no text in the title bar:

In addition, the Show method returns a MessageBoxResult, which has the following values: OK, Yes, No, Cancel, None. According to the docs, the Yes, No, and None values are currently unused. (This makes sense, as there are only OK and Cancel buttons.)

Here’s a link to the documentation: http://msdn.microsoft.com/en-us/library/system.windows.messagebox(VS.95).aspx

<StackPanel Name="ThePanel" Orientation="Horizontal">
    <Rectangle Width="50" Height="50" Fill="Red" />
    <Rectangle Width="50" Height="50" Fill="Orange" />
    <Rectangle Width="50" Height="50" Fill="YellowGreen" />
</StackPanel>

void SaveImage(Visual visual, int width, int height, string filePath)
{
    // generate the image
    RenderTargetBitmap bitmap = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32);
    bitmap.Render(visual);

    // create image file
    PngBitmapEncoder image = new PngBitmapEncoder();
    image.Frames.Add(BitmapFrame.Create(bitmap));
    using (Stream fs = File.Create(filePath))
    {
        image.Save(fs);
    }
}

// full path to the image
string filePath = Path.Combine(System.Environment.CurrentDirectory, "sample.png");

// generate image from XAML element
SaveImage(this.ThePanel, 500, 500, filePath); 

// full path to the image
string filePath = Path.Combine(System.Environment.CurrentDirectory, "sample.png");

// create instance of control
Button button = new Button();
button.Content = "Nifty Button";

// layout control before generating image
button.Arrange(new Rect(0, 0, 500, 500));

// generate image from XAML element
SaveImage(button, 500, 500, filePath); 

We’re taking one of our Microsoft Surface units to the Silicon Valley Code Camp tomorrow. As a Platinum Sponsor, we have our own room to do some show-and-tell. Since we’re expecting a big crowd (over 1200 people have registered!), we wanted to create a space that allows a lot of people to join in.

Jack and Paul S. are “painting” on the Surface unit. Overhead, a Canon HF-10 HD camera captures the action, sending the output over HDMI to the Sony 42” LCD TV. Alan can see the hands over the Surface as well as what’s shown on the Surface.

Paul O. is at the helm, driving the code demos on the attached keyboard and LCD. He can toggle the TV between the HD camera and the code shown on his screen. This way the audience gathered around can see how we’re building our demos.

The Fishman SoloAmp PA on the far left ensures we don’t have to yell! We’re doing these demos all day Saturday and don’t want to lose our voices.

I’m also bringing my Segway.

A couple of weeks ago I got one of those tiny Asus EEE PCs which is in the new class of computers called netbooks. It’s pretty small and light but just large enough to be really useful as a laptop. Originally, it came loaded with Linux which I left on for about a day before I longed for some of my regular Windows apps. So I dug out the product key for an old Dell laptop that I no longer use and installed Windows XP Pro on the netbook. While very slightly slower than the Linux that was on there before, the performance of XP on this machine is perfectly acceptable for my uses which are browsing the net, watching videos and reading books in PDF format.

Not being a big fan of XP anymore, I did try putting Vista on the Asus but it just felt a little too sluggish for my taste. However, watching the Windows 7 keynote on Tuesday morning I was a little stunned to see Steven Sinofsky show a netbook running the new OS. Actually, I was stunned, then skeptical and then finally curious. So I got my hands on a copy of the PDC build of Windows 7, first noticing that it was actually several hundred megabytes smaller than Vista 32-bit with SP1 integrated.

Playing it safe, I began by installing Windows 7 into a virtual machine with only 1GB of RAM allocated just to become familiar with the OS and see how it performed within those memory constraints. My first impressions were that it didn’t look terribly different from Vista but also that it was a very snappy OS even with just 1GB of RAM. Having installed Vista in a similar environment, my unscientific opinion is that Windows 7 is at least as fast as Vista and perceptibly faster.

So, having been satisfied with Windows 7 in a virtual sandbox, I was now ready to install it on my netbook… at 10 o’clock at night. I tried to keep my expectations low because I wasn’t even sure I would get past the initial setup dialog. Happily, the install proceeded quickly through selecting the partition for installation and then copying/expanding the files. However, it soon got bogged down during the later stages of installing and configuring the OS, sometimes spending upwards of 10 to 20 minutes displaying nothing but a blank screen and an intermittent blink of the hard drive light. Trying to be patient, I just let it run and it eventually appeared to install and then rebooted. It was now 1am.

After the reboot, something strange began to happen. All I got was a black screen, no hard drive light and no response to keyboard or mouse input. Figuring I was probably sunk, I did a hard reset and got the same black screen. I tried another hard reset except this time I must not have pressed the power button for long enough because it just put the machine to sleep. I believe that sleep is only supported if the OS has working chipset and video drivers so I was a little puzzled. At the very least it showed that it actually did boot into Windows. So I pressed the power button again to wake it up and was relieved to see a login dialog.

After logging in, I got the usual “personalizing” and “configuring” first-use messages so the system wasn’t usable yet. After about another 10 or 15 minutes, I finally got a fully functional Windows 7 desktop. The thing that initially amazed me was that it had Aero running with transparency enabled and I hadn’t even loaded any drivers yet! And even with the maximum eye candy running it didn’t perform too badly. I really had no expectation that my little Asus was capable of running Aero because I only got Vista Basic when I had previously installed Vista. That said, even though the glass effects in Windows 7 looked really nice there definitely was some lag in performance so I left Aero running and just turned off transparency. That allowed me to still enjoy the benefits of video hardware acceleration without the overhead imposed by the glass effects. So the machine was now fully installed and it was just after 2am.

Unfortunately, it wasn’t all sunshine and light because there were some things that just didn’t want to work. Most of the Asus software and drivers wouldn’t install, throwing up a message that the OS wasn’t supported. However, the most important driver (wireless networking) did install just fine, as did the Bluetooth driver. The only things I’m really missing are the shortcut function keys that control the volume. Other than that, I haven’t found much to complain about. A couple of times IE has temporarily gotten into a non-responsive state but there have been no application crashes or incompatibilities and not a single blue screen thus far. I’ll try to install some more software on it later and see where application compatibility begins to break down. It looks like IIS and .NET are installed so I may even try to do some development on it. Curiously, the .NET Framework version is 3.5.1 as opposed to just 3.5.

So my initial skepticism that netbooks could run Windows 7 has quickly gone away. In fact, it appears that Asus is already planning to release a Windows 7 based netbook as early as next summer! As for my Windows 7 netbook, it seems to be just as usable as Windows XP Pro was and is much, much nicer to look at. I was just amazed and impressed that the correct Aero-compatible video drivers were installed by default. I’m definitely keeping Windows 7 on this machine permanently and now I can’t wait for the open Beta early next year!

System Specs

Screenshots

I started going through the Azure SDK and samples last night and got tripped up on a few issues. Here are some of the steps to get started with the basics of Azure development:

1. To get started, you'll need Visual Studio 2008 with SP1 and make sure you also have SQL Server 2005 (or 2008) Express installed with the SQLEXPRESS instance name. The SDK samples require this.

2. Install the Azure SDK from http://www.microsoft.com/downloads/details.aspx?FamilyId=BB893FB0-AD04-4FE8-BB04-0C5E4278D3E9&displaylang=en.

3. Install the Azure Tools for Visual Studio from http://www.microsoft.com/downloads/details.aspx?FamilyId=63D0D248-1B08-4F7D-ABDE-62EB75CB1E69&displaylang=en. Not required to run the SDK samples but you will need to install it to run the hands on lab.

4. Read this page, http://msdn.microsoft.com/en-us/library/dd179419.aspx. The RunDevStore.cmd step is critical because if this fails then nothing else will work. There will be a yellow warning once it gets to the end but you can disregard this. Just make sure there are no red errors.

5. Download, build and run the hands on lab sample from this page, http://mbrownchicago.spaces.live.com/blog/cns!2221DC39E0C749A4!1040.entry?wa=wsignin1.0. It probably will build correctly but throw a runtime error saying that it could not find the Microsoft.ServiceHosting.ServiceRuntime assembly. For some reason this assembly is not installed in the SDK's bin folder but in a ref folder. You can either copy the assembly into the bin folder or add the ref folder into your machine's PATH environment variable.

6. Finally, it probably goes without saying, but run everything with administrative rights.

If all goes well then this is what you should see when you run the hands on lab, with the Development Fabric UI running in the background.

In addition to the samples and hands on lab, you can also learn more about Azure development from online videos such as here, here and here.

Silverlight's Visual State Manager (VSM) exhibited a couple of problems in Silverlight 2 Beta 2 which I described in my earlier blog post. To summarize, in SL2 Beta 2:

1. Radio Buttons, Checkboxes, and ListBoxItems ran into problems when trying to animate the same property for Normal, Mouseover, and Checked states.
2. Animating Brushes was buggy, and caused bad behavior.

So, now that Silverlight 2 has been completed and the final Release To Web (RTW) version is out, do these problems still exist, or have they been solved? Let's find out!

To start with, I upgraded Page Brooks' excellent light bulb demo app to SL 2 RTW. This app demonstrated problem #2 (brush animation bugs) very succinctly. I then added in some code to test out radio buttons to determine if they would still lose their states when animating the same property across multiple state groups. Here's what the test app looks like:

Radio Button Test – Problem #1

To start out, let's take a look at the standard radio button behavior on the bottom radio button:

Normal        Mouse Over    Checked

                
Notice that the Normal and MouseOver states (which are in the same state group – "Common States") animate the background highlighting, and the Checked state animates the black dot in the center. So, the 2 state groups are each modifying a different property, and mousing over a checked RadioButton still animates the background highlighting.

However, many custom controls are built in a way that animates the same property across multiple state groups. Let's see what happens when we do so. The two circles on the top are custom radio button styles, but all 3 radio buttons are in the same group. The custom radio buttons' backgrounds are grey normally. They should turn yellow on Mouse over, and black on being checked. So, I'll mouse over the first radio button:

Now I'll select the first radio button:

So far, so good. However, I'll now mouse over the checked radio button again:

The radio button failed to maintain its checked state, instead applying the mouse over state. When I mouse back out, the checked state does not restore:

So, it seems this problem of animating the same property across multiple VSM state groups still exists in Silverlight 2 RTW.

Brush Animation Test – Problem #2

Moving on, let's test out the brush animation bug. In Silverlight 2 Beta 2, VSM would incorrectly animate changes to the properties (color) of a brush. Every once in a while, the brush color would fail to change. In Page's program, the light bulbs should light up from left to right. A picture of the bug is below:

So, now, let's try it in the upgraded SL2 RTW version of the code:

Moving the mouse very quickly back and forth across the light bulbs produced no errant unlit bulbs at all. It looks like the Brush animation problem has been fixed in the new version of Silverlight!

Just recently, I began getting a JavaScript error whenever I browse our company's SharePoint 2003 and 2007-driven sites. This is the error I was receiving:

No one else in the company seemed to be having the same problem, so I doubt it was caused by a Windows Update. I can think of two possible culprits:

• I recently uninstalled SilverLight 2 Beta 2 and the Visual Studio tools + Expression products, and installed a SilverLight release candidate.
• I recently added Visual Basic to my Visual Studio 2008 Team Suite installation, and re-applied SP1 for VS 2008.

I was also receiving this error on my blog when clicking the link to "Launch blog program to post."

This message is very strange since I'm browsing with IE 7.

It turns out that the solution to the problem was to repair my Microsoft Office 2007 installation. I suspect that the installation of one of the SharePoint ActiveX components (see Jose Baretto's Blog) had become corrupted somehow. My guess is that Stssync, the component used to synchronize Outlook to SharePoint lists, was the culprit, but this is just a wild guess.

Occasionally, differences between the PC and Mac versions of the Silverlight runtime will crop up, and you'll notice that your code works fine on PCs, but has problems on a Mac. If this is the case, you'll need to remotely debug the problem from a PC with Visual Studio, or use Fiddler to scan network traffic.

Remote Debugging

1) First, you'll want to install the Silverlight Developer runtime for the Mac. This will install a Silverlight Debugging configuration tool – run it.

2) When you run this tool, it will setup your Mac to allow debugging via a specific port, allow you to specify a Remote Debugging password, and generate a ConfigurePCForSilverlightDebugging.exe file for you to run on your PC.

3) Copy that .exe file to your PC and run it.

4) Enter the password you entered on the Mac.

5) Your PC is now ready to debug remotely!

6) Now, launch Visual Studio, and select Debug -> Attach to Process.

7) Select "Silverlight Remote Cross-Platform Debugging" as the Transport.

8) Enter the network name of the Mac as the qualifier.

9) Finally, change the "Attach to" option to "Silverlight".

10) You now see all the processes running on the Mac, and you can attach to the one you want.

11) Optionally, you may want to install Remote Desktop for Mac so that you can use the Mac to terminal into your PC, attach the debugger, and then work in the browser from the Mac. This allows you to manage everything you need to do from one location.

Fiddler

Fiddler runs on the .NET Framework, and is generally only useable on PCs. However, you can route the network traffic from a Mac through a port on a PC in order to run a network trace against a Mac using Fiddler. To do so:

1) Open up Fiddler on your PC, and go to Tools -> Fiddler Options.

2) Check the box for "Allow remote computers to connect".

3) Next, on the Mac, go to System Preferences -> Network -> Advanced, and click the Proxies tab.

4) Use a proxy for Web/HTTP, and enter the network name of the PC on which you're running Fiddler. Enter Port 8888.

Now, when you go to a site on the Mac, the traffic should appear in Fiddler on your PC.

For the most part I really like Microsoft Windows. But when something doesn't work the way I expect it to, I often reboot the computer. I'd say it fixes the problem something like 10% to 20% of the time, which is relatively infrequently, but it's so easy to do that it's often the first thing I try.

Recently, we had an issue in a production system where the date format being passed to the database was suddenly different. We had not changed any code, and no updates had been applied to the server for several weeks. Instead of passing the time as "0:00" for midnight, or "12:00 AM", it was passing the time as "12:00", which is noon, rather than midnight. This caused a variety of failures.

We looked into it, and determined that nothing had changed. We could not duplicate the issue with the same code on any other machines--they all worked correctly.

This was all a bit stressful, as the application was significantly reduced in functionality due to the issue, and the clock was ticking.

After a bit, we decided that we might as well reboot the server. This isn't the first thing I try with a production server because it brings it down, and the 10% to 20% payoff isn't high enough to be the first thing to do.

Anyway, we rebooted the server, and it resolved the issue. It actually worked!

A subsequent set of diagnostics on the server revealed no hardware issues with the server. Perhaps an infamous "cosmic ray" flipped a bit in RAM somewhere...

Recently, the team I work with started adding a new Silverlight module to our large web application.

There are lots of great reasons to use SIlverlight:

• Simpler and faster development compared to ASP.NET AJAX
• More responsive user interface, and the possibility of a richer user experience
• Better performance than ASP.NET AJAX with interpreted Javascript
• Less exposure to differences between browsers

However, in the relatively data-centric enterprise web application we're currently working on, we're also starting to notice some of the browser features that we take for granted in an HTML web application that we are missing in Silverlight:

• Copy and paste--users cannot select static text in a Silverlight grid or label and paste it into another application
• Search within a page--users cannot search for a customer name or account number in a large table of data displayed on a page
• Font resizing--users cannot resize the font in a Silverlight control to make it easier to read

All of these can be implemented in Silverlight with custom code, but it ends up being a fair amount of effort, especially the copy and paste across multiple controls, and the searching within a page across all controls.

Just to be clear, what I'm talking about here are the features that are built into web browsers, and therefore are available to all HTML web applications. For example, here's a screenshot of searching for the word "android" in the news.com homepage in Microsoft Internet Explorer 7:

In Silverlight, the browser doesn't have direct access to the content in the Silverlight control, so it cannot search it. This can be useful when you have a list of customers as some part of a workflow page (everyone who is late paying their bill, for example), and you want to find a specific customer by name on the page.

And here's an example of selecting text across multiple HTML tags from news.com:

Here's what I get when I copy and paste this selection:

This week in Apple App Store angst

1 hour, 25 minutes ago

Developers are still wondering what Apple considers improper iPhone applications, and now might not even be able to compare rejection notes in hopes of figuring that out.

(Posted in Apple by Tom Krazit)

Firefox update fixes a dozen flaws

54 minutes ago

Update spans Firefox 2 and Firefox 3 and will be pushed out to current users to take affect the next time the browser relaunches.

(Posted in Security by Robert Vamosi)

Not a perfect reproduction, but good enough for many situations, and great considering that the news.com developers didn't need to do any development to get it working! This type of copy and paste can be crucial when you want to copy a customer's account number into an email or other document without mistyping it, or when you want to copy a larger amount of table data into Excel for some ad-hoc analysis.

The ability to change font sizes is great for accommodating different users--both users who have vision issues (and want a larger font), and for power users with excellent vision who want to fit more data onto their monitors (and want a smaller font).

For some web applications these features aren't important--for example, at home I use my bank's web-based bill pay system, and I've never used any of these features while doing that. However, in an enterprise system with lots of customers, accounts, and information, these features often become very useful.

Does this mean data-centric enterprise applications should not be implemented in Silverlight? Certainly not! (See some of the advantages listed above!) I just want to point out that there are some subtle things that users will lose, and it's important to be aware of these when choosing the technology, and to be prepared to add them in Silverlight if and where necessary.

// get data, could be from an XML file or some other data source
string someNumber = "1.23";
string someDate = "2/15/1564";

// convert data, everything is fine running as English
double number = double.Parse(someNumber);
DateTime date = DateTime.Parse(someDate);

// get data, could be from an XML file or some other data source
string someNumber = "1.23";
string someDate = "2/15/1564";

// not good, returns 123.0 instead of 1.23 when running as Dutch
double number = double.Parse(someNumber);

// not good, throws a FormatException when running as Dutch
DateTime date = DateTime.Parse(someDate);

// get data, could be from an XML file or some other data source
string someNumber = "1.23";
string someDate = "2/15/1564";

// good, returns 1.23 when running as Dutch
double number = double.Parse(someNumber, CultureInfo.InvariantCulture);

// good, returns correct date when when running as Dutch
DateTime date = DateTime.Parse(someDate, CultureInfo.InvariantCulture);

• Run Regional and Language Options from control panel.
• Select the Formats tab.
• Select a language such as Dutch (Belgium) under current format.
• Press Apply.
• Run your application and test.

public MainWindow()
{
    InitializeComponent();

    // subscribe to events raised by any child, Child Control is a Button in this example
    this.AddHandler(Button.ClickEvent, new RoutedEventHandler(ChildClicked));
}
        
private void ChildClicked(object sender, RoutedEventArgs e)
{
    // called when event is raised by any child
}

<Window x:Class="WpfEvents.MainWindow"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:controls="clr-namespace:WpfEvents"
  Title="WPF Events" Height="200" Width="200"
  Button.Click="ChildClicked">

// hooking up events requires a reference to each control
this.ChildControl1.Click += new RoutedEventHandler(ChildControl1_Click);
this.ChildControl2.Click += new RoutedEventHandler(ChildControl2_Click);
this.ChildControl3.Click += new RoutedEventHandler(ChildControl3_Click);
this.ChildControl4.Click += new RoutedEventHandler(ChildControl4_Click);

• There is only one instance of the Events class in the application.
• It contains a list of global events and helper methods to raise the events.
• Any object can subscribe to events.
• Any object can raise events.
• That means the main page can handle events from any child control, children can handle events from the main page, and siblings can handle events from each other.
• A reference to the control is not required to handle events.
  

public static class Events
{
    // example global event that can be handled by any object in the application
    public static event EventHandler ChildControlClicked;
    public static void RaiseChildControlClicked(object sender, EventArgs args)
    {
        if (ChildControlClicked != null)
        {
            ChildControlClicked(sender,args);
        }
    }
}

// raise global event
Events.RaiseChildControlClicked(this, EventArgs.Empty);

public Page()
{
    InitializeComponent();
    
    // subscribe to global event
    Events.ChildControlClicked += new System.EventHandler(Events_ChildControlClicked);
}

private void Events_ChildControlClicked(object sender, System.EventArgs e)
{
    // called when the event is raised, it could be raised by
    // any object in the application, this object does not need
    // a reference to the object that raised the event
}

• Use Lutz Roeder's Red Gate's .NET Reflector to open the assembly that contains the Silverlight controls. This is %PROGRAMFILES% \Microsoft SDKs\Silverlight\v2.0\Reference Assemblies\System.Windows.dll for now, but can change in the future.

• Open System.Windows.g.resources under Resources.

• Save themes/generic.xaml to a local file.
  

I suggest following the directions found here but if you need a different solution try the following instead.

Add this method to your Silverlight in a convenient place, such as your application class.

public static void OpenBrowser(string url)
{
if(HtmlPage.BrowserInformation.UserAgent.Contains("Safari"))
{
HtmlElement anchor= HtmlPage.Document.GetElementById("externalAnchor");
anchor.SetProperty("href", url);
HtmlElement button= HtmlPage.Document.GetElementById("externalButton");
button.Invoke("click", null);
}
else
HtmlPage.Window.Navigate(new Uri(url, UriKind.RelativeOrAbsolute), "_blank");
}

Then, add this code anywhere in the HTML.

<a id="externalAnchor" style="display:none;"></a>
<input id="externalButton" type="button" onclick="window.open(document.getElementById('externalAnchor').href)" style="display:none;" />

To quote StrongBad, "Scroll buttons never looked so good! Scrollin' up and down like you knew they would..."

Or, perhaps not.  We recently encountered a problem when trying to implement scroll buttons in Silverlight 2 Beta 2 that would: 

1) Smoothly scoll up and down when being held down.
2) Use VSM (Visual State Manager) for MouseOver and Pressed animations. 

Here's how we solved the problem and created scroll buttons truly worthy of some StrongBad adulation:

The problem is that instances of Button controls will never raise MouseLeftButtonUp and MouseLeftButtonDown events.   In other words, Button instances only support handling the Click event directly, not the Mouse Up/Down events.  We didn't want our users to have to repeatedly click in order to scroll - we wanted the scroll button to just smoothly scroll as long as the mouse button was held down.

This Silverlight.NET forum discussion features an excerpt from a help document that describes the behavior:   

"Certain control classes (for example Button) provide control-specific handling for mouse events such as MouseLeftButtonDown. The control-specific handling typically involves handling the event at a class level rather than at the instance level, and marking the MouseLeftButtonDown event data's Handled value as true such that the event cannot be handled by instances of the control class, nor by other elements (at a class or instance level) anywhere further along the event route. In the case of Button, the class design does this so that the event Click can be raised instead."

So, Buttons will swallow the MouseLeftButtonDown/Up events by setting Handled to "true".  

Our first thought was to just use an element (other than Button) which doesn't exhibit this behavior.  However, using VSM requires using an element that has a customizable control template (derives from the Control class), and it seems as if all the controls that can be used by VSM exhibit the same event swallowing behavior as Buttons.   

So, our solution was to build a custom "ScrollButton" class which inherits from Button.  The ScrollButton class overrides the OnMouseLeftButtonDown and OnMouseLeftButtonUp handlers, and resets Handled back to "false" after executing the base method.  This fairly simple change causes the events to fire properly, allowing our scroll buttons to actually scroll when held down.  The code is below:

public partial class ScrollButton : Button
{
     public ScrollButton()
     {
          this.MouseLeftButtonDown += new MouseButtonEventHandler(ScrollButton_MouseLeftButtonDown);
          this.MouseLeftButtonUp += new MouseButtonEventHandler(ScrollButton_MouseLeftButtonUp);
     }

     void ScrollButton_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
     {
          this.Content = "mouse down";
     }

     void ScrollButton_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
     {
          this.Content = "mouse up";
     }

     protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
     {
          base.OnMouseLeftButtonDown(e);
          e.Handled = false;
     }

     protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
     {
          base.OnMouseLeftButtonUp(e);
          e.Handled = false;
     }

}

In Silverlight 2 Beta 2, setting BorderThickness="0" or BorderBrush="Transparent" on a TextBox fails to hide the border around the TextBox.  I couldn't get a TextBox I was building to lose its border:

This seemed like a bug to me, but a Silverlight Program Manager explained it this way in a Silverlight.net thread: 

"The new visual style for TextBox uses gradients inside a Grid. This default style ignores the border thickness and border brush." 

Since this behavior seems to be intentional, a template needs to be used to hide the border.  A poster in the thread above suggests using a ScrollViewer in lieu of the TextBox, and it seemed to work for us:

See below for a quick example of how to implement this. 

Abridged XAML for TextBox: 

<TextBox Style="{StaticResource TextBoxNoBorder}" x:Name="TextSiteURL" /> 

Template for the TextBoxNoBorder style:

<Style x:Key="TextBoxNoBorder" TargetType="TextBox">
     <Setter Property="Template">
          <Setter.Value>
               <ControlTemplate TargetType="TextBox">
                    <Grid x:Name="RootElement">
                         <ScrollViewer x:Name="ContentElement" BorderThickness="0" />
                    </Grid>
               </ControlTemplate>
          </Setter.Value>
     </Setter>
</Style>

While working on Vertigo's high definition video player for the Democratic National Convention, our team encountered some challenges with Silverlight 2 Beta 2's Visual State Manager. In this post, I'll discuss how we overcame these challenges, and our solution to make working with VSM simple, quick, and easy. For an introduction to Visual State Manager, check out Scott Guthrie's Silverlight 2 Beta 2 intro here.

Problem #1: Radio Button and ListBoxItem Selection States

Radio buttons and ListBoxItems both have a "selected" state. The XAML for the VisualStateGroups for a ListBoxItem look like this (the same states are used for Radio buttons):

<vsm:VisualStateManager.VisualStateGroups>
     <vsm:VisualStateGroup x:Name="CommonStates">
          <vsm:VisualState x:Name="Normal" />
          <vsm:VisualState x:Name="MouseOver">
               <Storyboard>
                    <!-- Animate the MouseOver -->
               </Storyboard>
          </vsm:VisualState>
     </vsm:VisualStateGroup>
     <vsm:VisualStateGroup x:Name="SelectionStates">
          <vsm:VisualState x:Name="Selected">
             <Storyboard>
                    <!-- Animate the Selection -->
             </Storyboard>
          </vsm:VisualState>
        <vsm:VisualState x:Name="Unselected"/>
     </vsm:VisualStateGroup>
</vsm:VisualStateManager.VisualStateGroups>

Notice that there are 2 VisualStateGroups – one for "CommonStates", and one for "SelectionStates". Keep in mind that a control must be in one state from each VisualStateGroup at all times. This means that when a ListBoxItem or RadioButton is in the "Selected" state, it must also be in either the Normal/default state or in the MouseOver state:

Possible States
Normal & Unselected
MouseOver & Unselected
Normal & Selected
MouseOver & Selected

This becomes a problem when you need to define a 3-state setup for your buttons, when the same property has different values in all 3 states. If the "Selected" Visual State modifies a property that is also modified by the "MouseOver" Visual State, a conflict occurs.

For example, let's say we want to modify the text color on a ListBox Item or button. When you select the button, it will appear in the "selected" state:

However, when you mouse out of the button's area, the button will return to the "normal" state, even though the button is also in the "selected" state. Since the button is both "selected" and "normal", and both those states modify the text color, the last state to transition "wins".  Your selected button will show both states, with the normal state on top, making the text appear thin and unreadable:

Note that the same problem exists for CheckBoxes, which have a "CheckStates" VisualStateGroup.

Problem #2: Animating Brushes

We noticed that when using a ColorAnimation within VSM to change the color of a brush, strange behavior occurs. Either the animation does not occur, or it occurs on an adjacent control. This only happens on 1 out of every 10 transitions - a representative from Microsoft acknowledges the problem in this Silverlight forum discussion.

To see it for yourself, take a look at this sample application built by Page Brooks to illustrate the problem.  Mouse over the dots back and forth - you'll notice states getting stuck. The source code is also available.

Our Solution to Both Problems: Opacity-Only Animations and the "Selected Shield"

To circumvent these problems, we only ever animate opacity. We build a unique element (Grid, Canvas, whatever) for each Visual State, all having an opacity set to 0 other than the element for the "Normal" state. We then simply animate using a DoubleAnimation, changing the opacity on each element.

If our elements include only opaque items, such as images, this would be enough. However, if our elements contain transparent items, we still have a problem. Our selected state will be set to an opacity of 1 along with the MouseOver state, so both will appear to bleed into each other. To solve this, we also include an opaque "Shield" element in the selected state. We set the Z-orders of these elements so that the selected element appears on top of the shield, and the shield element appears on top of the MouseOver and Normal elements. See below for an example of this setup in the XAML.

Of course, having to make multiple copies of the exact same XAML elements is not optimal, and ends up requiring more lines of code. However, it is the only way we have found to totally squash both of these problems.

<ControlTemplate TargetType="ListBoxItem">
     <Grid x:Name="LBGrid" Background="Transparent" Cursor="Hand">

         <vsm:VisualStateManager.VisualStateGroups>
               <vsm:VisualStateGroup x:Name="CommonStates">
                    <vsm:VisualState x:Name="Normal" />
                    <vsm:VisualState x:Name="MouseOver">
                         <Storyboard>
                              <DoubleAnimation Storyboard.TargetName="canvasNormal" Storyboard.TargetProperty="(UIElement.Opacity)" Duration="00:00:00.001" To="0"/>
                              <DoubleAnimation Storyboard.TargetName="canvasMouseOver" Storyboard.TargetProperty="(UIElement.Opacity)" Duration="00:00:00.001" To="1"/>
                         </Storyboard>
                    </vsm:VisualState>
               </vsm:VisualStateGroup>
               <vsm:VisualStateGroup x:Name="SelectionStates">
                    <vsm:VisualState x:Name="Selected">
                         <Storyboard>
                              <DoubleAnimation Storyboard.TargetName="canvasNormal" Storyboard.TargetProperty="(UIElement.Opacity)" Duration="00:00:00.001" To="0"/>
                              <DoubleAnimation Storyboard.TargetName="canvasMouseOver" Storyboard.TargetProperty="(UIElement.Opacity)" Duration="00:00:00.001" To="0"/>
                              <DoubleAnimation Storyboard.TargetName="canvasSelectedShield" Storyboard.TargetProperty="(UIElement.Opacity)" Duration="00:00:00.001" To="1"/>
                              <DoubleAnimation Storyboard.TargetName="canvasSelected" Storyboard.TargetProperty="(UIElement.Opacity)" Duration="00:00:00.001" To="1"/>
                         </Storyboard>
                    </vsm:VisualState>
               <vsm:VisualState x:Name="Unselected"/>
          </vsm:VisualStateGroup>
     </vsm:VisualStateManager.VisualStateGroups>

     <Grid.ColumnDefinitions>
          <ColumnDefinition Width="255"/>
          </Grid.ColumnDefinitions>
     <Grid.RowDefinitions>
          <RowDefinition Height="24"/>
          <RowDefinition Height="3"/>
     </Grid.RowDefinitions>   

     <Canvas x:Name="canvasMouseOver" Grid.Column="0" Grid.Row="0" Opacity="0">
          <Rectangle Canvas.Left="0" Canvas.Top="0" Stretch="Fill" VerticalAlignment="Stretch" Width="255" Height="24" >
          <Rectangle.Fill>
               <LinearGradientBrush StartPoint="0.511514,-0.00480887" EndPoint="0.511514,1.0625"> 
               <LinearGradientBrush.GradientStops>
                    <GradientStop Color="#80FFFFFF" Offset="0"/>
                    <GradientStop Color="#805B7F9C" Offset="0.34322"/> 
                    <GradientStop Color="#80FFFFFF" Offset="1"/> 
               </LinearGradientBrush.GradientStops>
               </LinearGradientBrush> 
          </Rectangle.Fill>
          </Rectangle>
     </Canvas>

     <Canvas x:Name="canvasNormal" Grid.Column="0" Grid.Row="0" Background="Transparent" Opacity="1">
          <Rectangle />
     </Canvas>

     <Canvas x:Name="canvasSelectedShield" Grid.Column="0" Grid.Row="0" Background="#ABBDD1" Opacity="0"/>

     <Canvas x:Name="canvasSelected" Grid.Column="0" Grid.Row="0" Opacity="0">
          <Rectangle Canvas.Left="0" Canvas.Top="0" Stretch="Fill" VerticalAlignment="Stretch" Width="255" Height="24" >
           <Rectangle.Fill>
               <LinearGradientBrush StartPoint="0.525718,0.0128409" EndPoint="0.525718,1.0513">
                    <LinearGradientBrush.GradientStops>
                         <GradientStop Color="#80FFFFFF" Offset="0"/>
                         <GradientStop Color="#807E9EB8" Offset="0.360731"/>
                         <GradientStop Color="#80FDFDFD" Offset="1"/>
                    </LinearGradientBrush.GradientStops>
               </LinearGradientBrush>
          </Rectangle.Fill>
          </Rectangle>
     </Canvas>

</Grid>
</ControlTemplate>

Vertigo's DNC team is sitting in the Denver airport right now after an exciting and exhausting week at the Democratic National Convention.  We built the High Definition video website for the convention, and it was a huge success! We had a massive number of people around the world watch the convention live on our site, and what we achieved is an internet first. Never before has a live event of this historical importance been made available in quality that exceeds most HDTV broadcasts.

Additionally, our site broadcast the ENTIRE convention, not just the hour of primetime coverage offered by the TV networks, and the proceedings in their entirety are offered in Video On Demand form on the site.

You can check it out at gallery.demconvention.com.

For more information and pictures from our trip, check out the convention feature page on Vertigo's site here:

http://www.vertigo.com/dnc.aspx

If you haven't been paying much attention to the release schedule of the Microsoft ADO.NET Entity Framework, you might not even know that it was finally released with SP1 of Visual Studio 2008. Having stirred up so much controversy among ORM enthusiasts, I was hoping for some election-year-worthy rhetoric and hyperbole from its critics, and either a flurry of praise or complaints from EF-user-hopefuls. Its release, however, was eerily quiet. I guess we'll just have to wait and see what comes up.

I was curious to see how the SP1 installation affected my existing EF Beta 2 installation and applications, so I installed SP1 without uninstalling EF Beta 2. The first thing I noticed when attempting to create a new Entity Data Model in a new application was this message:

I had to double-take to see that I actually have two "ADO.NET Entity Data Model" templates in the Add New Item dialog. One of templates causes the error and the other one does not.

This is obviously because I had not uninstalled EF Beta 2. To fix this problem, uninstall the following programs:

1. ADO.NET Entity Framework Tools Preview
2. ADO.NET Entity Framework 1.0 (Pre-Release Version) (not really required to fix this issue, but it should be uninstalled anyway)

Next, I tried opening and running an old EF Beta 2 demo application I wrote. When attempting to open the .edmx file in the designer, I received the following error:

"Error 5: The required attribute 'Provider' is missing."

Similarly, attempting to build the solution gave me this error:

"Schema specified is not valid. Errors: Rockstars.ssdl(2,2) : error 0005: The required attribute 'Provider' is missing."

Apparently, the storage model (SSDL) schema has changed a bit. To fix the problem, I found the edmx:StorageModels element in my .edmx file and edited the code as shown below. (You may need to right-click on the .edmx file in Solution Explorer, and choose Open With --> XML Editor.)

From this:

<!-- SSDL content -->
<edmx:StorageModels>
<Schema Namespace="RockstarsModel.Store" Alias="Self" ProviderManifestToken="09.00.3054" xmlns="http://schemas.microsoft.com/ado/2006/04/edm/ssdl">

to this:

<!-- SSDL content -->
<edmx:StorageModels>
<Schema Namespace="RockstarsModel.Store" Alias="Self" Provider="System.Data.SqlClient" ProviderManifestToken="2005" xmlns="http://schemas.microsoft.com/ado/2006/04/edm/ssdl">

The other build error I was receiving was this:

"The type or namespace name 'RockstarsModel' could not be found (are you missing a using directive or an assembly reference?)" (In case you haven't figured it out yet, my program is called "Rockstars.")

This is due to a change in the way the generated data classes are namespaced. Previously, the generated data classes were placed in a top-level "model" namespace to represent the conceptual model (CSDL). This namespace had to be imported (or classes fully-qualified in code) in order to consume the data classes. In the RTM version, the classes are generated in your solution's default top-level namespace, so no import is necessary. The code gets re-generated at almost every move, so your old project will get updated to the new namespace pattern.

To fix my error I removed this line of code:

using RockstarsModel;

The most touted new feature in the RTM is the EntityDataSource. I'm a little skeptical that it's just another wizard, but hopefully I'll get a chance to look at it and blog about it. Other changes that may be of interest can be read about here. Some that caught my eye are:

• In the SSDL (store definition), you can no longer use a period in the name of an Entity, Association, EntityContainer, EntitySet, AssociationSet, or Function.
• The public DisposeContext() method has been removed from the EntityDataSourceView class.
• The event argument classes for the EntityDataSource have been re-architected. This affects ASP.NET users who used the ContextCreating, ContextCreated, ContextDisposing, Selecting, Selected, Updating, Inserting, Deleting, and Deleted events.

All in all, the installation was pretty smooth, and migrating my Beta 2 application was pretty simple.

Over the last couple of months, Vertigo has been building the High Definition, Silverlight-driven video website for the Democratic National Convention.  6 members of our team arrived in Denver yesterday, and we'll be supporting the site throughout the convention, which runs from Monday August 25 to Thursday August 28. 

This is an exciting project for Vertigo, as we're breaking new ground.  This is one of the biggest events to have ever invested this heavily in live, high definition quality coverage.  The site allows Video on Demand as well as a full schedule, and will be available during and after the event.  The site will really begin to "light up" this week as the live coverage begins, and a slew of high definition VODs begin to appear in our video gallery.  The site can be viewed here:

http://gallery.demconvention.com 

We got the opportunity to tour the convention floor at the Pepsi center last night, and I was very impressed by the visual design of the stage, as well as all the effort being put into the event.  Check out the pictures from our trip here.

Some screenshots from the app appear below. Note that the second image is actually a screenshot – not a picture we took!

Recently, there was an article on avoiding inheritance on the Visual Studio start page news channel. In general, I like the content of the article. I don't think there is any misinformation, but I do think there is some misrepresentation. I believe this article is overly critical of inheritance. I hope the author isn't simply being fashionable by deriding inheritance in favor of generics and lambdas.

This is a problem of education, not abstraction. This doesn't mean inheritance is flawed; it means the developers' knowledge is incomplete.

Correct: that is by design. That is a known and welcome aspect of inheritance. If Foo inherits Bar, a Foo is a Bar and I expect it to behave as such.

If you're adding an abstract method, it means you want derived classes to implement it. Otherwise, either add a virtual method or derive a new class that contains the new abstract method.

This problem isn't restricted to class hierarchies; this will happen with any code. Any time you change code anywhere, you need to re-test your application. If you're writing a class library for consumption by others, you're only alternative to potentially breaking a client is to add a new method with the new behavior or create an entirely new class (e.g. the ConfigurationManager class instead of the ConfigurationSettings class). The .NET framework even has an attribute (the ObsoleteAttribute class) specifically for dealing with legacy. There are plenty of instances of this in the System.Runtime.InteropServices namespace.

Everything else about the article is pretty good. His use of the Command pattern is a fine example of when to use generics instead of inheritance. I have a couple of additions to his discussion.

• And because of leveraging a common base class, we can use polymorphism to reuse this code even more (like having a list of commands that we can execute in a script or elsewhere).

  I think this is still useful but he didn't come back to it in his re-implementation using generics. Here, he can still benefit from an interface. Having his GenericCommand<TReceiver> implement, say, ICommand (having the same definition as his Command abstract class) enables generic containers and iteration.

• First of all, for every home device that we wish to turn on and off, we would be introducing two new classes into our code.

  In his example where he addresses this with generics, .NET will introduce new classes (e.g. GenericCommand`1[Garage]), but they're created at run-time. You won't find them if you use, say, Reflector to look at the assembly. This doesn't invalidate the way he addresses this concern since those generated classes aren't introduced into our code.

• If we change our Execute() method in our base class from abstract to virtual in order to introduce common behavior, how do you guarantee that the base method is called when it should be? In a derived class, should you call the base method before your own execution code, or after? What if I want common code in my base class that will be executed both before and after the behavior in my derived classes?

  The answer to all of these is "use the Template Method pattern." In fact, using lambdas to defer the actual implementation of the command behavior to a separate entity as he does is in essence a use of the Strategy pattern, a relative of the Template Method pattern. (BTW, Wikipedia's Python example of the Strategy pattern can be re-implemented in C# without loss of generality by using the same techniques found in this article.)

We have some mice running around the house and I bought some live mouse traps to catch the mice and release them where they can live out their happy mouse life. I thought one of the live mouse trap's instructions was kind of odd:

"Bla, bla about setting it up. After you catch the mice, you can submerge the cage in water."

I've seen several master-detail examples using a GridView that controls a DetailsView but no parent-child examples that reverse their roles (i.e., an example using a DetailsView that contains and controls a GridView). I alluded to such a scenario in a previous post. Here, I'll walk through the steps to create such a display.

1. Create the database and tables. If you already have one with a parent-child (i.e., one-to-many) relationship, you can skip this step. Also, if you're using SQL Server 2005 instead of its Express edition, skip to sub-step c.
   1. From the Project menu, select "Add New Item…".
   2. Select the Data category, and then select the SQL Server Database template and click "Add". If it then prompts you to place it in the App_Data folder, click "Yes".
      
      
   3. Create a two tables, one of which has a foreign key into the other. Here is the example I'll use.
      
      
   4. Add some data to the tables. I'll add two companies with two divisions each.
2. Create a new Web form or use one you already have. I'll use Default.aspx. Open it and switch to the Design view.
3. Add a DetailsView to the design surface. You can find it in the Data section of the Toolbox.
   
   
4. From the "Choose Data Source" drop-down list, select "<New data source…>". I'll select the Database data source for this walk-through.
   
   
5. Select the connection to your database from the drop-down list. If it's not there, click "New Connection…" to create a new one.
6. Click "Next" to save the connection string in Web.config.
7. In the "Configure the Select Statement" step, select the "Companies" table (or whichever table is the parent in your schema) and select "*" to see all columns in the DetailsView. Click "Next".
   
   
8. Test the query if you like. Click "Finish".
9. Click the Smart Tag symbol on the DetailsView control to open it and select "Add New Field…".
   
   
10. Select "TemplateField" from the "Choose a field type" drop-down list and enter some header text. I'll enter "Divisions" since that's the name of my child table. Click "OK".
    
    
11. Select "Edit Templates" from Smart Tag. The control enters "Edit Template Mode" and displays an empty item template for the Divisions field. Drag a GridView from the Data section of the Toolbox into the item template.
    
    
12. Create a new data source as above (steps 4 through 8) for the GridView but select all columns from the Companies table (or whichever table is the parent in your schema) instead. There is one issue to beware. VS will name the new data source for the GridView the same as that for the DetailsView. (I previously used the default, SqlDataSource1.) This will cause a designer error. Be sure to use a different name for the new data source. I'll use what is supposed to be the default, SqlDataSource2.
13. If you run it now, you'll see one company but all divisions, not just those for that company.
14. In the "Configure the Select Statement" page of the "Configure Data Source" wizard (the page where you select "*"), click the "WHERE…" button.
15. In the "Add WHERE Clause" dialog, select "CompanyId" from the "Column" drop-down list and select "Control" from the "Source" drop-down list.
16. In the Parameter properties section, select DetailsView1 from the Control ID drop-down list. Click "Add" and then click "OK".
    
    
17. Verify the SELECT statement. Mine is "SELECT * FROM [Divisions] WHERE ([CompanyId] = @CompanyId)". Click "Next".
18. Test the query if you like. Click "Finish".
19. Press F5. Here's what it looks like in my browser.
    
    

I ran through the instructions of my previous post and had no problems with that combination of GridView, ObjectDataSource, DataSet, and stored procedures using Visual Studio 2008. It appears Microsoft fixed it since Orcas.

I have two external Western Digital MyBook drives that are working great… I had two external Western Digital MyBook drives die recently, one around a week ago, and another around 2 months ago.

Both drives were not used very much (powered off most of the time) and worked for over a year. There were no indications of failure, I turned on the drive and the computer indicated the drive could not be recognized and needed to be formatted.

I tried a lot of programs to recover the files and the only one that worked was FindNTFS. I was able to recover all of the files from the drives with FindNTFS, you might try it if you are in a similar situation.

I did the following:

• Remove the drive from the enclosure, which probably was not necessary.
• Install the drive in another enclosure, which was necessary since I removed it in the first place.
• Ran findntfs 2 0 1 1, that listed the files on the drive.
• Ran findntfs 2 0 1 1 copy, that copied the files from the drive.

Using Media Center under the following conditions was resulting in stuttering video and audio, and the occasional green screen:

• Windows Vista Ultimate SP1, 64-bit
• 4 GB RAM
• NVidia GeForce 8800 GTS
• Hauppauge WinTV 1600 TV Tuner

I've seen a lot of posts on message boards where people are experiencing similar issues, all with strange suggestions that don't seem to work. I accidentally discovered my own solution, which I hope helps anyone else with the same problem.

Here's what I did:

1. Go to Hauppauge's website and download the newest drivers
2. Extract the contents of the zip file
3. Run hcwclear.exe, selecting the Remove All WinTV Drivers and Applications (Total Removal) and Search All .INF Files for Conflicting Hardware options
4. Reboot
5. When Windows discovers new hardware after rebooting, allow it to look for new drivers

I have seen other instructions that indicate you should use the downloaded drivers, but in my case, the drivers available through Windows Update worked fine.

If you use local MSDN rather than the internet-based version like I do and you are doing Silverlight work, here's how to integrate Silverlight's SDK into Visual Studio's local help.

1. Open the Microsoft Visual Studio 2008 Documentation start menu item
   
   
   
2. Go to the Index tab, and type in "combined help", which should navigate you to the combined Help collection [Visual Studio]entry, and press enter
   
   
   
3. Open the help topic opens, click on the last link named Visual Studio Combined Help Collection Manager
   
   
   
4. At this point, you should see a list similar to what you see below. Pick the SDKs you'd like to integrate, then press the Update VSCC button.
   

Once you press the Update VSCC button, you'll be prompted to close the documentation and Visual Studio. The next time you open the documentation, it will spends several minutes integrating the SDK. Once the integration is complete, when you navigate to a class common to .NET and Silverlight, you'll be able to select which SDK you want to navigate to:

For Silverlight, you'll want to select the dv_silverltmref location.

Good luck!

I'm far from an expert on Microsoft's Entity Framework (EF), but I have dabbled a bit with betas 2 and 3. Recently, Brian Ellis, a colleague of mine, summarized the points made in an open letter claiming a "vote of no confidence" in the Entity Framework. I'm no ORM guru or EF junkie, but I know enough about EF to see that it has both potential and limitations. I'd like to share my thoughts on the letter.

To be fair, I've never used NHibernate (the Holy Grail), and work primarily with Microsoft technology. That doesn't make me an EF evangelist. I'm still quite skeptical, but interested in understanding the value of the technology.

Before getting into the issues mentioned in the open letter, I would like to add a few gripes of my own:

• The design surface is not feasible for maintaining hundreds of entities.
• The mapping seems to be brittle when using the designer for custom entities, including the refresh from schema feature.
• The designer forces the developer to refresh from schema in certain cases, when perhaps she doesn't want to.
• Generated code in an entity data model does not represent self-referencing schema very well (for instance, an Employee that inherits from Person, which has a Manager property that also inherits from Person). Customizations required to work around the issue are hard to maintain.

I'm sure the more I use it, the more gripes I'll have, but for now let's get to the gripes of the open letter.

INORDINATE FOCUS [ON] THE DATA ASPECT OF ENTITIES LEADS TO DEGRADED ENTITY ARCHITECTURES

Regarding the point that entities are tied too closely to schema, I believe this is often true, but only because unmodified, generated code is the simplest and most common way to build an entity model—straight from schema. They don't have to be, however. From my understanding, a decent amount of flexibility is provided for structuring entities and their relationships, included multiple inheritance patterns, and the ability to group mapped columns into complex object properties.

(For instance, a Person table may contain several columns related to addresses. You could create a complex type called Address that a Person entity uses, and map the properties of the Address property to the columns in the Person table. No Address table is required in the data store, just proper mapping.) I'm sure, however, that many entity models would be very difficult, or impossible, to map using EF.

Regarding the point that entities are data-centric, rather than behavior-centric, I might not fully understand the complaint. The authors make no mention of the fact that the entities are partial classes with full exposure to the EF's data access gateway, allowing custom business and data access logic to be attached to each entity. (They do mention the partial class architecture in the "persistence ignorant" section, but only to complain of its "awkwardness.") It seems to me that custom entities could be designed with behavior in mind.

EXCESS CODE NEEDED TO DEAL WITH LACK OF LAZY LOADING

EF supports deferred loading, but requires the developer to understand when any related entities ("navigation properties") are loaded, rather than automatically fetching & load-tracking when referenced. It's true, this causes the developer to ask IsLoaded() of an entity's navigation properties, and then conditionally Load(). You can also eagerly fetch navigation properties when fetching the parent by using the .Include() method, but this is pretty much the opposite of lazy loading. It sounds like the authors of the letter do not want developers to need to understand when or if a property has already been loaded. I don't really have an opinion on this since this requirement hasn't given me enough heartburn to gripe about it.

SHARED, CANONICAL MODEL CONTRADICTS SOFTWARE BEST PRACTICES

If I understand correctly, the authors of the letter are proponents of separate models per application tied to a single data store, rather than a single, canonical, model shared by multiple applications. This seems fully feasible with EF—there's no reason multiple models could not represent and access the same data store. Am I missing something?

Even better in certain cases, it seems possible with EF to place all core, sharable logic in a shared entity model, and have application-specific logic in each application that consumes the model. This architecture would probably break the partial class pattern of putting the logic directly in the entity, but if the logic is application-specific, I don't think it belongs there anyway. This could be handled with a more classically-tiered approach using service layers or business layers in consuming applications.

LACK OF PERSISTENCE IGNORANCE CAUSES BUSINESS LOGIC TO BE HARDER TO READ, WRITE, AND MODIFY, CAUSING DEVELOPMENT AND MAINTENANCE COSTS TO INCREASE AT AN EXAGGERATED RATE

I think this is a little misleading, because the entities themselves are persistence-ignorant, but obviously the mapping configuration cannot be. Perhaps I'm missing something, but that seems to be the nature of ORM. In order to connect an entity data model to two completely different data stores (in schema, technology, etc.), you would have to take great care in creating two separate mapping configurations to ensure they provide equivalent mapping. Even then, you are limited by the differences in what the two data stores support. For instance, you can't expect an XML file to support cascading deletes or other features that SQL Server provides. However, if we ignore the differences in the features of data store technologies and focus solely on mapping, I believe the EF supports persistence-ignorant consumption of entities, allowing for unit testing, data migration, etc.

EXCESSIVE MERGE CONFLICTS WITH SOURCE CONTROL IN TEAM ENVIRONMENTS

This wouldn't surprise me, but I have no experience with EF in source control.

In summary, I feel like the open letter attempts to make some good points, but doesn't do much to back them up. It also seems that certain features of EF are glossed over, or perhaps EF is just not enough like NHibernate for those that wish it was. I'm not an EF evangelist, and I'm sure when it's finally released it will stir up a lot of complaints (by me, included), but this letter smells a bit like alt.net vs. MSFT to me.

I am still a die-hard C++ programmer. I don't call myself an expert (journeyman, perhaps); it's a huge and complex language. Put another way, it gives you enough rope to shoot yourself in the foot. Nowadays, I program primarily in C#. For the longest time, I still did significant recreational programming in C++ because I liked the power of the language and the C++ standard library, most notably the STL, which the .NET framework had not yet matched.

With .NET 2.0 and 3.x, that's changed. While I'm sure there are tasks more well suited for C and C++ (e.g. operating systems), I find myself doing much less of my recreational programming in C++. What really did it for me was the introduction of generics, introduced in .NET 2.0. Not so much that generic programming became possible, but rather the implementations of many of the same concepts found in the STL: containers, iterators, algorithms, and functors.

Iterators and functors previously existed in .NET in the forms of IEnumerable and delegates, respectively. They're more powerful now with IEnumerable<T> and anonymous methods. Those are interesting but the most interesting to me are the containers. Here is a list of the STL containers and the .NET equivalents. I also listed the STL insert complexity.

¹ These are more difficult to construct since they allow duplicate keys. Perhaps use a Dictionary of Lists.

There are other containers but they're either more for special purposes (e.g. bitset and valarray) or not yet part of the standard (e.g. hash_set and unordered_map).

.NET 3.x, with LINQ and extension methods, gives us not only many of the functors but also something even more valuable: expressiveness and elegance. For instance, which is more readable? (These are adapted from Scott Meyers' Effective STL, Item 47.)

C++

vector<int> v;

// ... other statements here

// remove elements < 100 except those preceding the last element >= 2500
v.erase(
    remove_if(find_if(v.rbegin(), v.rend(),
        bind2nd(greater_equal<int>(), 2500)).base(),
        v.end(),
        bind2nd(less<int>(), 100)),
    v.end());

C#

List<int> v= new List<int>();

// ... other statements here

// remove elements < 100 except those preceding the last element >= 2500
v = v.SkipWhile((i, n) => n < 100 && i >= v.Last(m => m >= 2500)).ToList();

I still like C++ and I understand the above statement and have written many like it (although I wasn't sure how to indent it since I prefer to break it up as he suggests in his book). I'm ignoring efficiency¹ and aliasing² here, but for readability, I side with C#.

¹ The C++ code is likely to be more efficient, at least for primitive types such as int used here. For more complex classes with expensive copy constructors, the C# code is perhaps better since it deals with references, not values. C++ can certainly handle references (as pointers) but, in an unmanaged world, one must then contend with memory management.
² The C++ code modifies the vector while the C# example creates a new list. That matters if other code has a reference to the original list. It's possible to construct a more complex C# expression or set of C# statements involving RemoveAll or RemoveRange.

If you have code that you want to run only while debugging in Visual Studio, you can detect it if you are running in its hosting process, which is enabled by default.

#if DEBUG
    if(AppDomain.CurrentDomain.FriendlyName.EndsWith("vshost.exe"))
    {
        // Perform whatever tasks depend on running inside the Visual
        // Studio debugger.
    }
#endif

While it does provide several features not otherwise available, you might have a reason to disable it (such as a corrupted vshost.exe file). To do so, uncheck the last box (shown checked here) on the Debug tab in the Project Properties window.

Another control I’ve been playing with is the <GridSplitter />.  The grid splitter control allows a user to resize a column or row to their liking.

Below is a basic grid with two columns taking up the same amount of space. A gridsplitter is put on the right side of the first column to allow the user to resize it.

   <Grid>
    <Grid.RowDefinitions>
      <RowDefinition Height="*"/>
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
      <ColumnDefinition Width="*"/>
      <ColumnDefinition Width="*"/>
    </Grid.ColumnDefinitions>
    <Rectangle Grid.Column="0" Fill="Green" />
    <Rectangle Grid.Column="1" Fill="Red" />
    <GridSplitter Grid.Column="0" Width="5" HorizontalAlignment="Right" VerticalAlignment="Stretch" Background="Black" />
  </Grid>

The gridsplitter control uses the HorizontalAlignment and VerticalAlignment properties to determine the movement direction. The MSDN article has a nice table which describes the effect of the various property values:

Here is a little more complex grid with three columns and two gridsplitters. Notice the gridsplitters are always put on the border of two columns. Splitters put on an outside border do nothing.

   <Grid>
    <Grid.RowDefinitions>
      <RowDefinition Height="*"/>
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
      <ColumnDefinition Width="*"/>
      <ColumnDefinition Width="*"/>
      <ColumnDefinition Width="*"/>
    </Grid.ColumnDefinitions>
    <Rectangle Grid.Column="0" Fill="Green" />
    <Rectangle Grid.Column="1" Fill="White" />
    <Rectangle Grid.Column="2" Fill="Red" />
    <GridSplitter Grid.Column="0" Width="5" HorizontalAlignment="Right" VerticalAlignment="Stretch" Background="Black" />
    <GridSplitter Grid.Column="2" Width="5" HorizontalAlignment="Left" VerticalAlignment="Stretch" Background="Black" />
  </Grid>

The gridsplitters can also be put on opposite side of the center column for nearly the same effect. There are two differences when used this way. First, the space taken by the gridsplitters are inside the center column and secondly, the gridsplitters fully overlap when move moved all the way over.

   <Grid>
    <Grid.RowDefinitions>
      <RowDefinition Height="*"/>
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
      <ColumnDefinition Width="*"/>
      <ColumnDefinition Width="*"/>
      <ColumnDefinition Width="*"/>
    </Grid.ColumnDefinitions>
    <Rectangle Grid.Column="0" Fill="Green" />
    <Rectangle Grid.Column="1" Fill="White" />
    <Rectangle Grid.Column="2" Fill="Red" />
    <GridSplitter Grid.Column="1" Width="5" HorizontalAlignment="Left" VerticalAlignment="Stretch" Background="Black" />
    <GridSplitter Grid.Column="1" Width="5" HorizontalAlignment="Right" VerticalAlignment="Stretch" Background="Black" />
  </Grid>

That is the basics of using gridsplitters. I’ll have some more advanced use of these controls in my next post.

This showed up in my vanity alerts yesterday. Bill Gates and Scott were quoted in the same article about TechEd North America.

http://www.crn.com/software/208401855

If in a class you have a value type property that is optional, it's common to specify it as nullable. However, if you serialize a nullable value type property to XML, you'll get something like this if it's null.

<Value xsi:nil="true" />

Or, if you turned off declaration of the XML schema instance namespace, it will be even more verbose.

<Value p2:nil="true" xmlns:p2="http://www.w3.org/2001/XMLSchema-instance" />

This might look strange but it will properly deserialize. Nonetheless, you might have a reason to have a nullable value type property serialize the way a class property does, which is to not appear in the XML output at all if it's null. Setting the IsNullable property of the XmlElement attribute for such a property will have no effect. (Well, setting it to false will result in a run-time error.)

The XmlElementAttribute.IsNullable Property page at MSDN has this to say.

You cannot apply the IsNullable property to a member typed as a value type because a value type cannot contain null. Additionally, you cannot set this property to false for nullable value types. When such types are null, they will be serialized by setting xsi:nil to true.

One work-around is to declare another property that is a class type, such as string, and parse it in the nullable value property.

[XmlElement("Value")]
public string ValueString { get; set; }

[XmlIgnore]
public int? Value
{
    get { return int.Parse(ValueString); }
    set { ValueString= value.ToString(); }
}

Of course, you can go in the opposite direction as well.

[XmlElement("Value")]
public string ValueString
{
    get { return Value.HasValue ? Value.Value.ToString() : null; }
    set
    {
        if(value != null)
            Value= int.Parse(value);
        else
            Value= null;
    }
}

[XmlIgnore]
public int? Value { get; set; }

I've been playing with XAML a little bit lately, both the Silverlight and WPF flavors, and thought I would discuss some of the things I learned about the <Grid /> control and a few of the concepts I had issues with.

The first concept I had to grasp was the fact that <Grid /> is a visual layout control. It has nothing to do with data. This reminds me of the good ol' days when I was allowed to use tables to layout my HTML pages. I actually had to convince myself this is a good thing. Microsoft designed it for layout so I should use it for layout.

When you start adding rows and columns to a test grid you will find that the first row or column is 0 not 1. From a layout standpoint the first row or column should be 1, but if you look from the development side the RowDefinitions and ColumnsDefinitions properties are collections where the first index is 0. Looks like designers will have to get used to 0 based indexing, but I'm a dev so it's fine by me.

There are three ways to size a row or column of a grid.

1. Give a hard size. This can be data bound also, but it's basically giving a hard number.
2. "Auto". The row or column takes on the size of its content.
3. "N*" (Star sizing). The new wonder of the development world. Takes up the space not used by the auto or hard sizing and splits it between all of the star sized rows or columns.

Auto and hard sizing are easy concepts, but star sizing threw me for a loop for a bit. The way I understand star sizing comes down to being a number of units of remaining space. You just need to add up the number of stars to determine the number of units of remaining space.

For example, in the following grid the first row will take up a set size. Now for the remaining space there are 2 star rows so there are 2 units of remaining space. Therefore, the second and third rows will each take up half of the remaining space.

<Grid>

  <Grid.RowDefinitions>

    <RowDefinition Height="Auto"/>

    <RowDefinition Height="*"/>

    <RowDefinition Height="*"/>

  </Grid.RowDefinitions>

</Grid>

In this example there are 2 star rows but one uses 2 stars so there are 3 units of remaining space. So the first row takes up two thirds and second row gets one third of the remaining space.

<Grid>

  <Grid.RowDefinitions>

    <RowDefinition Height="2*"/>

    <RowDefinition Height="*"/>

  </Grid.RowDefinitions>

</Grid>

Another example I've seen is below. It makes it a little clearer to the reader that each of the rows is going to take up 50% of the remaining space.

<Grid>

  <Grid.RowDefinitions>

    <RowDefinition Height="50*"/>

    <RowDefinition Height="50*"/>

  </Grid.RowDefinitions>

</Grid>

Just remember star sizes use the remaining space so having a lot of auto or hard sized rows or columns can leave you with very little space to split up.

Here are a couple of notes and things I don't want to forget:

This will make a nice base which will resize itself whenever the user changes the window size:

<Grid> 
  <Grid.RowDefinitions> 
    <RowDefinition Height="*"/> 
  </Grid.RowDefinitions> 
  <Grid.ColumnDefinitions> 
    <ColumnDefinition Width="*"/> 
  </Grid.ColumnDefinitions> 
</Grid> 

To put a control in row 0  and column 1 from XAML use the following:

<Rectangle Grid.Row="0" Grid.Column="1" />

To put a control in row 0 and column 1 from code use the following:

myControl.SetValue(Grid.RowProperty, 0);

myControl.SetValue(Grid.ColumnProperty, 1); 

myGrid.Children.Add(myControl)

To remove the declarations of the XML schema (xsd) and schema instance (xsi) namespaces from the output file of XML-serialized objects, create an XmlSerializerNamespaces object and add an empty namespace to it.

XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", ""); // Remove the unnecessary xmlns:xsi and xmlns:xsd namespaces.

Use it in the XmlSerializer.Serialize method invocation.

s.Serialize(writer, o, ns);

Interestingly, the XmlSerializerNamespaces Class page at MSDN has a note about this:

The creation of an empty namespace and prefix pair is not supported. That is, you cannot create a pair using the following code:

It refers to the Add invocation above.

• Use document.getElementById to get the Silverlight control.
• Then call Content.<registered name>.<method name>. For example, control.Content.Page.UpdateText(text).
• Nothing special for the functions that are called from Silverlight.
  

• Mark the class with the ScriptableType attribute.
• Call HtmlPage.RegisterScriptableObject in the constructor.
• Mark any methods that will be called from JavaScript with ScriptableMember.
• Use HtmlPage.Window.Invoke to call JavaScript functions.

<StackPanel VerticalAlignment="Top" Orientation="Horizontal">
  <TextBox x:Name="Result" HorizontalAlignment="Stretch" Width="200" Height="24" />
</StackPanel>

[ScriptableType]
public partial class Page : UserControl
{
    public Page()
    {
        InitializeComponent();

        // make this object a scriptable object
        HtmlPage.RegisterScriptableObject("Page", this);            
    }

// called from javascript
[ScriptableMember]
public void UpdateText(string result)
{
    this.Result.Text = result;
}

<!-- html area, click on the link to send data to the Silverlight control -->
<input id="result" type="text" size="30" />&nbsp;&nbsp;
<a href="javascript:updateSilverlight();">Update Silverlight</a>

<asp:Silverlight ID="silverlightControl" ... />

function updateSilverlight()
{
    // get data from html control
    var text = document.getElementById("result").value;

    // call silverlight control method
    var control = document.getElementById("silverlightControl");
    control.Content.Page.UpdateText(text);
}

Now you can run the application. Enter some text in the HTML textbox and press the Update Silverlight link. The JavaScript function updateSilverlight is executed which calls the managed code UpdateText method.




Call JavaScript function from Silverlight

// called from silverlight
function updateText(text)
{
    document.getElementById("result").value = text;
} 

<StackPanel VerticalAlignment="Top" Orientation="Horizontal">
  <TextBox x:Name="Result" HorizontalAlignment="Stretch" Width="200" Height="24" />
  <Button x:Name="CallJavaScript" Content="Update JavaScript"
     Width="130" Height="24" Margin="10,0,0,0" Click="CallJavaScript_Click" />
</StackPanel>

private void CallJavaScript_Click(object sender, RoutedEventArgs e)
{
    // call the javascript function
    HtmlPage.Window.Invoke("updateText", this.Result.Text);
}

Now run the application again. Enter some text in the Silverlight textbox and click the Update JavaScript button. The click handler is executed which uses the HtmlPage.Window.Inovke method to execute the JavaScript updateText function.

A class derived from a collection class will XML-serialize only the collection, not any additional properties in your derived class.

public class NamedNodeList : List<Node>
{
    public string Name { get; set; } // ignored during XML serialization
}

The work-around is to use containment instead of derivation.

public class NamedNodeList
{
    public string Name { get; set; }
    public List<Node> Nodes { get; set; }
}