Bruce Johnson's SOA(P) Box

Toronto Code Camp Collateral

bruce — Sat, 01 May 2010 21:33:41 GMT

I just finished my two presentations at this year’s Toronto Code Camp. As is my standard, I have put my slides on Slideshare.net. They can be found at:

OData - http://bit.ly/akPCcH

Silverlight 4 Out of Browser - http://bit.ly/91xQwp

As well, the sample code for the Silverlight 4 talk can be downloaded here.

Visual Studio 2010 At the Movies

bruce — Fri, 23 Apr 2010 16:21:00 GMT

Yesterday was the third (or fourth) annual ObjectSharp At The Movies event., For this particular version, we were able to celebrate the launch of Visual Studio 2010 and .NET 4.0 with a plethora of sessions covering VS (naturally) to ASP.NET, Silverlight, Sharepoint and TFS. All in all, it was a successful day that seemed to give the attendees what they came for. The slides that I used for my portion of the talk (which was an overview of VS2010 and .NET 4) can be found here. As always, feel free to ask questions. And, for those that missed it, we plan on doing it again next year. Just don’t know (yet) what the theme will be.

MIX 10 – First Impressions

bruce — Mon, 15 Mar 2010 21:29:53 GMT

Once of the interesting elements of this year’s MIX is the complete domination of Twitter as a medium for distributing updates. If you have been following me on Twitter (I’m @LACanuck), then you will already have heard a lot about the Windows Phone 7 development announcements. However, as useful as Twitter is, it’s not really a place for opinion. Unless your opinions fit into <140 characters. Mine don’t

Windows Phone

There is no question that there is a lot of buzz around developing apps for the Windows Phone 7. This is completely understandable, as WP7 allows Silverlight developers the ability to create applications for the phone. According to Scott Gu’s keynote, there is only “one Silverlight”. That is to say that applications that run on the browser should also be able to run on WP7.

Now there is going to be a little bit of a reality check for that statement, especially as we hit Silverlight 4. I’m not sure, for example, if Silverlight as running on WP7 has the concept of a trusted application. I suspect that it doesn’t, although I’m open to correction if my assumption is misplaced.

But working solely within the security sandbox is not the only real difference. Specifically, the design of a WP7 application is very different than a Web application. The size of the design surface is, naturally, much smaller on the WP7. And the UI needs to consider that main UI gesture is touching, a paradigm that doesn’t apply to Web applications. All of this is to say that while, theoretically, the same application could run on both platforms, it’s much more likely that different views will be used by the different targets. If nothing else screams that you should be using MVVM as a design pattern for Silverlight, this will.

Deployment

Once you see what’s possible in the WP7 environment, the excitement regarding creating applications is easy to understand. And not only are the apps exciting, so too is the ability to monetize your application. Microsoft will be making a Marketplace available so that you can sell your apps on-line. Given how well Microsoft has done with community driven marketplaces, I have no doubt this will be successful.

But what about your own personal applications? What if you want to develop a WP7 application that is used by your mobile sales force? At the moment, the answer seems to be that you’re out of luck. This might change before it goes live, but the word that I’m hearing is that the only way to get apps onto your phone is through the Marketplace.

Now, that’s not completely accurate. If you have Visual Studio 2010, you can deploy your application to a physically connected phone. However, the time to live for applications which have been deployed in such a matter is limited, To, approximately, a month. After which the app would need to be redeployed.

I’m not a fan of this. In fact, in my mind ,it drops the collection of Silverlight developers who might write WP7 apps by 50%. At least. I can take guesses at the reason why this limitation is the case, but still, it’s not what I was hoping for. The term for what I’m looking for is ‘siloed’ deployment’ (that is, deployment only for people in a particular silo) and I’m hoping that it becomes part of the released version of WP7 before it goes live with the first version.

While there is more of interest that is being revealed here, this is probably a decent start. And I’ll be both blogging and tweeting as much as I can while I’m here at MIX ‘10

The Benefits of Windows Azure

bruce — Mon, 01 Mar 2010 15:03:43 GMT

The age of cloud computing is fast approaching. Or at least that's what the numerous vendors of cloud computing would have you believe. The challenge that you (and all developers) face is to determine just what cloud computing is and how you should take advantage of it. Not to mention whether you even should take advantage of it.

While there is little agreement on exactly what constitutes 'cloud computing', there is a consensus that the technology is a paradigm shift for developers. And like pretty much every paradigm shift there is going to be some hype involved. People will recommend moving immediately to the technology en masse. People will suggest that cloud computing has the ability to solve all that is wrong with your Web site. Not surprisingly, neither of these statements is true.

And, as with many other paradigm shifts, the reality is less impactful and slower to arrive than the hype would have you believe. So before you start down this supposedly obvious ‘path to the future of computing’, it's important to have a good sense of what the gains will be. Let's consider some of the benefits that cloud computing offers.

Instant Scalability

If you are tasked with building a customer-facing Web site, then one of the main concerns is scalability. Regardless of the type of site being created, there will be considerable intellectual energy spent determining how to configure the Web servers to maximize the up-time. And in many cases the infrastructure design must also consider issues not related solely to reliability. The ability to handle peak times, which can be a large multiple of the normal level of activity, must also be designed into the architecture.

These spikes in usage come in a couple of different varieties. Sometimes, the spikes come at predictable times. Think of the holiday season for a retail site or a price sale for a travel site. Sometimes the spikes cannot be predetermined, such as a breaking news event for a current events site. But regardless of the type of spikes, the infrastructure architect must create an infrastructure that is capable of absorbing these variations in stride. The result, especially if the peak is 10 times or higher than the average load, is that extra (and mostly unused) capacity must be built into the design. Capacity that must be paid for, yet remains idle.

Into this picture comes cloud computing. Regardless of the cloud platform for which you develop, the ability to scale up and down with the click of a mouse is readily available. For Windows Azure, there are a number of different scalability points, including the number of virtual machines assigned to the application, the number of CPUs in each of the virtual machines, and so on. Within the application itself, you as the designer would have already partitioned the application into the various roles that are then deployed onto the virtual machines.

As the demand on the Web site increases, additional machines, CPUs or roles can be added to ensure a consistency of responsiveness through all of the loads. More importantly, when demand decreases, the resources can be removed. Since these settings form the basis for price paid for the cloud computing service, companies will end up paying only for the capacity that they require.

The price to be paid for this flexibility is that mostly that the application needs to be designed with the necessary roles in mind. As well, there are other constructs (such as the AppFabric and the ServiceBus) and technologies (such as WCF) that need to be mastered and integrated into the application. As a result, it is easier to build a Web application that works with Windows Azure right from the start. This is not to say that existing Web applications can’t be refactored to take advantage of the cloud…they certainly can. But starting from scratch allows you to take full advantage of the benefits offered by Azure.

Expandable Storage

The ability to avoid idle resources is not the only appeal of cloud computing. Another resource that can be virtualized for most applications is the database. Just like the CPU, database usage can rise and fall with the whims and patterns of the user base. And the fact is that the vast majority of business databases do little more that grow in size as time goes one. Again, infrastructure architects need to consider both growth rate and usage patterns as they allocate resources to the database servers. As with the machine-level resources, over-capacity must be designed into the architecture. By using a database hosted in the cloud, the allocation of disk space and processing power can be modified on an as-needed basis. And you, as the consumer, pay only for the space and power that you use.

There are some additional thoughts that need to be given to the use of a cloud database. In order to provide the described flexibility, cloud database providers freely move data from one server to another. As a result, there must be a fairly high level of trust in the provider, particularly if the data is sensitive in nature. For the traditional non-cloud database, the owner of the Web site maintains physical control over the data (by virtue of their physical control over the database servers). Even if the server is hosted at a co-location facility, the Web site owner ‘knows’ where the data is at all times.

When the data is persisted to the cloud, however, this is no longer the case. Now the data is physically in control of the cloud provider. The owner has no idea on which server the data is stored. Or even, when you get right down to it, which city. For some companies, this is a level of trust well beyond what they might have been comfortable with in the past.

As a person who lives abroad, (I’m from Canada), there is one more consideration: privacy. Data privacy laws vary from country to country. When data is stored ‘in the cloud’, there is little weight given to the physical location of the data. After all, the actual location has been virtualized out through the cloud concept. Information can (and does) move across national boundaries based on the requirements of the application. And when data resides in another country, it may very well be subject to the privacy laws of that country. If those laws are significantly different than your own, you might need to modify your corporate policies or the Web application itself to address whichever requirements are more stringent. This sort of situation brings rise to a common approach to cloud storage – data segregation.

In data segregation, the data required by the Web application is stored in multiple locations. Data that is static and/or not particularly sensitive is stored in the cloud. Data that is sensitive is stored in a traditional (and more subject to owner control) location. Naturally, the Web application needs to be structured to combine the data from the different sources. And the traditionally located data needs to be stored in an infrastructure that is reliable and scalable…with all of the problems that the implementation of those features entail.

The functionality offered by cloud computing will be enticing to some, but definitely not all, Web sites. For those who fit the target audience (Web sites that have a wide fluctuation in usage patterns) or just those who want to outsource their Internet infrastructure, cloud computing is definitely appealing. For developers of these sites, platforms such as Windows Azure represents a significant change in the necessary development techniques. And even with the inherent complexity, the shift to cloud computing is beneficial to developers (the resulting applications tend to be more modular, composable and testable), enough to make further exploration of the details worthwhile.

Order Fixation

bruce — Mon, 25 Jan 2010 12:39:00 GMT

One of my current tasks for a client has been to facilitate the integration between a Java client and a WCF service. The mechanism for doing this is JSON and I have been quite grateful that WCF makes it relatively easy to implement this type of communication. However, there is one area that has been causing some grief for me (and my Java colleagues) that I finally create a workaround for yesterday.

The source of my problem starts with the contract used by the WCF service. A number of the methods include parameters that are abstract data types. Consider the following class declaration.

[KnownType(ButtonCommand)]
[KnownType(MouseCommand)]
[DataContract]
public abstract class AbstractCommand

The AbstractCommand class is just a base class for a couple of concrete classes (ButtonCommand and MouseCommand). The WCF method is declared as accepting an AbstractCommand type, but the value passed into the method will be either a ButtonCommand or a MouseCommand.

[OperationContract]
[WebInvoke(BodyStyle=WebMessageBodyStyle.Wrapped,
RequestFormat = WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json)]
StatusCode ExecuteCommand(AbstractCommand command);

Naturally, when the client invokes this method, the expectation is that a concrete class instance will be passed along. However, if all you do is pass in the JSON for one of the concrete classes in, you get an exception saying that an abstract class cannot be instantiate. The reason for the error can be found in how WCF dispatches message. When the request arrives, WCF examines the message to determine which method is to be invoked. Once identified, the parameters for the method (found in the JSON) are created. This creation involves instantiating an object using the default parameterless constructor for the type and then assigning property values as found in the JSON. However, the AbstractCommand type cannot be instantiated (it is abstract, after all). And there is no immediately apparent mechanism to determine which concrete type should be used.

To address this final problem, Microsoft introduced the idea of a type hint. The JSON for a concrete type passed into the ExecuteCommand method would look something like the following:

{"command":{"__type":"ButtonCommand:#Command.Library", "prop1":"value", "prop2":"value"}}

The name/value pair of “__type” is used by WCF to determine the type that should be instantiated before performing the property assignment. This is conceptually similar to how types are provided through SOAP. This mechanism does have the hard requirement that the “__type” value be the first pair in the JSON list.

Enter Java into the picture. In order to communicate with my WCF service, the client using the Java JSONObject class. This class takes a collection of name/value pairs and converts it into a JSON-formatted array. This array is then sent to my method, where it goes through the previously described process. However the JSONObject seems to take the portion of the JSON specification where it says the name/value pairs are ‘unordered’ to heart. There is (apparently) no way to force a particular name/value pair to be emitted as the first pair. In other words, the JSONObject cannot reliably produce JSON for a concrete type that is being passed into a parameter of an abstract type.

Crap.

Well, it was actually stronger language than that once I figured this out.

The solution was not nearly as complicated as identifying the problem. I created a WCF endpoint behavior extension. In the AfterReceiveRequest event handler, I look at the body of the request (which has already been converted into XML, as it turns out..a surprise, albeit an easier choice format for the next step). If the “__type” property is the first pair in the JSON array, it is converted to a “__type” attribute in the XML element. Otherwise, it appears as a regular child node. So the transformation consists of finding the XML elements that have a name of “__type” and moving the value up into an attribute of the parent node. The modified message is then injected back into the WCF pipeline. And now the request is processed as desired.

Setting the Default Style for a Custom Silverlight Control

bruce — Thu, 14 Jan 2010 14:47:24 GMT

Like so many of my posts, this one is as much about keeping a log of what I learned. And, in this particular case, since I had a difficult time finding the answer (and the answer is relatively new), a blog posts is doubly worthwhile.

I was trying to write a custom control for Silverlight 3. It was an extension to a ListBox, so I created a class that derived from ListBox and added my neat-o cool functionality. However, part of the requirements for the control was (for example) that it needed to be horizontal and that the scroll bars needed to be hidden. For this, the best approach is to define a default template for the control.

The default template is basically the style that is applied to the control in the absence of designer requests to the contrary. Practically, it is exactly the same as any other style that you would create. What makes it different is that the user of the custom component does not need to do anything to have the style applied.

In order to accomplish this feat requires three steps. The first has been true since Silverlight 2, that being that the style needs to be placed into a file named Generic.xaml. In the past it was sufficient to place the style in said file and set the TargetType of the style to be the custom control. However at Silverlight 3, two additional requirements were added. The first is that the Generic.xaml needs to be placed into a directory called Themes. The second is that the following line of code needs to the constructor for the custom control.

this.DefaultStyleKey = typeof(customcontrolname);

Once these conditions have been met, the default style will get picked up. It was the last two steps that stymied me, as many of the existing posts talk about one, but not both of the requirements.

As a convenience, there is now a TemplatedSilverlightControl template that actually sets up the necessary files, directory and code to make all of this work without further thought. And I like not having to think (other than remembering to use the correct template, that is).

Getting Value from your Data

bruce — Wed, 20 May 2009 14:41:17 GMT

For those of you who are not on the ObjectSharp mailing list, you might not be aware that next week we have another in our Smart Breakfast series. This time it’s David Chennels talking about Business Intelligence. You can find the details out here.

Now the term “Business Intelligence” is one of those amorphous phrases that have the potential to make people crinkle their nose. It has the good buzzwords to entire management and it’s vague enough so that you can put many different technologies under that umbrella. If you’re a geek in the Microsoft space, typically business intelligence includes the OLAP and Analysis Services parts of SQL Server, maybe a third-party tool to visualize the data (if Reporting Services isn’t enough) and perhaps Integration Services.

But those tools have been around for a while. And, even though there is no licensing fee added to be able to use then, they don’t seem to have much traction, at least in the companies that I’ve been working with. So what is the reason for this lack of interest?

From my perspective, the answer seems to be lack of awareness. If you ask any managers whether more information is better than less, most will want more. If you qualify the question by letting the managers specify the type and format of the information that is presented, the percentage answering in the affirmative goes up. And yet, even though the information is already stored in the corporate database and the tools to create the desired reports are readily available, nothing is done.

And what is the solution? Education. Spend some time getting up to speed on what you can do with the tools already at your disposal. Is the creation of a business dashboard a zero-effort project? No. But it’s probably much less effort than you think. And in the current business environment, doesn’t it make more sense to find a way to use your existing resources to their fullest event? Of course it does.

So take a morning to learn about the possibilities. More specifically, take the morning May 28th and come to the ObjectSharp Smart Breakfast on Business Intelligence. Along with a good breakfast, you’ll learn about some tools and techniques that can make an immediate difference to your business. Now that’s really getting value.

Getting Trained in an Economic Downturn

bruce — Thu, 30 Apr 2009 22:34:07 GMT

I’m sure that, for the vast majority of the readers of my blog, becoming more productive with your programming tools is a desirable goal. Not all developers go out of their way to advance their skills, but the very fact that you read blogs means that getting better is of interest to you. And, for most companies, they would also like you to make better use of your existing tools. It’s certainly obvious that it’s in your company’s best interest for this to happen, even if they don’t go out of their way to explicitly advance your skills.

And this is the ugly truth for most companies. In the best of times, a large number of companies don’t provide any significant budget for formal training. Usually developers are expected to pick up any new skills on their own time. Or, worse, they are expected to apply new technologies without spending any ‘exploratory’ time with them. As most of your are aware, the first time you try a new technology, the result is usually only partially successful. Only after you have worked with it a few times does it become possible to take full advantage of it. And yet, management is reluctant to pay for training classes, tech conferences, or even a programming book that will help you get ‘into the zone’ for the stuff that would make a difference in your day-to-day efforts. Here's a few suggestions that might, possibly get your manager to approve educational expenses, even in the economic conditions that exist today.

Working with Books

Over the years, I have worked with a number of different companies. Each of them takes a slightly different view of what appropriate training costs are. For companies that have a large number of developers and a small educational budget, sometimes books are all that fit. For some companies, creating a library of programming books is a viable books. Your company could purchase well-reviewed (reviews are easy to find on Amazon) programming books on the relevant topics. Employees could then ‘borrow’ books that were appropriate to their current tasks. The books end up being purchased just once, but can be shared between developers as the need arises.

A more high-tech solution to the problem can be achieved with a solution to the on-line technology book site Safari. Safari allows for books to be searched electronically and even be downloaded (in a PDF format) or even printed on an as needed basis. This is a decent mix between the need to search for a specific answer and still being able to read a book cover-to-cover when called for.

However, a corporate library is not always the best solution. Finding answers in a book requires, in many cases, that you have some inkling of the solution beforehand. At a minimum, you need to frame your query appropriately, something that is as much art as science. And the pace of technology advances means that books are almost always going to lag new technology and best practices by a period of months, if not years.

Selling Management on Training: Speak Their Language

When you want to convince your boss to let you go to a conference or attend a course, the first thing to do is look at the expenditure from their perspective. After all, the cost of the training is an expense to them. If there is no corresponding benefit, it becomes difficult to justify spending the monies. And, ultimately, you need to convince management that the benefits that they will gain are more than the money that they will spend.

In general, you will find that the attitude that a company has towards the training of developers is dictated by how the company makes money and who is responsible for helping to making that money. Usually, companies whose product is technology-based tend to be better at providing and paying for skill improvements for their employees. When developers productivity is closely aligned with corporate revenues, it is easier to get the boss’ attention. However, if you work on an application that has no direct correlation with how the company makes money, you’re much more likely to face an uphill battle.

But regardless of where you fit in this spectrum, focus your arguments on what they get out of sending you across town or across the country. Make the conversation about their Return on Investment. Show that the training will have concrete and immediate value to the company and you’re a lot closer to getting approval.

One way that you might be able to do this is to offer to share materials and experiences with your team upon return. At ObjectSharp, we call these sessions ‘Lunch & Learns”. You many know them as “Brown Bag Training”. By offering to present such a session after your conference or course, your company gets to spread some of the benefits of sending one person on training across multiple people. And your team benefits from having the new technologies couched in terms that are directly relevant to your environment.

In some cases, it’s also possible to get the trainer to offer to help with these sessions. This is something that ObjectSharp offers to attendees of our courses. We’re more than happy to have one of our instructors speak to your company about the newest technologies. While any course is on-going, instructors work hard to make the content relevant to you. To accomplish this, we ask about the kinds of projects that are being worked on and where the technology will be applied. So by having an ObjectSharp instructor give the Lunch & Learn, you get a person who is well-versed in the technology, but who also has a basic understanding of how it will fit into your corporate development plans.

You might consider shouldering some of the burden of training yourself. I don’t necessarily mean to pay for it directly. But if you take your time to attend user group meetings and Code Camps (both of which take place in non-work hours), you show a dedication to improving your skills that might make a difference. At a minimum, you will get some insight into the latest technologies, even if it’s not quite the same personalized and intensive hand-on experience that going on a course might be.

Finally, I’d like to leave you with one final, and surprisingly creative, argument. One of the most common questions we get from potential training clients is 'What if I train our developers and they leave?'" Our answer is invariably 'What if you don’t train them and they stay?' This usually gets an 'Aha' moment from management, followed by a realization that perhaps investing more in staff development might not be quite the pure expense that they think.

Data Bondage in WPF presentation at Toronto Code Camp

bruce — Sun, 26 Apr 2009 05:28:00 GMT

My final presentation in my April World Speaking tour was at the Toronto Code Camp this afternoon. As always, the code camp was a huge success. The efforts of many people went into making it so, but the organization was top notch.

As part of the lead-up to my presentation, Joey de Villa made good on a promise to wear Microsoft branded assless chaps. And he even regaled the crowd with his version of Hit Me With Your Best Shot, a choice completely in character with the theme of the presentation.

As for the presentation, it went very well. Something like 70-80 people where there and I was pleased by the questions that were asked. I have always preferred an interactive audience because it means that they are probably listening. :)

As I promised at the end of the presentation, here are links to the slides and demos. Any questions are most welcome.

Slides: here

Demos: Download

Update: For those who want a more complete story surrounding the title of the presentation and the assless chaps references, check out Joey's blog post here.

Never Test Alone – Presentation at KWSQA Testing Conference

bruce — Wed, 22 Apr 2009 20:14:59 GMT

I finished presentation four of my April World Tour of the GTA earlier today. It was actually a co-presentation with Deb Forsyth and I was basically code-monkey and the 'developer’ that she could point to with here ‘bad developer’ stories. This was an unusual conference for me, in that I was a lone developer in a room full of testers. Daniel never had it so bad with the lions. :)

Anyway, as I mentioned in the presentation, the slides are now available for download at the following link. As always, questions are welcomed.

Slides – Download

Dropping Cookies in IE7

bruce — Fri, 17 Apr 2009 13:41:32 GMT

I was asked an unusual question yesterday about cookies, Silverlight and WCF. The scenario was that a Silverlight application was being used in a consumer-facing situation. The application itself communicates with the server using WCF. The service which is the target of the communication uses ASP.NET Authentication to authenticate the user. It’s an implementation detail (but critical to this post) that the method of storing the authentication token is a cookie called .ASPXAUTH.

In a normal (that is, working) scenario with Silverlight, the credentials are sent to the server and an .ASPXAUTH cookie is returned. The browser strips off the cookie and stores it. On any subsequent requests, Silverlight creates a request and sends it the the server through the browser’s networking API. The browser is responsible for determining which, if any, cookies should be send with the request and adding them to the outgoing header. In other words, the Silverlight application has no specific knowledge of or interaction with the .ASPXAUTH cookie.

As you would expect, this mechanism works the vast majority of the time. If it didn’t, I think it would have been a significant story long before now. But my questioner was running into a situation where the Silverlight application was unable to communicate with the server even after authentication was performed. What’s worse, this behavior was only happening on IE7. When Silverlight was run through Firefox, it worked exactly as it was supposed to.

The diagnostic step in a situation like this is to use Fiddler (or whatever your favorite TCP trace application is) to view the raw messages. And what was seen is that although the authentication response had the .ASPXAUTH cookie in it, any requests sent back to the server after authentication did not. Given when I’ve already explained about the processing of cookies with Silverlight requests, this eliminates the Silverlight application as the most likely culprit. But it also makes one scratch your head, as we can be pretty certain it’s not a widespread failure of IE7 to process cookies.

The answer likes in a strange bug in IE7. It turns out that if a domain name has a underscore in it, IE7 doesn’t persist the cookies. Let me repeat that, because it’s such a bizarre sounding problem. In IE7, if the domain name has an underscore (‘_’) in it, then any cookies returned from the domain will not be persisted. Which also means that subsequent requests will be ‘cookie-free’.

I’m guessing that most domain names don’t have an underscore, which is why this bug didn’t get widespread notice. In this particular case, the domain was one used for development, which would keep the problem from being a production issue. But I have no reason to believe that the bug would be restricted to a local problem. Deploy a ‘underscored’ domain name to the public internet and no authentication, shopping carts or other state information can be saved.

Fortunately, the solution was a simple one. If the domain name in the endpoint configuration is replaced with the raw IP address, IE7 is more than happy to save the cookie. I wouldn’t be surprise if an entry in your local hosts file would have the same effect. And the final solution would be to have your domain administrator create a DNS Alias entry…one that doesn’t have an underscore, of course.

Code Contracts at Toronto VB User Group

bruce — Fri, 17 Apr 2009 13:37:53 GMT

On Wednesday past, I did a Code Contracts presentation to the Toronto Visual Basic User Group. It was a continuation of my whirlwind ‘April Presentation Tour’, in that it was my third presentation in a week and the third of five that I’m doing in April. Tee shirts for the April Presentation Tour were available for sale from vendors as you left the arena

I have posted the slides and the source code to the following links:

Slides: Here

Source Code: Here

If you have any questions, please feel free to drop me a comment or an email message.

What’s New in Silverlight 3 at the Toronto Silverlight User Group

bruce — Sat, 11 Apr 2009 03:36:23 GMT

This past Thursday, I had the opportunity to present on Silverlight 3 to the Toronto Silverlight User Group. It was my first time presenting to the group and I was impressed by the number of attendees (I would say 30-40) who managed to hang around on the Thursday evening before a long weekend.

As promised, I have posted the slides and the source code to the following links:

Slides: Here

Source Code: Here

If you have any questions, please feel free to drop me a comment or an email message.

Catastrophic Failure While Installing an Out-of-Browser Silverlight Application

bruce — Wed, 08 Apr 2009 15:00:14 GMT

While working on one of the demos for my upcoming Toronto Silverlight User Group presentation, I ran into a catastrophic failure. Actually, the starting point for the problem was that when I right-clicked on the Silverlight application and selected the installation option, nothing happened. No errors, no warnings, but also no results.

While trying to figure out the problem, I when to the more direct method of installation by programmatically calling Application.Current.Detach(). When this statement was hit, an exception was thrown with the following beautiful details.

System.Exception: Catastrophic failure (Exception from HRESULT: 0x8000FFFF (E_UNEXPECTED))
   at MS.Internal.XcpImports.CheckHResult(UInt32 hr)
   at MS.Internal.XcpImports.Application_Detach(Application app)
   at System.Windows.Application.Detach()
   at LocalConnectionDemo.MainPage.Button_Click(Object sender, RoutedEventArgs e)
   at System.Windows.Controls.Primitives.ButtonBase.OnClick()
   at System.Windows.Controls.Button.OnClick()
   at System.Windows.Controls.Primitives.ButtonBase.OnMouseLeftButtonUp(MouseButtonEventArgs e)
   at System.Windows.Controls.Control.OnMouseLeftButtonUp(Control ctrl, EventArgs e)
   at MS.Internal.JoltHelper.FireEvent(IntPtr unmanagedObj, IntPtr unmanagedObjArgs, Int32 argsTypeIndex, String eventName)

As you might guess, this is not particularly useful in the debugging process. After a fair bit of effort, I discovered the solution. I happen to be using a PNG file as the icon for the application. When the PNG file is added to the project, the Build Action is automatically set to Resource. When you change the Build Action to Content, the problem goes away.

Also, the same exception is thrown if the file used as the out-of-browser icon is not present at the indicated location.

I’m hoping that the exception becomes a little more useful as Silverlight 3 moves through the beta process.

Design 101 – The Color Wheel

bruce — Mon, 30 Mar 2009 18:43:55 GMT

One of the most common comments from Silverlight and WPF developers is their lack of design sense. Over the next little while, I’ll be posting (interspersed with other topics) on some of the basics of color theory and how they can be applied to WPF and Silverlight.

To start with, let’s talk about one of the fundamental artifacts of color theory – the color wheel.

Originally conceived by Sir Isaac Newton, color wheel is a representation of the colors in the visual spectrum. In the representation, the three primary colors are placed equidistant from one another. The gaps between the the primary colors is then filled with with secondary and tertiary colors.

Now, already I’ve used three terms, only one of which I would expect you to be familiar with. Primary colors (red, blue and yellow) are something that we learned about in elementary school. Secondary colors (orange, green and violet) are created by combining the primary colors. Tertiary colors are those that are formed by combining primary colors with secondary colors.

So now that we have a color wheel, what good is it? Well, it helps identify harmonious colors. When selecting colors to use in a user interface, it is important so select colors that are, in combination, pleasing to the eye. Personally, I understand the challenge to this. As a person born without the color sense gene, I think that pink and lime green go well together. But apparently, I’m in the minority. :)

There are numerous theories about the combinations of colors that promote harmony. We’ll look at some of them in more detail in upcoming blog entries, but to give you a second, two of the most commonly used ones are complimentary and analogous. Complimentary colors are found opposite one another on the wheel. For example, red-green, yellow-violet, and blue-orange are all complimentary. These colors promote stability and contrast in the image.

Analogous colors are sets of three colors that are adjacent to one another on the color wheel. In images using analogous colors, one of the colors tends to be the dominant one. The result is an image that appears to be saturated in the dominant color with the other colors offering a subtle nuances of difference.

Where does Off-Browser Silverlight Run?

bruce — Tue, 24 Mar 2009 12:45:57 GMT

Off-browser Silverlight is pretty cool. And one of the first questions that got raised is ‘where is it running’. Obviously, it’s not running within the browser. I mean, duh. But if not there, then where?

I got the first inkling of an answer listening to Mike Harsh’s presentation on off-browser Silverlight at MIX ‘09 (slides, demos and video can be found on his blog). Actually, it wasn’t his presentation, per se, but his answering of questions afterwards. I actually give Mike props for doing this presentation. Off-browser Silverlight is very easy to configure and use. It’s difficult to find 60 minutes worth of content when the user experience is ‘right-click to install…right-click again to uninstall’ and the developer experience is ‘check a box in the property sheet’. But from his easy handling of the questions afterwards, it’s pretty obvious that he knows the topic well.

One of the post presentation questions Mike was asked was related to the ‘how’ of off-browser Silverlight. Mike intimated that, basically, the Browser control was used. In other words, when installed on a client’s machine, launching the Silverlight application actually launches an application which hosts the Browser control. The Browser control then hosts the Silverlight application.

As it turns out, this is “basically” true. For the Windows platform, it’s precisely true. From Chris Hayak, the application which is launched is called SLLauncher.exe. This is also the application to which you will attach if you want to debug Silverlight apps in off-browser mode. For the Mac platform, the SLLauncher application runs webkit, which in turn hosts the Silverlight application.

The one downside of this approach is that, at least during the beta, there is no way to distinguish between multiple, simultaneous off-browser Silverlight apps. They all appear in the process list as ‘sllauncher.exe’. Hopefully this will change before SL3 goes gold.

Is WPF Dead?

bruce — Mon, 23 Mar 2009 18:40:52 GMT

One of the first questions that arose from the announcement of off-browser Silverlight was “What will happen to WPF?” The obvious source of this concern is that since Silverlight 3 can run either as part of a Web page or installed in an off-browser mode, why would there ever be a reason to write a WPF application? And since Silverlight seems to be the technology that has all of the new features, is there a possibility that WPF could languish as the ugly step child in the client application development world ?

First, let me assuage your concerns. WPF is not dead. This opinion is based on a couple of on-going development projects at Microsoft: Expression Blend/Design and Visual Studio. In the case of Expression Blend/Design, the entire application was written in WPF. For Visual Studio, the code editors are being re-written in WPF. If nothing else, the investment being made by Microsoft to these products in WPF should demonstrate its on-going commitment to the technology. And there is the on-going integration of WPF into the Live Messenger client to add more fuel to the argument.

Going forward, I see WPF and Silverlight moving ahead more or less in lock-step. Features in Silverlight that are successful will find their way into WPF (Visual State Manager, for example). Features in WPF that are useful will move into Silverlight (element binding, based-on styles). Since the products have different audiences, each technology will be driven forward with a different set of priorities. VB.NET and C# already have this So don’t give up on WPF because of all of the excitement from Silverlight. As a WPF developer, I found some of the excitement generated by Silverlight announcements a little odd (applause for element-to-element binding? WPF has had that for a while now). What playing with Silverlight 3 that I have done so far suggests that the disparity between the two features sets is going to be much less in the future.

That having been said, there is still the open question of when WPF should be used instead of Silverlight 3. I can see three main cases at a minimum, but they all revolve around the same restriction in Silverlight…the security sandbox.

Access to local system resources

Off-browser Silverlight runs in the same security context as on-browser Silverlight. So if your application needs access to the local file system or the communication ports on the client machine, then Silverlight is not going to work out. In fact, this limitation can be extended in include any feature that requires full-trust to operation. Silverlight doesn’t work in full-trust mode. WPF can.

Full 3-D graphics capabilities

With Silverlight 3, perspective 3-D is available. But that is not the same as the complete 3-D capabilities that WPF has. It’s nice, but if you’re looking for fully rotational 3-D images, then WPF is the choice.

Semi-Esoteric Functionality

There are instances where Silverlight is missing functionality that is available in WPF. For example, there is no Closing event for a Silverlight application. This means that you can’t stop a user from closing an application when the current record has been modified but not saved. In on-browser Silverlight, a JavaScript hack can be used to emulate this feature. But in off-browser Silverlight, there is no JavaScript available, so no Closing event can be detected. While might seem like an edge case, the functionality offered by Closing is part of most LOB application. So it might not be such a small deal as you might originally think.

I’m sure there are more differences. It’s not like WPF is not a compelling choice for a development platform. In fact, I approach the choice between the two the same way I would between WinForms and ASP.NET. Because ultimately, the decision between Silverlight and WPF will be based on the specific requirements of a project. If Silverlight (either on- or off-browser) is sufficient, then pick Silverlight. If not, then pick WPF. Regardless of your choice, you’re not in danger of dead-ending with the technology. Both areas will flourish and grow for many years to come.

Consuming WCF in Silverlight 3 Session at MIX ‘09

bruce — Fri, 20 Mar 2009 14:01:09 GMT

This session covers three separate scenarios for Silverlight and WCF interactions. The basic functionality of adding a service reference, creating proxy class and calling method hasn’t changed. However, they are trying to address some of the common pain points related to WCF

It’s now possible to remove the network traffic associated with ‘fat’ SOAP/XML messages by using a binary XML format to send the message. The demo reduced message size by 30%. But size was not the main design goal for binary XML. While compression is possible at the HTTP level, apparently binary XML reduces effort on the client and server as messages are compressed and decompressed. Binary XML is intended to improve speed. And while not every message is affected significantly (small messages and strings don’t really benefit), there is no case that MS is aware of where it gets worse. So binary XML becomes an appropriate default formatting standard.

Also included in this section was a description of why server-side error information is not accessible from within Silverlight. Specifically, if you have a server-side HTTP 500 code, the information related to the error does not get pushed to Silverlight. This is a fairly hard limitation related to how browsers pass HTTP information to plug-ins. And Silverlight is really a plug-in. The solution is an HTTP hack, there internal server errors get returned as HTTP 200 codes. And Silverlight 3 is built to pull the error information off of the response and surface it through the normal SOAP faulting mechanism.

When it comes to security WCF calls in Silverlight 3, there are two choices: browser-based and manual. The browser-based approach depends on cookies and Forms authentication at the browser level. This is easy to implement, but is open to cross-domain threats IF you have enable cross-domain access for every Web site. The manual approach has identity managed by Silverlight. When the credentials are added by Silverlight (instead of the browser), the cross-domain thread is eliminated. SL3 provides an out-of-the-box mechanism for creating the SOAP headers associated with the manual mechanism. It’s the ‘out-of-the-box’ that is new in SL3, not the technique itself.

The big gotcha in the manual mode is found in the method that WCF uses to prevent replay attacks. There is the concept of a MaxClockSkew. In indicates how far apart the client and server clocks can be. The default value if 5 minutes. which is to say that if the server system has a time of 11:05 and the client system has a time of 11:11, all messages will be rejected. This is the kind of situation that I’m sure will bedevil developers. MS is still trying to decide what the default value of MaxClockSkew will be when SL3 is released.

The second scenario covered in this session involved pushing messages to Silverlight. It was possible in SL2 to push message to the Silverlight application, but the knowledge required by the developer to implement it has been reduced. Because I’m very familiar with WCF, the technique does not seem advanced. Basically, the idea is to have the SL3 client make a one-way WCF call with a callback contract. The OneWay mode means that there is no calling context hanging around on the client. The callback allows the service to call back to the Silverlight application. In the Silverlight application, there is an event raised when the callback method is invoked from the service.

The third and final scenario talked about REST in Silverlight 3. As it turns out, SL3 doesn’t have much added in this area. Mostly because “the REST story in SL2 was pretty complete” This is actually pretty true about WCF in Silverlight in general. It’s not that there aren’t things that people would like to do with WCF in Silverlight (different bindings, for example). But the reality is that the limiting factor for most new feature requests is the HTTP stack from within the browser. It was mentioned that it’s possible to roll your own HTTP stack by going out to JavaScript through the HTTP DOM, but that technique will probably not work if the Silverlight application is running on off-browser mode.

Off-line and Off-Browser Silverlight

bruce — Thu, 19 Mar 2009 10:48:33 GMT

The big announcement at yesterday’s keynote was the availability of an off-line and off-browser mode for Silverlight 3.0. Just to clarify the terms, off-line mode indicates that Silverlight will not require a live connection to the Internet in order to continue functioning. Practically, this means that a Silverlight application will able to be installed on the client’s computer. Off-browser means that Silverlight apps will no longer appear to need to be running within any browser.

As a point of clarification, this last feature doesn’t mean that Silverlight will have free reign over your computer. Off-browser Silverlight apps will still run in the same security sandbox that they have in the browser. It’s just that you won’t need to explicitly launch the browser to start the application. In fact, the installation process for the Silverlight application includes the ability to place links on the desktop on the system tray

So what are the ramifications of these changes?

First, it opens up a world for Silverlight applications. While I’m a huge fan of WPF, there are a number of roadblocks to wide acceptance. It needs to have the .NET Framework installed (3.5 or 3.0). Which, in itself, implies a Windows platform (according to the Mono project, they are not planning to support WPF). Full WPF applications need to be installed. Yes, you can use XBAP to deploy the application, but that model has implications on security (it runs in the browser-driven security sandbox).

Silverlight, on the other hand, runs on both Windows and Mac. And while it requires an installation step, to call it an install is really overkill. It’s basically an XCOPY from one place to another on the client’s system. The conclusion, though, is that WPF and off-browser Silverlight do hit different target markets.

The second question is how does it change your Silverlight development process.

The goal of off-browser Silverlight was to have the same application run in both modes. And it certainly appears that is the case. However, being able to run the same application off-line and on-line does have an impact on your approach to development. For example, UI pieces might be different. The ability to retrieve data for a combo box, for example, might depend on being able to call out to a WCF service. That isn’t happening in off-line mode (although it would if you were just off-browser). So to create a solid off-line scenario, you may need to provide additional functionality or enable/disable functionality that is currently in place. This is not an insurmountable problem, but it does require some care and design effort.

All in all, off-browser/off-line Silverlight is an interesting idea and I’m looking forward to not only working on apps in this space, but also to see how others take advantage of it. Exciting times indeed.

Having an Out-of-Browser Silverlight Experience

bruce — Wed, 18 Mar 2009 22:12:23 GMT

The fundamental philosophy used to develop the off-browser functionality for Silverlight applications was to reduce the friction surrounding the moving of the application from in-browser to out-of-browser. Specifically, there is no separate download that is required to take a Silverlight application off-line. As a developer, you need to make a change to the manifest to support installation, but nothing more than that. And because the off-browser application runs in the same sandbox as the in-browser application, there are also no security warning messages on installation.

From the user’s perspective, there are two methods to take the application off-browser. The first is the right click on the application. A second option (besides the Silverlight Configuration that has always been there) is visible to indicates that the application to be installed. Also, it is possible to place a button on the application that will install the application.

The manifest is where most of the information used in the installation exists. The name, description and icons related to the application are stored there, along with the flag indicating whether the application can be taken off-browser.

Updating the Silverlight application is exactly the same as the traditional Silverlight application. Which is to say that updates are downloaded and installed automatically. This keeps it consistent with the Silverlight model, where new versions are automatically picked up. The biggest difference is that once a new version is detected and downloaded, the Silverlight application does not automatically terminate and start running the new version. It waits until the next time that the application starts before launching the new version.

Warning – in the beta version, there appears to be a bug associated with updating from your localhost. In the words of the Silverlight PM, it’s a little flaky.

In terms of interacting with the client, an off-browser Silverlight app still has access to the Insolated store. And through the OpenFile and SaveFile dialogs, access to the local file system. There is a quota on isolated storage, but it is increased to 25MB from it’s current size of 1MB. That’s nice and probably sufficient for most applications.

There are still a number of open questions about off-browser Silverlight applications. Is there an event raised when the application is closed (this is done through Javascript in normal Silverlight applications)? Is there a mechanism that simplifies serialization and synchronization? Should there be a way to uninstall the application other than by right-clicking on it (what if the app can’t load)? I’m sure time and the need to make this work in the real world will provide answers.

Go Beyond Best Practices Session at MIX ‘09

bruce — Wed, 18 Mar 2009 16:35:24 GMT

Because I already had some exposure to Silverlight 3 at the MVP Summit, I thought I’d start off with a session directed at creating user experiences. Not to mention that I was interested in the idea of going beyond the superlative of ‘best’ :)

The basic premise of the talk revolves around the idea that companies that succeed find ways to get customers to engage with them. The experience of using the customer transcends the details of the product or service being offered. He mentioned a book called “Firms of Endearment” which describes companies that arouse passion from the people involved. The authors of the book determined that companies that fit this model, exhibit a number of characteristics. One is described by the SPICE model.

Consider the following categories.

Society
Partners
Investors
Customers
Employees

The value created by the companies in Firms of Endearment was equally important across all of these constituencies. Experience is about the effects that we create for these constituencies.

But experience is becoming a buzzword. That is to say, it’s a phrase that businesses use to think that

For most businesses, process is more important that effect. People follow the ‘process’ without a thought to what the effect on others might be. Experiences are a combination of behaviors, attitudes and emotions. For most companies, the emotional side is what’s lacking.

For example, Fed Ex doesn’t believe that it’s in the delivery business. It thinks it’s in the ‘peace of mind’ business. This is really about engineering the experience that people have when they use your product/service. It’s about creating clues as to how important you consider your constituents to be. These clues are frequently small and subtle. And the effort to perform them is also small. But a focus on ROI has obscured the the need to actually follow through. The suggestion is that instead, there should be some concentration on ROY. As in Y not provide the clues necessary to make customers/employees/etc realize that you are as passionate about the business they they are.

I found the presentation interesting. At a minimum, it gave me pause to think about how ObjectSharp delivers to this constituencies. While I think we do a decent job, there are certainly areas where we can improve. And we probably need to pay closer attention to the details of the experience that our customers have. And, in many cases, it’s the details that are more important than anything else.

MIX ‘09 Keynote – Part 3

bruce — Wed, 18 Mar 2009 15:10:29 GMT

Some additional Silverlight 3 improvements that are being announced.

Data Binding improvements, specifically element-to-element bindings
Validation error templates, although there is no support for the IDataErrorInfo interface
improvements on the ability to push data from the server to the client. Conceptually, this is similar to callback functionality in WCF.
Introduction of a DomainServices class that is used to generate a proxy class on the client. The proxy class has the ability to track and marshal changes between the client and server.
Validation logic can be declaratively defined on the DomainServices derived class. The generated proxy class will contain the same validation, triggering the error template within Silverlight.

And now, the big news.

Silverlight 3 will be able to run outside of the browser on both Windows and the Mac. Security is the same sandbox model used from within the browser. There is built-in support for automatic updates. And the application can be aware of its off-line/on-line situation. There will be more about this later in the week, I’m sure.

MIX ‘09 Keynote – Part 2

bruce — Wed, 18 Mar 2009 14:51:55 GMT

More stuff on the Web server side of the equation. There is a new version of the Web Platform Installer. This doesn’t have any impact on me, at least not in the past. But there is now a gallery of community-based applications, such as DotNetNuke, DasBlog and WordPress that can be automatically installed onto a web server through the Platform Installer. Not useful to me, but nice to people who are trying to streamline the build-out of a Web server. You can see a list of these applications here.

Silverlight 3.0 has some new functionality to improve functionality. There will be hardware-based acceleration for compositing, where available. And there are a number of features aimed at improving the media experience. A gentleman from NBC came out and showed some stats on the Beijing Olympics and Silverlight. As well, NBC will do the same for the Vancouver Olympics. Forgive me for not caring, as none of this is available in Canada.

You will probably hear that Silverlight has 3D functionality. A warning that it is not true 3D, but the ability to move a 2D image in three dimensions. The actual term is ‘perspective transform’. If you have to ask about the difference, then you probably don’t care. But for those that do, visualize a flat-screen image that can be rotated about the X-, Y-, or Z-axis so that it appears to be spinning. Hit testing works appropriately (you can only click on the image, regardless of how it is oriented.

Silverlight 3.0 will provide a better experience for SEO. This includes the capability of supporting deep linking and navigation.

Going back to the idea that support for a sketch-based workflow, Expression Blend 3 will have a features called SketchFlow. This feature allows for easy navigation through a collection of pages. The interface allows for quick and simple creation of the workflow through an application. Each state in the workflow corresponds to a page.

One of the things that is interesting about the creation of the pages in a workflow is the inclusion of Wiggly controls. These are controls that, through their appearance, will not be mistaken for a completed application. The borders on the controls take on the appearance of a hand-drawn image. Yet the controls are still real WPF controls, meaning that they work in the Blend and, indeed, when the applications is ‘run’ through the SketchFlow prototyping tool..

MIX ‘09 Keynote – Part 1

bruce — Wed, 18 Mar 2009 14:21:24 GMT

The first part of the keynote was Bill Buxton talking about the benefits of considering user experience and design when creating an application. Certainly a good speaker with passion about hit topics. But I’m afraid that he’s preaching to the converted. He touted the idea of coming up with 5 solutions to any problem, allow the best one to float to the surface. While this is a fine idea, I’m afraid that it will run up against the shoal of fiscal prudence as soon as it gets pitched to management. The trick will be to convince management that five solutions is worth while. He mentioned sketching as a technique, but I’m still waiting for tools to support this approach. The ability to transition from a ‘sketch’ to a WPF form would be quite useful to fill this gap.

One more thing about Bill’s talk. He gave a quote, almost as a throwaway, that I’m sure I’ll use in the future “It’s too important to take it seriously”. While that sounds like a contradiction, I think that in the design space, the implication is that user experience should have some focus on fun and excitement over pure serious. When you think about the shining lights of user experience applications, you’ll find that ‘fun’ and ‘cool’ are big parts of the success.

The first portion of Scott Guthrie’s presentation talked about Web functionality. Expression Web 3 contains a feature called SuperPreview, which allows pages in Expression Web to be viewed (either side-by-side or onion skinned) as they will be rendered in other browsers. This includes browsers that you don’t have installed on your system. The functionality of SuperPreview also makes it easier to identify and isolate problems with rendering in the different versions. The Web 3 version support (at a minimum) IE versions, as well as Firefox and Safari. But there is also a standalone version of SuperPreview which allows comparison between IE 6, 7 and 8. You can download it here.

On the Road to MIX ‘09

bruce — Wed, 18 Mar 2009 10:07:45 GMT

I’m writing this particular blog post while in the air on the way to Las Vegas. For the next three days, I’m going to be at the MIX ‘09 conference. For regular readers of my blogs, that means you can expect a flurry of posts. I tend to live-blog the sessions that I’m in (particularly the keynotes) as a way of note taking, if nothing more. In this way, if nothing more, it is completely different than the MVP Summit I was at a couple of weeks ago.

Actually, there are some other differences. Where the MVP Summit is as much about giving information to Microsoft as it is about receiving, MIX is all about the receiving. While I have some inkling about some of the announcements that you’ll be hearing about, I also know that they have kept some under wraps. Which means that they were even held back from the NDA sessions at the MVP Summit. So, even though I already have some blog posts ready to go, I will still need to pay attention to what’s being discussed. And I’ll pass the good stuff on to you as soon as I can.

The Patch I Didn’t Even Know I Needed

bruce — Thu, 12 Mar 2009 09:39:53 GMT

I have been working with WPF and Silverlight pretty steadily for the past 6 months or so. And thanks to Rocky Lhotka, a problem that I didn’t even realize I had has been (probably) corrected.

The problem was that occasionally Visual Studio would just go away. No warning. No error. Just disappear. It didn’t happen that often for me, but I have had awkward moments while teaching a course. Even in that situation, neither I, nor any of the students did anything but shrug, chuckle and restart. These things do happen in the world of software development. The fact that we were willing to just accept it unquestioningly is a blog post for another day.

However, while perusing my blog roll yesterday, I came across this post from Rocky. It talks about a hotfix for a problem that causes Visual Studio to just disappear. Way too coincidental. A quick download and, hopefully, I’m inoculated from this issue going forward. If you’re using WPF in Visual Studio, it’s a fix you might strongly consider.

Fixing ‘prop’ Snippet Compatibility

bruce — Sun, 08 Mar 2009 02:34:00 GMT

As you might have gathered from reading my recent post on changing generated code in VS2008, I wasn’t thrilled when Microsoft changed the behavior of the prop snippet between VS2005 and VS2008. It’s almost two years later and my fingers still want to type 'prop’ even when I know that using automatic properties is very, very unlikely to be the thing that I want to generate.

My solution to this consternation was to create a custom snippet. The XML found below can be used to create such a snippet. In this case, the snippet is named ‘propfull’ and its template creates a property complete with the backing variable. It can be loaded into Visual Studio by using the Import button found in the Tools | Code Snippet Manager dialog box. The other possible approach would be to edit the snippet that comes with VS2008, but I’m loath to make that type of change to the default. Changing behavior that others have come to expect would evil, wouldn’t it Microsoft?

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>propfull</Title>
            <Shortcut>propfull</Shortcut>
            <Description>Code snippet for property implemented using a backing store</Description>
            <Author>Bruce Johnson, ObjectSharp Consulting</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>type</ID>
                    <ToolTip>Property type</ToolTip>
                    <Default>int</Default>
                </Literal>
                <Literal>
                    <ID>backing</ID>
                    <ToolTip>Backing variable name</ToolTip>
                    <Default>myProperty</Default>
                </Literal>
                <Literal>
                    <ID>property</ID>
                    <ToolTip>Property name</ToolTip>
                    <Default>MyProperty</Default>
                </Literal>
            </Declarations>
            <Code Language="csharp"><![CDATA[
private $type$ $backing$;
public $type$ $property$
{
   get { return $backing$; }
   set { $backing$ = value; }
}$end$]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>

My Biggest Disappointment at the MVP Summit

bruce — Thu, 05 Mar 2009 16:52:28 GMT

I’ve just come home from spending the last three days in Redmond at the MVP Summit. For those who might not be aware, the Summit is an annual event that Microsoft hosts for Most Valuable Professionals (MVP). The MVP designation is given to people who have contributed in a positive way to the community through speaking, blogging, answering questions in forums or organizing user groups and conferences at the local level. At the Summit, the various product groups get the opportunity to demonstrate some of the futures for their products in order to solicit feedback. The chance to meet and talk with product group members is actually one of the main benefits of being an MVP to me. They are people who are passionate about the code they write and who love to hear about the good and the bad.

However, the futures that are being discussed are really that. We’re not talking about what’s going to be in VS2010. The feature list for that has been set in stone for a while and is generally well known. Instead, we’re talking about what might be coming in the next version of Visual Studio. Or Silverlight. Or ASP.NET. Or Data Programmability. These futures have not, for the most part, even been designed much less coded. So to talk with us about this, MVPs at the Summit (and, indeed, all MVPs) have to sign a non-disclosure agreement (NDA). This means that we cannot discuss with anyone outside of the MVP community what we have seen and heard until the information becomes public.

Today’s technology, combined with the outgoing personalities of MVPs makes this restriction a challenge. Normally when I’m at a conference, I’m live blogging the session that I’m in. Or I’m twittering my schedule. Can’t do that here. It gives me itchy fingers, but the NDA is taken quite seriously. Even the code names for various projects are considered NDA, a problem for the person who unthinkingly twittered one while in sessions on Monday.

So that inability to share is my biggest disappointment. Not an unexpected one (I’ve been to the Summit before and am under NDA constraints constantly), but still a source of sadness nonetheless. But let me just say that I’ve already written some blog posts that will be published once the details of the products are made public in the near future. Hopefully that little tidbit of foreshadowing won’t get the NDA police on my trail.

Clearing the Debugging Tooltip

bruce — Mon, 02 Mar 2009 03:45:57 GMT

On the scale of annoyances, this is not a huge one. But the solution is so simple, that it’s worth a quick post.

Have you ever been in the middle of debugging an application and used the hover functionality to display the current value of a variable? And expanded multiple levels to find the specific property that you’re looking for? Of course you have.

But have you ever been frustrated when the debugging view obscures a piece of code that you’re interested in? So that you have to close the debugging tooltip to see the code and then navigate through the hierarchy to get back to what you were looking for? Odds are that it has happened to you. It certainly happens to me frequently enough.

Fortunately, there is a solution. While the debugging tooltip is displayed, simply press the Ctrl key. This instantly makes the tooltip transparent. And when you release the Ctrl key, the tooltip reappears. Simple and elegant, just the way all solutions should be.

Thanks to Dave Lloyd and Brian Rasmussen for the information (same tip at different times).

Changing Generated Code in VS2008

bruce — Mon, 02 Mar 2009 02:47:34 GMT

Have you ever been dissatisfied with the code that is automatically generated by Visual Studio in response to various commands that you perform. For example, in VS2005, I got used to using the prop snippet to create properties. This snippet created a property declaration complete with a private backing variable. However, in VS2008, the prop snippet was modified to create a property declaration in the form of the automatic property declaration. That, to me, was annoying.

(Note to Microsoft: Please consider the existing snippets to be part of what you consider when looking at backwards compatibility. Create more snippets, sure. But please don’t change what the current snippets do…especially when the ‘better’ snippets are not actually better)

Or, consider the fact that, as more and more work is done in WPF, the need to ensure that business classes implement INotifyPropertyChanged grows. Adding or modifying a snippet to include the code to call PropertyChanged could be quite useful. It certainly has been for me.

Little known by most developers is the location for the snippets that Visual Studio provides. Or, what might be more interesting to intrepid developers, the snippets used by Visual Studio refactoring. All of these are found in %ProgramFiles%\Microsoft Visual Studio 9.0\VC#\Snippets\1033. The keyword snippets can be found in the Visual C# subdirectory, while the refactoring snippets can be found in the Refactoring subdirectory. Take a look at what’s there and you may be surprised how you can increase your productivity for mundane (and frequent) tasks.

“Fixing” the WPF Designer

bruce — Sat, 28 Feb 2009 03:41:55 GMT

If you use WPF on a regular basis, then I can take a good guess as the esteem in which you hold the designer. While it has it’s place, hard code WPF devs using XAML directly. It’s much each to get the result that you’re looking for quickly. The problem I’ve always had is that when you open a WPF file, even when you have disabled the design portion, there is still a significant time lag.

Thanks to Fabrice Marguerie who wrote this blog post which describes how to eliminate that annoying delay.

It’s nice to have less friction between me and my XAML. :)

Excel automatically defines column types

bruce — Thu, 26 Feb 2009 03:39:40 GMT

So to set up this problem, an application that I'm currently working on needs to process data that is stored in an Excel spreadsheet. The creation of the spreadsheet is actually performed by a scientific instrument, so my ability to control the format of the output is limited. The instrument samples liquids and determines a quantity. That quantity is placed into the spreadsheet. If the quantity in the liquid is not successfully read, then the literal "Too low" is placed into the sheet. The application opens up the spreadsheet and loads up a DataSet using the OleDb classes (OleDbConnection and OleDbDataAdapter).

This seemed like a fine setup. At least, until some of the numeric values in the spreadsheet were not being read. Or, more accurately, the values in the spreadsheet were not making it into the DataSet. Head-scratching, to say the least.

After some examination, the problem became apparent. When the values were being successfully read, the column in the DataSet had a data type of Double. When the values were not being successfully read, the column in the DataSet had a data type of String. Now the difference between success and no-success was nothing more than the contents of the spreadsheet.

Now the obvious path to follow is how the data type of the column is determine. Some research brought me to what I believe is the correct answer. The Excel driver looks at the contents of the first 8 cells. If the majority is numeric, then the column's data type is set to Double/Integer. If the majority is alphabetic, then the column becomes a string.

Of course, this knowledge didn't really help me. As I said at the outset, my ability to control the format of the spreadsheet was limited. So I needed to be able to read the numeric data even if the column was a string. And, at present, the cells containing numbers in a column marked as a string were returned as String.Empty.

The ultimate solution is to add an IMEX=1 attribute to the connection string. This attribute causes all of the data to be treated as a string, avoiding all of the cell scanning process. And, for reasons which I'm still not certain of, it also allowed the numeric data to be read in and processed. A long and tortuous route yes, but the problem was eventually solved.

Walking the WPF Control Hierarchy

bruce — Wed, 25 Feb 2009 20:33:46 GMT

I just finished teaching a Silverlight/WPF course last week. As is true in almost every course I teach, there were questions from people who are trying to use the technology in the real world. It's what I love about teaching...that I always learn something about how people use the tools they have been given.

In this particular case, the problem was relating to walking the control hierarchy in a user control. The user control contained a DataGrid and the goal was to get from a particular cell within the DataGrid back to the user control itself. The code that was written to do so looks approximately like the following.

public UserControl GetContainingUserControl(FrameworkElement element)

{

if (element is UserControl)

return element;

else

return GetContainingUserControl(element.Parent);

}

The problem with the code is that, in the case specified, the Parent becomes null before the UserControl is found. For most developers, this is a strange and unexpected turn of affairs. For most hierarchies, it seems completely reasonable to presume that every element in a hierarchy will have a non-null parent except the root of the tree. But if you read over the description of the Parent property closely, you will see that it could be null. From MSDN,

Parent may be a null reference (Nothing in Visual Basic) in cases where an object was instantiated, but is not attached to an object that eventually connects to the Silverlight RootVisual, or the application object.

Ouch. Sure it's documented, but still. Ouch.

Fortunately, there is a solution, found in an incredibly useful class named VisualTreeHelper. This class exposes a number of methods that can be used to navigate up and down the visual hierarchy in a WPF interface component. There is, for example, a GetChild method that retrieves a particular child element. As well, of particular interest for this example, there is a GetParent method that retrieves the parent of a given element. This method will not return a null parent until the top of the visual hierarchy is reached.

In other words,VisualTreeHelper.GetParent(element) can be used in place of element.Parent in the above method with the result being more in line with expectations.

Whew.

First Post of the Year and a Gift for You

bruce — Tue, 06 Jan 2009 11:53:21 GMT

Now that the holidays are over (which weren't particularly fun for me this year, due to a persistent bout with sinusitis), it's time to get back to the posting. And to start things off, let me offer any of you who might be thinking about going to DevTeach Vancouver at the beginning of June (8th to the 12th). Jean-Rene Roy, the organizer of the conference, has offered 50% off the registration cost to the first 30 people who register with the following code: DEVT50OFFVAN. Also, the registration need to be done prior to Feb 10th.

If you've never been to a DevTeach conference, you don't know what you're missing. This is easily the top .NET developer-focused conference in Canada. They get big name speakers presenting on the latest and greatest of technologies. As well, the setup for the conference is such that the speakers are much more accessible than any other conference I've been to. So not only will you be able to hear familiar luminaries, but you'll also get the ability to speak with them one-on-one. A great deal at full price, this becomes an incredible opportunity at half-price. So if you were just thinking of going, let this offer make your mind up for you.

My Book is now Available

bruce — Sun, 16 Nov 2008 15:56:31 GMT

In the excitement of PDC, it slipped my mind to let everyone know that the book on which I was a co-author was actually shipped at the beginning of October. The title is the terse, yet incredibly descriptive MCTS Self-Paced Training Kit (Exam 70-503): Microsoft® .NET Framework 3.5 Windows® Communication Foundation (PRO-Certification). There is a bidding war for the movie rights and I'm hoping that George Clooney plays me in the adaptation. :)

For those of you wondering how the actual release might have slipped my mind, the reason is that I'm not involved in the steps that takes place at the end of the publishing process. Most of the book was written in the first half of the year. Since July, I have been reviewing chapters and responding to editor notes. But since the middle of August my tasks have been done. And, I'm afraid, when it comes to book writing, once I'm done, I mentally move on to the next task. So I wasn't even sure when the publication date was. But it was released and, based on the numbers that I've seen so far, it seems to be doing quite well. If any of you have the chance to read it, I'd be thrilled to hear any feedback (both good and bad).

Non-Geek Fun

bruce — Sat, 15 Nov 2008 21:19:26 GMT

I've been a fan of Malcolm Gladwell since I read The Tipping Point. And after following that up with Blick, it is clear that Mr. Gladwell is a fascinating author on subjects that are quite interesting, even when it falls outside my normal range of reading material (that being mostly geeky ). Apparently on Tuesday, a new book of his entitled Outliers: The Story of Success is coming out. That in itself is enough to pique my interest. However, it turns out that, as part of his book tour, Mr. Gladwell is speaking in Toronto on Dec 1 at the University of Toronto Rotman School of Business. And the price of the tickets (only $31 and which you can get here) includes a copy of the book. I'm signed up already and if you have found his books interesting, here is a chance to hear him in person.

Problems Publishing Unit Tests from VSTS

bruce — Mon, 03 Nov 2008 19:07:45 GMT

Earlier today, a colleague had an issue with the publishing of unit test results into a TFS instance. The publication process, which is typically done manually at the click of a button, was no longer available. Specifically, the Publish button was actually disabled. There was no obvious error message indicating what, if anything, was wrong. This lack of information made identifying the problem a challenge, to put it mildly.

The solution, at least to identifying what the problem was, is to use the command line version of MSTest. If you execute the command MSTest /? in a command window, you will see that there are a number of options which can be used to execute a set of unit tests and publish them to a TFS server. For example, the following command will execute the unit tests in the TestLibrary.dll assembly and publish the results to the TFS server located at http://TfsServer:8080

MSTest /nologo /testcontainer:"TestLibrary.dll" /runconfig:"localtestrun.testrunconfig"
/resultsfile:"TestLibraryResults.trx" /test:TestLibrary /publish:http://TfsServer:8080
/publishbuild:"DemoTestBuild_20081103.1" /teamproject:"DemoProject" /platform:"Any CPU" /flavor:Debug

In this particular situation, running MSTest generate an error that indicated that the drop location for the build could not be created. An error that was, thankfully, quite easy to correct. But difficult to identify without using the command line tool.

More Thoughts on the Cloud

bruce — Fri, 31 Oct 2008 14:04:18 GMT

One of the more farsighted thoughts on the implications of cloud computing is the concern about vendor lock-in. Tim Bray mentioned it in his Get in the Cloud post

Big Issue · I mean a really big issue: if cloud computing is going to take off, it absolutely, totally, must be lockin-free. What that means if that I’m deploying my app on Vendor X’s platform, there have to be other vendors Y and Z such that I can pull my app and its data off X and it’ll all run with minimal tweaks on either Y or Z.

...

I’m simply not interested in any cloud offering at any level unless it offers zero barrier-to-exit.

This idea was also commented on by Dare Obasanjo here. It was Dare who originally pointed me at Tim's post.

My take on the vendor lock-in problem is two-fold. First is the easier one to deal with - the platform on which the application is running. As it sits right now, use of Azure is dependent on you being able to publish an application. The destination for the application is a cloud service, but that is not a big deal. You can just as easily publish the application to your own servers (or server farm). The application which is being pushed out to the cloud is capable of being deployed onto a different infrastructure.

Now, there are aspects of the cloud service which might place some significant requirements on your target infrastructure. A basic look at the model used by Azure indicates that a worker pattern in being used. Requests arrive at the service and are immediately queued. The requests are then processed in the background by a worker. The placement of the request in the queue helps to ensure the reliability of the application, as well as the ability to scale up on demand. So if you created an infrastructure that was capable of supporting such a model, then your lock-in at the application level doesn't exist. Yes, the barrier is high, but it is not insurmountable. And there is the possibility that additional vendors will take up the challenge.

The second potential for lock-in comes from the data. Again, this becomes a matter of how you have defined your application. Many companies will want to maintain their data within their premises. In the Azure world, this can be done through ADO.NET Data Services. In fact, this is currently (I believe) the expected mechanism. The data stores offered by Azure are not intended to be used for large volumes of data. At some point, I expect that Azure will offer the ability to store data (of the larger variety) within the cloud. At that point, the spectre of lock-in becomes solid. And you should consider your escape options before you commit to the service. But until that happens, the reality is that you are still responsible for your data. It is still yours to preserve, backup and use.

The crux of all this is that the cloud provides pretty much the same lock-in that the operating system does now. If you create an ASP.NET application, you are now required to utilize IIS as the web server. If you create a WPF application, you require either Silverlight or .NET Framework on the client. For almost every application choice you make, there is some form of lock-in. It seems to me that, at least at the moment, the lock-in provided by Azure is no worse than any other infrastructure decision that you would make.

Summarizing the Cloud Initiative

bruce — Fri, 31 Oct 2008 04:11:30 GMT

So it's the last few hours of PDC for this year. Which means that pretty much all of the information that can be shoved into my brain has been. It also means that it's a pretty decent moment to be summarizing what I've learned.

Obviously (from its presence in the initial keynote and the number of sessions) cloud computing was the big news. This was also one of the more talked about parts of the conference, and not necessary for a good reason. Many people that I have talked to walked out of the keynote wondering exactly what Azure was. Was it web host? If so, what's the point? It's not like there aren't other companies doing the same thing. Could it be more than web hosting? If so, that wasn't made very clear from the keynote. In other words, I was not exactly chomping at the bit to try out Azure.

But it's here at the end of the week. And I've had a chance to see some additional sessions and talk to a number of people about what Azure is capable of and represents for Microsoft. That has tempered my original skepticism a little. But not completely.

In the vision of Azure was presented, the cloud was intended to be a deployment destination in the sky. Within that cloud, there was some unknown infrastructure that you did not need to be aware of. You could configure the number of servers to go up or down depending on the expected traffic to your site. As you change the configured value, your application becomes provisioned accordingly. This is nice for companies that need to deal with spikes in application usage. Or who don't have (or don't want to have) the support personnel for their infrastructure.

However, there are some limitations to the type of applications which can fit into this model. For example, you need to be able to deploy the application. This implies that you have created the application to the point where you can publish it to the Azure service. The published application might include third party components (a purchase ASP.NET control, for example), but can't use a separate third-party application (such as Community Server).

As well, you need to be able to access the application through the web. You could use a Silverlight front end to create the requests. You could use a client-based application to create the requests. But, ultimately, there is a Web request that need to be sent to the service. I fully expect that Silverlight will be the most common interface.

So if you have applications that fit into that particular model, then Azure is something you should look at. There are some 'best practices' that you need to consider as part of your development, but they are not onerous. In fact, they are really the kind of best practices that you should already be using. As well, you should remember that the version of Azure introduced this past week is really just V1.0. You have to know that Microsoft has other ideas for pushing applications to the cloud. So even if the profile doesn't fit you right now, keep your ears open. I expect that future enhancements will only work to envelope more and more people in the cloud.

WPF Futures

bruce — Tue, 28 Oct 2008 21:33:12 GMT

I just got out of the WPF Roadmap talk. I found the future for WPF less interesting that the present, although that could very well because the speed of innovation coming from that group has been very high over the past couple of years. In fact, the 'roadmap' is as much about the present as it is about the future.

Mention was made of the fact that the SP1 version of .NET 3.5 actually included a fair bit of 'new' functionality for WPF. As well, they have just released some new controls that are in different states. There is a DataGrid, Calendar control and DatePicker that are officially released. And there is a brand new ribbon control that is (I believe) in CTP mode.

As well, there is also a Visual State Manager available for WPF. This is actually quite cool, as the VSM solves a problem that WPF has (and that SIlverlight already has). Specifically, it could be challenging to get the visual state of a control/page/form matched up with the event or data triggers that would be raised within the application. The Visual State Manager lets you associate a storyboard with a particular state and then set the state programmatically, at which point WPF runs the storyboard.

Both the ribbon control and the VSM are available right now

The future for WPF seemed less clear. A list of 'potential' controls was presented. And some general comments about improvements in the rendering, integration with touch, etc. In other words, the future appears to be now. I guess that lack of specificity is to be allowed when a product group is right at the beginning of it's development cycle.

Silverlight 2.0 Penetration

bruce — Tue, 28 Oct 2008 16:27:38 GMT

I'm sure that you know that Silverlight was released a couple of weeks ago. ScottGu made an interesting comment indicating that Silverlight (that would be 1.0 or 1.1) was installed on 1 in 4 computers that are connected to the Internet. And that over the next month, those computers would be updated to 2.0. Also that they had already upgrade 100 million computers. These numbers surprised me, only in that I didn't expect that penetration had achieved that goal.

It also provides a number that might encourage people to start developing externally facing applications using Silverlight. Which, given some of the capabilities, is a good thing.

Development Changes

bruce — Tue, 28 Oct 2008 16:08:01 GMT

The presenter for the development changes related to .NET and Windows 7 is ScottGu. Who else?

First off, Microsoft will be releasing a WPF ribbon control later this week. That is very nice, especially since the ribbon is the new hotness when it comes to the user interface.

Demos also mentioned the integration of touch and jump lists, which are Win7 specific functionality. The jump lists (which is context sensitive functionality available through the thumbnail for an application) are simply commands which are implemented and registered by the application. Touch integration includes the ability to tie gestures to commands. So, ultimately, commands become the main mechanism for integrating WPF and Win7, at least at this level.

Today, some additional WPF controls are being released. This includes DataGrid and a DataPicker control, as well as a Visual State Manager (a feature that greatly improves the creating of interfaces that depend upon events within the UI).

.NET 4.0 includes support for the dynamic language runtime.

VS2010 includes improvements for WPF designer. It also appears that VS2010 was built using WPF (at least the UI portion). Other areas of improvement include a streamlined test-driven development (TTD) model, and a better extensibility within the editor (and the IDE itself). For the later functionality, check out the Microsoft Extensibility Framework (MEF). The idea behind MEF is to allow for better visualization of data, even from external sources such as TFS, within the IDE. The demo includes the ability to grab bug information from TFS and display it while looking at the code associated with the bug.

Windows 7 Brick-a-brack

bruce — Tue, 28 Oct 2008 15:44:25 GMT

A couple of notes on how Windows 7 will improve O/S and application performance and some additional features.

If you reduce the granularity of a timer, you can improve power consumption.

They are trying to reduce the memory and processor requirements for Windows. Sinofsky (the speaker) held up his current machine, which is a 1MHz, 1GB system on which Windows 7 uses only half the RAM when started.

A VHD can be created from within Windows (yeah!!!!!). As well, a VHD can be added to a running instance of Windows. And the machine can be booted from a VHD using the boot manager. This has the potential to be quite cool, especially for people like me who go from system to system on a regular basis.

Built-in zoom-in and zoom-out. Useful for me when I'm training.

To give you an idea of what the release schedule for Windows 7 is, the version that is available is basically the Milestone 3 version. There are still basically two steps to go. Next up, after the Milestone 3 is the Beta version, which is expected to be out at the beginning of next year. While M3 is criteria complete, in terms of performance, it is not feature complete. The beta version will be feature complete when it comes out. Microsoft is basically looking for us to use Windows 7 and provide feedback that will impact bugs fixes and the release schedule.

That having been said, there is no hard timeline for when Windows 7 will be released. The only comment beyond that was "we're sticking with the idea of roughly 3 years from the Vista release". Which, if memory serves, means that we're talking about Q4 2009 or Q1 2010.

Windows 7 includes Touch Support

bruce — Tue, 28 Oct 2008 15:12:52 GMT

First off, I find touch cool. I couldn't really use it to do my work, but I love the possibilities for improving user experiences.

Windows 7 has built in support for touch in a number of ways. First, applications don't need to explicitly support touch in order to be used by touch. Second, the interface with touch goes beyond using your finger as a mouse. It includes the concept of 'gestures'.

This is tough to explain in words, but let me try. Say you were looking at a Word document and you wanted to scroll down. You could 'flick' your fingers down and it would scroll as if you had started to roll a wheel. This is quite similar to the interface that an IPhone has. Along the same line, you can go back in IE by 'flicking' to the left. The subtlety of the interface fits nicely with my idea of the kinds of animation that a good WPF application should have.

Ray Ozzie Keynote - Day two

bruce — Tue, 28 Oct 2008 15:01:52 GMT

The starting point for his presentation was to talk about how the Internet has become ubiquitous. And how there is a benefit to having proximity between the hardware, the software and the user. He also mentioned the phone as one of the software platforms that are part of most people's lives, which is not a surprise considering the comments about the Live Mesh made at Mix '08.

Also interesting that Windows 7 is being referred to as the 'client' operating system. The intent is obviously to set up the idea that the next version of Windows is intended to be the 'client' to the Azure 'service'.

The highlights for Windows 7 include:

Changes to the taskbar to including thumbnails of the running instances of an application, as well as the ability to manage (e.g. close, open a recently used document, etc.) an instance from the thumbnail.
Improvements to the searching capabilities within the machine, as well as across the machines in your home network.
Improvements to automatic connection while in your home network. This includes discovery of other Windows 7 machines on the network. And, more importantly, the default printer changes to a printer within your home network (instead of having to remember to change from your printer at work).

These last two points indicate the focus for Windows 7 improvements, that being to try to smooth the integration of computers within a home next.

More to follow.

ASP.NET 4.0 Futures

bruce — Tue, 28 Oct 2008 14:38:18 GMT

One way that you can tell that a product is getting more mature by the type of features that are included with new release. By this measure, ASP.NET is getting to be positively adult like.

I just sat through the session on ASP.NET 4.0 futures. The main announcements are surprisingly tame. Well, surprising by former ASP.NET standards. And not particularly revolutionary.

There are, of course, other reasons for that. The ASP.NET team has been working on a release schedule that is based on Internet time. In other words, you can't want for three years between releases when the rest of the world is innovating every 6-9 months. That's one of the reasons that you saw an MVC release onto Codeplex. It's why you saw Atlas before AJAX. And why the AJAX Control Toolkit exists.

As a result, the advancements are more along the lines of incorporation and integration of these features. MVC is officially part of the product. As is the AJAX Control Toolkit. All good things, but definitely not earth-shaking.

There are a couple of changes on the technology side. There is support for JQuery, a JavaScript library used to improve the integration between JSON and HTML. The binding used in AJAX looks much more like the WPF binding syntax. That last point made me wonder how long until there is a convergence of ASP.NET and WPF, when it comes to application markup.

There are a number of other announcements, regarding JavaScript integration, better granularity when it comes to enabling and disabling ViewState (yeah!), and more control over how server controls deal with CSS markup. If you spend your business hours working with ASP.NET, some of this will probably fall into the 'finally' category. But for me, there was nothing that I found particularly compelling.

A Lap Around Windows Azure

bruce — Mon, 27 Oct 2008 17:43:09 GMT

The first session that talked about Azure was (not surprisingly) incredibly popular. Filled a room that looked like it seated 700+ people. Then filled an overflow room. And the second overflow room is pack with people standing at the back.

The sample app is a thumbnail generator. In other words, a function that could normally be provided by a Windows Service. Interesting that the 'simplest' scenarios is that one. Interesting that it seems to indicate that what you're deploying into Azure is a service with ASP.NET or Silverlight as the user interface

A couple of times now, Azure has been referred to as an operating system.

Currently, the storage abstractions are: blobs for user data, simple tables for service state and queues for service communications. But these abstractions are not intended to replace a database. Astoria seems to be the expected CRUD channel.

"Azure is an operating system" is getting to the point where it should become a drinking game.

The second demo is a live site, managing teachers in Ethiopia. The speaking actually asked that we not to go to the site because it is live and the the typical usage pattern doesn't include being hit by 1000+ rabid developers all at once. :) In what appears to be a common approach, the user interface is a Silverlight communicating with Azure through web service calls.

As of noon (PDT) today, you can go to http://www.azure.com and download the desktop SDK. And publish applications to the close. Currently usage is free, with restrictions. And there is no indication yet regarding the pricing model, although in the keynote, Ray Ozzie suggested that it would be 'competitive' and that there would be support for 'hobbyists'. So look to Amazon's EC2 for a rough idea and figure that you will have some low/no cost option for you to play with.

Azure and On-Premises Data

bruce — Mon, 27 Oct 2008 16:47:02 GMT

One of the more interesting questions that will arise from cloud computer in general and Azure specifically is how the connection with on-premises data will be maintained. Based on what I saw in the keynote, they appear to have the link to Active Directory well in hand. In other words, identity can be federated so that the Azure service receives the credentials and passes the authentication request to an Active Directory server running on your corporate network. The demo in the keynote made that process look incredibly easy. Demo easy, with no discussion over the potential security risks or configuration requirements for the AD server. But that's beside the point (for the moment).

My real question relates to the access required for non-identity data. How will a company's internal data be made available to an Azure service. It appears that the answer is going to include SQL Data Services, but I'll be interested in hearing more about the details. Specifically, the level of exposure and integration required to allow an Azure application to retrieve and update information that is available only through an internal network. That has the potential to be an interesting challenge and set up a confrontation between security and functionality.

Welcome to the new world, same as the old world.

Nothing like some new terms

bruce — Mon, 27 Oct 2008 15:17:31 GMT

Get ready to hear about the 'Fabric controller'. In a cloud computer environment, the fabric controller is the "O/S". It is responsible for managing the services that you have configured.

Modeling your services

The first step is to model your service. This means to define the attributes related to the deployment and execution of your service. This includes the channels and endpoints for your service (do a quick look to WCF for the definition for these terms). As well, you define the security model by identifying the roles and groups. This information is persisted as the configuration for the service.

Development Tools

The developing and testing of the service can be done using familiar tools (i.e. VS2008). There is no need to deploy to the cloud in order to test. There is also no requirement that the application be written purely in managed code. This piece of information is a bit of a clue as to what is going on under the covers. In other words, there is probably Windows running someplace.

The development environment 'simulates' the cloud computing environment. Once the application is completed, it can be 'published' to Azure. The 'package' (the bin output for the project) and the configuration file is sent to Azure. After a few minutes, your application is running live on the cloud.

Simple. At least for the "Hello World" application. :)

Windows Azure Links

bruce — Mon, 27 Oct 2008 15:03:18 GMT

If you're looking for a set of links that provide more info on Windows Azure, check out http://blogs.msdn.com/cloud/archive/2008/10/27/bookmarks-windows-azure.aspx

Ray Ozzie Keynote at PDC 2008

bruce — Mon, 27 Oct 2008 15:01:20 GMT

Today's focus is on the back-end innovations. The client conversation/demos will be done at tomorrow's keynote. In other words, this is the 'cloud' talk.

The content of the first portion of his talk is about the convergence of IT Pro and IT Dev functions. Basically, he is making a case for the need for cloud computing. Things like redundancy, resilience, reliability, etc. Nothing exceptionally new here. But he then branches to the idea that, rather than having the infrastructure within a corporation, perhaps it would be better to have the infrastructure hosted by someone who specializes in offering web functionality that supports millions of developers. I think I can see where this is heading :)

The new service is called Windows Azure.

That explains the 'blue' theme seen throughout the Convention Center.

One of the goals is to be able to integrate the service with the existing toolset. "And you can", says Ray. But there will also be a new set of tools aimed at assisting developers with this 'cloud design point'. After all, it's not quite the same as traditional Windows applications. The focus for a typical Windows application is 'scale-up' and not 'scale-out'. And to work properly with the cloud, the 'scale-out' model is a requirement.

Keep in mind that one of the benefits of the cloud computing is the ability to increase capacity by turning a dial that increase the number of 'servers'. For your application to work successfully in that environment, the manner in which you develop applications might change significantly. But the details on that piece will have to wait for tomorrow.

Now it's time for the demos. More shortly.

Traveling to PDC 2008

bruce — Mon, 27 Oct 2008 14:14:46 GMT

I'm writing this while at 35,000 feet, winging my way to PDC in Los Angeles. This is actually my first PDC so I'm looking forward to it. I've been to Tech Ed and Mix in the past, but have never made it to a PDC. How can anything bad happen while I'm surrounded by 7,000+ geeks?

There are a couple of areas where I expect to see some significant announcements. Some of them, such as the beta bits for Windows 7 and an early CTP for VS2010, are already widely anticipated. But there are likely to be more (and potentially more interested) announcements from across the company.

For example, I expect to hear some big initiative surrounding cloud computing. Aside from tools that will help developers take advantage of the technology, it wouldn't surprise me to hear about a service that competes with Amazon's new E3 service.

Another potential target for news is the Oslo project. There has been a bit of buzz (oooooo...alliteration) on this upgrade to Microsoft's service layer offering, but it will be interesting to see how Oslo is positioned, especially in relation to any cloud computing announcements.

Beyond the above, I'm sure there will be more surprises. From the number of sessions on the agenda, I expect that there will be some VSTS innovations. And my interest has been piqued by an MSR project called Pex that deals with automated white-box testing. I'll be live-blogging from the keynotes and the sessions that attend, basically commenting on anything that catches my ear. So stay tuned for some PDC details...at least, my take on them.

A Disappointment with PPTPlex

bruce — Wed, 03 Sep 2008 23:42:17 GMT

I did a presentation this afternoon on some of the basic functions of WCF. I had put a slide deck together using a new Microsoft Office add-in called PPTPlex. You can see demos of what this add-in does in the provided link, but basically is allows for a much more dynamic experience of going through the slides in a slide deck. As compared to the typical linear flow, PPTPlex allows you to easily jump from one slide to another with a couple of clicks up and down the slide hierarchy.

I was pretty excited to be able to put this technology to work in the real world - right up to the time when I started the slide show.

Most of the time when I do presentations, I use a split screen. That is to say that what is displayed to the audience is not the same as what I see on the laptop in front of me. The new Presentation Mode in PowerPoint 2007 helps me a great deal with working that way. I was expecting that, when PPTPlex was run as a slide show, I would have expected the same appearance, that being that the slide show (such as it is) would be displayed on the secondary monitor.

I was disappointed.

Now it may be that there is a setting that I missed that would have allowed this to happen. I will admit that I was standing in front of the class when I tried this, so the time allocated for exploration was limited. But I expected it to just work and it didn't. Sigh.

Now I haven't yet got back to a place where I can do some detailed investigation, but as soon as I do I will see if I missed something. I hope so, but I doubt it. More details as they become available.

Mind Mapping from Word 2003 to 2007

bruce — Thu, 28 Aug 2008 15:31:51 GMT

I recall my first experience with Word 2007...it took me 20 minute to figure out how to do a Save As. Who would have figured that the cute icon in the top left corner actually had functionality associated with it. :)

In a blog post from Chris Sells, I was point to a tool whose purpose is to bridge this gap. You see an on-line image of Office 2003 menu structure and by hovering an item, you are told where to find the same function in 2007. You can find the tool here. Check it out, use it and avoid the embarrassment that I went through.

Writing is done, so back to the blogging

bruce — Thu, 21 Aug 2008 12:49:00 GMT

The two or three of you who follow my blog with regularity will have noticed that I was dark for most of the summer. The reason was that I was in the process of writing a book. Co-writing, would be more accurate, but still long hours were spent pounding out prose on my antique Underwood. Okay, maybe not so much pounding, but writing a book does dry me out for writing blog posts.

The recent influx of posts would seem to indicate that the book writing process was finished. And indeed it is. In fact, my editor informed me yesterday that the files have been shipped off to the publisher for final processing and printing. This is a source of great cheer, as I can now rest easy that no additional requests for editing will arrive in my inbox.

For those of you who are interested, the book is the MS Press training kit for the Windows Communications Foundation exam. You can see what it looks like at Amazon. And feel free to buy multiple copies...they make great Christmas gifts

Visual Studio and SQL Server 2008 Conflicts

bruce — Mon, 11 Aug 2008 13:40:18 GMT

I'm just passing along some information that has been making the rounds (I found it on Guy Burstein's blog).

If you attempt to install SQL Server 2008 on a machine that has Visual Studio 2008 installed, it will fail. The requirement is to have VS 2008 SP1 installed, an update that is still about a week away from release. And you need the 'real' SP1. The same problem exists with the beta for SP1.

So, for you developer/database people out there, it looks like at least a week of waiting to get the combination on a single machine.

Misleading "Could Not Locate Dependency" message in Composite UI Block

bruce — Fri, 08 Aug 2008 17:00:41 GMT

The project that I have been working on for a number of months uses the Composite UI Application Block (CAB) as the basis for the user interface. If you have never worked with CAB before, it is an interesting framework. In many ways it makes tasks easy that would be incredibly challenging otherwise. This includes the ability to add and remove elements from the user interface by simply adding or removing lines from an XML file. On the other hand, there are parts of CAB that appear to work as if by magic.

One of the 'magic' pieces is dependency injection. As a smart part (the name of the UI element that is part of the composition process) is loaded, the presenter (CAB supports a model-view-presenter pattern) is instantiated with some number of parameters passed into the constructor. The cool feature is that the value of any one of the parameters can be 'injected' into CAB by marking the parameter as follows.

public DemoPresenter([ServiceDependency] WorkItem workItem,
[ComponentDependency("Target")] string injectedParameter)

In this declaration, the injectedParameter value is taken from the Target item in the work item and automatically passed into the constructor. Someplace earlier (and, in fact, even in another component), someone had to execute the code.

string valueOfInterest = "Hello";
WorkItem.Items.Add(valueOfInterest, "Target");

While this might seem a little convoluted, in the world of composite UI, this injection technique allows disparate components to easily share context.

So much for the background and on to the problem. I had created a presenter constructor that took a parameter of type NamedObject. As well, the ComponentDependency attribute specified that the "Target" item in the work item should be passed in. In the place where the object was added to the WorkItem.Items collection, I instantiated an object of type Profile, where the Profile class derives from the NamedObject class. I added the Profile object to my Items collection with a key of "Target". I expected that the dependency injection mechanism to retrieve the Target item and pass it into the presenter constructor. Instead, I received an "Unable to locate dependency 'NamedObject'" exception being raised.

After digging deep into the injection process, specifically into the ObjectBuilder methods within the CAB project. It turns out that the matching process used by dependency injection is not based solely onthe key passed into the Items.Add method. It is also includes the type of the item. In other words, the ObjectBuilder not only looks to find an item called "Target", it also ensures that the type of the item matches. And, to make it more annoying, the ObjectBuilder doesn't understand hierarchy. So even though my item was of type Profile, which is a NamedObject (due to the inheritance), the ObjectBuilder says that there was no match and threw an exception.

The solution to this problem (other than to modify how ObjectBuilder performs its matching...a daunting task to say the least) is to extract the item out of the work item directly. There are reasons for wanting to avoid this (there are actually more than one Items collection which can contain the injected value), but it worked in my situation. But I still have a gripe with the message. It's not truly misleading, as ObjectBuilder couldn't find a dependency of the indicated type. However, the message does require a deep understanding of how ObjectBuilder does its thing, and that is a strike against the message in my book.

More Ways to Avoid the Second System Effect

bruce — Wed, 06 Aug 2008 18:02:17 GMT

Dare Obasanjo had an interesting post yesterday on the Second System Effect in software development. For those who are unaware, the second system effect is a term first coined by Frederick Brooks in The Mythical Man Month. It deals with (in general) the idea that the second system designed/implemented by anyone is typically over-architected, with more bells and whistles added then need be.

Dare goes on to describe a number of common factors that keep systems from falling into this trap. Factors that my experience do contribute greatly to the success of a second version. I do have a couple of factors to add.

Only One Driver

There is a fundamental clash between marketing and developers when it comes to the priority of items added to a product. Marketing is looking for features that will help to drive sales. Developers are looking for features that will improve the architecture, stabilize the product, ease any future enhancements and simply be cool to implement. Frequently, these two groups will not agree 100% at the features which should be in the next release.

Successful projects have a single driver. That is, there is one person who is responsible for determine which features do and don't make the cut. They will listen to both sides of the argument and make a decision, with their ultimate responsibility being to drive the successful shipping of the release. It doesn't matter which discipline the person comes from, although it helps if the driver has the respect of both groups). The important element is to have someone who is making the decision and ensuring that the process doesn't become a continual stream of requests for new features.

Rewriting is not Right

The title should probably read "Rewriting is not Right unless you have extraordinary unit test coverage...and probably not even then", but that wasn't catchy enough.

After you come up for air at the end of a project, it is usual to have some sort of post mortem. Even the name indicates how developers look at this part of the software development process. It is not in our nature (generally speaking) to sit back and admire the good things that were accomplished. Instead, we concentrate on the warts of the system. How many times have you said, immediately after completing a task, that you wished you could rewrite it from scratch? Take solace that you're not alone in that feeling...it is quite common among your brethren.

The problem is that the feeling to rewrite needs to be resisted. There is, whether you realize it or not, more invested in the development of a particular feature than you might expect. There is more than the code that implements the feature set that is visible. There are also all of the bug fixes associated with the application. The one or two lines of code that were necessary to make the system load the poorly-formatted file that arrives monthly from your biggest client. The use of a semaphore to ensure that a timing problem was corrected. All of those little things that had to be done to take the first pass of code and make it ready for use in the real world.

When you're thinking about rewriting, your mind is focused on reworking the architecture. It is not thinking about the many hours of effort that went into identifying, replicating and correcting the bugs. We know that it's easier to write new code than to read old code, but we don't consider all of the the knowledge embedded in the old code. While throwing out old code is sometimes useful, we tend to fall back on that choice too quickly, believing that 'new' is faster than spending the time to understand the impact of enhancements and changes. If you have a set of unit tests that covers the vast majority of functionality, then you might be able to make a case. But if you don't, then rewriting part of your system should be the last choice, not the first one.

SQL CLR Configuration - A Head Slapping Moment

bruce — Tue, 05 Aug 2008 15:52:18 GMT

This post is basically a reminder to a future me. The client I'm working with right now (basically an ISV) is using SQL Express as part of their project. And included in their database are a number of CLR stored procedures. In other words, the stored procedures are written in C#. While a little unusual, this is not particularly extraordinary.

The problem arose as I deployed my application from the build server to a freshly installed machine by hand. Moving the binaries was simple (a file copy from a shared directory). Moving the database was nothing more than a backup and restore. But when I ran the application, things didn't work.

It turns out that I had forgotten an important point, that being that the database setting that enabled the CLR would be 'backedup and restored' along with the database. Given that CLR functionality is turned on using sp_configure (sp_configure 'clr Enabled' to be precise), there was no reason for me to make such an assumption. But I did and the result was a moderate debugging session spent trying to figure out why I was stupid...er...forgetful.

Anyway, the point is that not every setting that a database depends on is backed up with the database. Some are associated with SQL Server itself and are therefore not backed up at all. I knew that, but sometimes I forget. :)

A New Recruiting Drive

bruce — Tue, 29 Jul 2008 16:38:44 GMT

ObjectSharp has been growing quite steadily for the past little while. But winning a couple of recent contracts have begun to strain our seemingly unending supply of high-end talent. For this reason (and to get some fresh blood and ideas into the company), we are now actively searching for associates. If you're immediately available, we do have a project that could use your skill set (assuming that your skill set includes C#, Windows/Web Forms and SQL Server). But if you're just interested in learning what ObjectSharp has to offer, I'd be happy to answer any questions. Or you can contact (or forward a resume to) our fantastic Service Manager, Gisele Bourque.

In a few sentences, working with ObjectSharp is a great opportunity to work with some of the top minds in the .NET world using technologies and techniques that are at the forefront of software development. The people are great. The projects are usually quite interesting. And, on top of all of that, you get paid. :) If you'd like the chance to stretch your development wings, it's probably worth having a conversation with us, one way or the other.

ORA-01008 Not All Variables Bound error

bruce — Mon, 28 Jul 2008 12:46:00 GMT

I have recently had the opportunity to work (once again) with Oracle. Specifically, I had to create a mechanism that would, based on configurable settings, update either a SQL Server or an Oracle database. In and of itself, this is not particularly challenging. Not since ADO.NET implemented a provider model using the Db... classes that are part of System.Data. The provider name can be used to generate the appropriate concrete instance of the DbConnection class and away you go.

While testing out this capability, I ran into this error when the target data source was Oracle. One would think (and I certainly did) was that I had missed out assigning one of the in-line parameters. The text associated with the error certainly gave that impression. And I was, after all, building the SQL statement on the fly. A bug in my logic could have placed a parameter into the SQL and not created a corresponding DbParameter.

But that was not the case.

Instead, it was that the value of one of my parameters (a string, as it turned out) was null. Not String.Empty, but null. And when you assign a null value to the parameter, it's as if you didn't bind anything to the parameter, the result being that when executing the query, a nice ORA-01008 exception is thrown. The correct way to do the assignment is to set the parameter value to System.DbNull value instead. It would appear that the SQL Server data provider doesn't have this issue, in that the problem only appeared against an Oracle data source. Not a particularly vexing problem, but still it's something to be aware of.

And a couple of years had passed since my last Oracle post ;)

The Cost of Migrating from VB6

bruce — Sat, 26 Jul 2008 04:56:00 GMT

Recently, a question regarding the cost associated with migrating from VB6 to VB.NET was asked by one of our clients. Since that is a question whose answer has a broader appeal than just to the asker, I thought I would replicate my response here.

It should be stated up front, however, that I don't normally recommend a migration from VB6 to .NET. This isn't to say that there aren't ways to benefit from the move. It's just that a straight migration typically won't see any of those benefits. Re-architecting an application is generally the only way to get those improvements and a straight migration doesn't accomplish this. And if you already have a working VB6 application, there is little to be gained by creating a VB.NET application that does exactly the same thing.

Keep in mind that I said "little", not "nothing". While the benefits are greater for redesigning, there are still times where a migration is the right choice. Which is the reason why the question of cost does need to be addressed.

There are a number of factors that come into play when trying to determine the cost of just migrating a VB6 application to VB.NET. Let me provide an admittedly incomplete list.

Code Migration

Naturally, the first thing to consider is moving the code from VB6 to .NET. Where there are migration wizards that are available, both from Microsoft and third parties, it is important to realize that there is no way to simply 'wizard' a migration. While the syntax between VB6 and VB.NET are similar, there are many concepts that are different. And no wizard will take a VB6 application and create a VB.NET application that is designed in the most effective manner for .NET. So while you can get an application to be compilable quite quickly, it won't be taking advantage of many of the features of .NET that can improve developer productivity. This is one of the reasons that many companies consider re-writing VB6 applications instead of just migrating them.

That having been said, it is certainly faster to migrate an application than it is to rewrite. An average developer can produce 500-1000 lines of tested and deployable code in a month. However, that same developer can migrate 35,000 to 40,000 lines of code a month. So to calculate raw cost per line of a migration, figure out how much you pay an average developer in a month and divide by 35,000.

Developer Training

Of course, migrating the code is only part of the associated cost. Developers have to be retrained to use VB.NET. A typical VB6 developer will take about six months to regain the productivity level in VB.NET that they had in VB6. A junior developer might take 8 months, while a senior developer will take around 4 months.

Part of the process of getting people up to speed will be training. Depending on the technologies that are being used, anywhere from 10-20 days of in-class training will be needed. A typical breakdown of the topics covered would be 3-8 days of .NET Framework training, 3-5 days of ASP.NET development, 1-2 days of testing. 4-5 days of advanced programming concepts (WCF, Sharepoint, WPF, etc).

While this might seem like an expensive process, there are hidden costs and lost productivity associated with trying to get developers up to speed 'on the cheap'. There is too much in .NET for a single class to provide all of the necessary information in sufficient depth to be able to use it effectively. The problem is that some organizations (and some developers) will pretend that a 5 day course on .NET is good enough. The developer will end up spending the next 12 months looking up how to do the common tasks that weren't covered in the 5 days and will end up making design decisions that, had they the correct knowledge at the time, would not be made. Both company and developer can spend years trying to correct the bad choices made through inexperience.

Preparing the VB6 Application

There are a number of common issues that arise during the migration process, issues that can't be addressed by a wizard. These issues generate the large majority of problems that are found when migrating and include such items as

The default property is no longer used

The property/method is not found in VB.NET

The property/method is found, but has a slightly different behavior

COM functionality has changed

If these issues are addressed before the migration (that is, in the VB6 application), it can help speed up the migration process. Each of these issues actually results in a cascade of problems (on the order of 5 VB.NET problems for each instance of a VB6 problem) in the migrated application, so it is worthwhile to spend some time 'fixing' the VB6 application in order to get it ready for migration.

While there are other considerations involved (is the new application to be web-enabled? is there integration with other legacy applications?, etc.), these items are the largest sources of cost associated with migrating from VB6 to .NET.

Bring Your Data to Life with WPF Session

bruce — Fri, 07 Mar 2008 16:39:21 GMT

The premise behind this session is the idea of separation of UI designers and developers. The UI people don't know how to code business rules. But the UI people need to be able to 'try out' the user interface and easily make changes. This is the designer/developer separation that is in the Web space, only in this case, it's for Windows Forms applications.

For those of you who aren't aware, one of the drawbacks of WPF is the lack of data binding support. This is a significant step back in functionality, if you're used to creating ASP.NET or Windows Forms apps. And it stopped me from using WPF to any great extent.

The session starts out slow, talking about the rationale behind data binding. This is something that I would expect most developers to be aware of, although if he's including designers in his target audience, then I can understand the digression.

Databinding in a WPF form can be done through the latest version of Expression Blend. A new Data pane allows for the selection of a data source (a class, for example). Once the data source has been specified, the property sheet for a control allow the mapping between the control's property and the data source's property to be made. This is a familiar process, although very new to WPF and Expression Blend.

WPF includes the concept of a value converter. This is a function that operates on a bound value with the result from the conversion being displayed. As well, the data binding appears to be hooked up to the property change notification mechanism, in that if a property is programmatically changed, the updated value appears in the form.

There is also a mechanism (INotifyCollectionChanged) which raises an event when the collection is changed. The idea of 'change' in a collection is the addition or removal of an item from the collection. WPF data binding is able to detect and respond to these events.

WPF has replaced the ObjectDataSource class with an ObjectDataProvider. Without seeing the details, I'm guessing there is a lot of similarity in terms of functionality, if not the details.

In the WPF itself, the binding notation looks like the following

This notation takes the Name property of the Sun object found in the ObjectDataProvider named solarSystem. A little cumbersome, but since it's definable through Expression Blend, that's only an issue for those of you who code in Notepad 2008.

As part of the data binding mechanism, there is the concept of a data template. This greatly resembles a template within ASP.NET, where different fields and controls are displayed based on the mode of the control. One twist is that WPF data templating can be defined based on the type of object being displayed. Within the same list box, a collection of Products will appear with different fields then a collection of Customers, even though the underlying WPF is the same.

The final reveal for the demo is a list box that displayed the information about a solar system not as a list of planet names, but as a graphical representation of the solar system orbit with the images of the planets and the positioning away from the sun based on properties from the object. The cool part is that there is no change to the underlying object necessary to change from a drop down list of properties to the graphical view. Only the XAML needs to be modified. But again, that is the power of WPF.

One word of warning. Not all of the advances in WPF are necessarily available in Silverlight. A concept called a CollectionView was explicitly called out as not being part of Silverlight 2. So if you are developing for the Silverlight market, make sure that the data binding techniques you use are supported before you spend time on it.

WPF provides support for a hierarchical data template. This template because useful when you are trying to create a tree view visualization for your data. It's similar to the list box data template in concept, but the level within the hierarchy becomes part of the mechanism for distinguishing between the different data fields and styles that are used.

It looks to me like data binding for WPF has finally moved towards the standards that we have been used to. The presentation didn't cover error providers and error notification, but a slide at the end suggests that it is, using the IDataErrorInfo interface.

Steve Ballmer Keynote - 2

bruce — Thu, 06 Mar 2008 21:08:17 GMT

Continuing from the previous post

Guy commented on how Microsoft is different. Responsive, helpful and a change from what Microsoft's image has been historically.

Some questions from the audience

On Adobe

They are a big competitor in some areas. Specifically in the Silverlight and .NET vs Flex and Flash arena. There is no expectation that they are going to "go away". Will continue to work with Adobe where it makes sense.

On Internet Explorer not moving at the speed of .NET

Many innovations, including the browser, were tied to the "next O/S after XP". Microsoft .NET was not. It was because they took dependencies on the O/S. That will not happen in the future. Future IE will incubate the innovations outside of the O/S and move them into the O/S once they have been proved out

On the PHP applications that Yahoo has

There will be some refactoring of the search, ad and email technologies when Yahoo and Microsoft get together. Some technology will come from Microsoft. Some will come from Yahoo.

On the Synergies between Microsoft and Yahoo

Scale is an advantage in the search game. More search = more ads = higher bids on ads. The more ads you have, the larger the number of ads that can be inserted into the results of a search. Google has more ads that either Yahoo or Microsoft. The merger will help scale out in this market.

On the Virtualization Server Licensing Scheme

The question was regarding the licensing cost for virtualization to be able to compete with Amazon's computing in a cloud (ECC or EC2, I can't remember the acronym). The answer was that Microsoft has plans to provide a similar service.

On Silverlight on the iPhone

Microsoft would love to get Silverlight on every mobile platform they can. There is currently no free runtime license for apps on the iPhone. Apple apparently wants 30% of all of the revenue generated through the iPhone. So while it would be nice to have, the expectation is that developers are unlikely to bite. And it was suggested that perhaps Apple is not being embracing of external developers.

On Silverlight and Microsoft applications

The question is whether Silverlight will become part of Microsoft apps, such as Hotmail. As the product cycle for the relevant products is appropriate, Silverlight will become part of the deliverable. But only on those technologies where appropriate. MSN Messenger was called out specifically as not a likely choice.

On HD DVD vs Blu Ray

Microsoft doesn't make peripherals. They support the devices where the demand is and will continue to do so. In the long term, the format isn't that important, as content is more likely to be delivered over the network.

On Enterprise adoption of social networking

The ways in which people interact with each other within the corporation is changing. Sharepoint provides collaboration services, so there is already some knowledge about how people interact. The key is to leverage these areas to provide more 'social-like' capabilities. This area is early technology, so there will be advances in the future.

Steve Ballmer Keynote - 1

bruce — Thu, 06 Mar 2008 20:42:03 GMT

The keynote is actually an interview between Guy Kawasaki (as interviewer) and Steve (as interviewee). A number of interesting points.

Regarding competing with Google

Of the four areas in which Microsoft is focused, Google is really only present in one of them (on-line ads). But the on-line ad space is expected to be the next big thing.

On why he keeps working

This is the answer that everyone should give. He:

Loves what he does
Works with smart and energetic people
Enjoys the challenge

From personal experience, this should be what everyone strives for.

On the place of XBox in the Microsoft world

Steve put it into perspective. XBox has 25 million users world wide who are passionate about the products that Microsoft creates. But there are 1 billion Office users. It makes sense to focus efforts on driving passions appropriately

On Web and Windows forms technologies

Microsoft is trying to blur the boundaries between Web and Forms, in terms of capabilities. Apparently 1.5 million Silverlight downloads per day. WPF currently has a broader reach because of Windows Update

On Apple's MacBook Air

"My laptop is lighter", "It's missing half the features of my laptop", "Where's the DVD?", "We'll get rid of this (the Air that Guy has) and get you a real machine"

On Vista

The number one issue for Vista is application compatibility and driver compatibility. Made choices to create a secure O/S. The result is that compatibility is hurt. As drivers and applications are updated, the compatibility issues have decreased. With SP1, the uptake in the business market will increase.

On Microsoft's Skill Set

Microsoft is trying to focus on two skill sets: consumer devices and business platforms. Most companies only attempt to create one. Microsoft is lucky enough to be able to focus on two, with a third and fourth still a possibility

On Social Networking

People will continue to use the Internet to keep in touch, to find friends, to connect with people. It is unlikely that any one company/website/technology will be able to stay on top forever.

Real World AJAX with ASP.NET Session

bruce — Thu, 06 Mar 2008 16:26:00 GMT

I have to give credit to Nikhil Kothari. He just ran a session the way that I like to see sessions run. As I read the title and abstract for the session, I was expecting not much in the way of new information. I actually attended the session mostly because it was the only one in this time slot that might be of interest.

Nikhil started out with just some basic stuff on AJAX. But very quickly he got past that and the session became very interesting. The idea is that if you plan on using AJAX in a "real" application, there are a number of issues that need to be address. Simple issues to identify, but complex to deal with. For example:

History

Say you have a page that makes a number of AJAX calls, updating the screen each time. Then you click on the back button. The typical action is to go to the page prior to the initial view of the current page. But what you generally what to do is go to the results from the previous AJAX call.

The solution is to use an AJAX UpdateHistory control. More details can be found on Nikhil's weblog here. It requires some work by the developer to determine when the browser history needs to be updated, but if you put the effort in, your users will love you. OK, not really. This is one of those features that users will ignore if it's there, because your site is working as they think it should. But if you don't have it, they will hate you. It's almost the same thing.

Indexability

If you have a page that uses AJAX to retrieve and display information, you have a problem with making that page appear in the appropriate place within Google. After all, Google depends on static data for its indexing.

The pattern that Nikhil is suggesting is to create a static page that contains all of the data. Make the data static on page. Put the data into a hidden div. Then create a separate frame and use script to pull the data from the hidden div into the frame. When viewed normally, the data will appear in the frame. When crawled by a spider, the script is not executed, so the data is just available for indexing. This pattern might not work in all situations, but there are enough to make it worthwhile being aware of. Again, a blog post (here) provides some additional details.

Overall, a nice presentation with some useful takeaways.

Silverlight 2 - Fundamentals

bruce — Wed, 05 Mar 2008 23:06:00 GMT

I'm sitting through the first part of the Building RIA using Silverlight 2 session. The starting point is some of the new, but quite fundamental elements of Silverlight 2

First off, the schedule of releases at the moment are:

Beta 1 = today, with a non-commercial go-live license

Beta 2 = Q208, including a commercial go-live license

Silverlight 2 now includes a TextBox (only about a year too late).

Silverlight works in a sandbox. It has access to local storage through isolated storage. But basically consider Silverlight applications to have the same level of local storage as your current web browser.

Silverlight supports cross-domain requests, but the target domain needs to be configured (via a policy file) to accept requests from Silverlight.

Silverlight has a number of classes available to allow a number of easy mechanisms to make a request to the current or a different domain. And those requests can be made both synchronously and asynchronously.

A large number of intrinsic controls are now available. And the controls are very skinable.

There is support to one- or two-way data binding. The binding mechanism seems to be quite similar to ASP.NET, although the syntax is a little different.

Scott Guthrie Keynote - 3

bruce — Wed, 05 Mar 2008 18:04:00 GMT

Silverlight 2 beta includes

Multi-language support - VB, C#, Iron Ruby, Iron Python
WPF UI, including data binding
Networking stack - REST, SOAP, WS-*, sockets. And cross-domain stuff is supported
Integrated Data Support - LINQ, and the ability to cache data across browser sessions
High performance
Small download, fast install - 4.3 MB download, no .NET Framework download required, working with Novell on a Linux implementation

Includes a lot of built-in controls

Sliders
Calendars
DatePicker
DataGrid

Built-in controls are shipped with source included in the beta. Open license allows for modification and resale.

The built-in controls are now completely skinable, including custom animations.

Also including unit testing capability for Silverlight controls. Around 1200 unit tests included for the built-in controls.

They are also shipping preview versions of Silverlight tools for VS2008 and Expression.

Scott Guthrie Keynote - 2 - Silverlight and the Olympics

bruce — Wed, 05 Mar 2008 17:55:00 GMT

Silverlight is a major part of the Olympics 2008 Site

2200 hours of live streaming coverage over 22 days. This, plus the 1100 hours of content on the 5 NBC broadcast networds, will be made available as Video On Demand.

Also, through Silverlight, you will be able to see live streamed coverage of all 34 sports. As part of the live coverage, you can

rewind and rewatch the stream
view pop-up alerts of other activities in other sports.
share link to the live coverage with others.
include picture in picture (PiP) of multiple sports
view multiple live streams of the same sports, even PiP

Very cool, especially if you're a fan of non-traditional sports. But I wonder if such a service will be available outside of the US.

Scott Guthrie Keynote - 1

bruce — Wed, 05 Mar 2008 17:40:00 GMT

Silverlight 2 Beta 1 is available for download after the keynote

Changes include enhancements for media. Sorry, but this section includes terms that don't mean that much to me. High Def? I thought he was a rapper. ;) But let me make some notes

Adaptive Streaming - The Silverlight client can adaptively determine the bandwidth between the client and the server and set the bit-rate appropriately. And can change on-the-fly, if necessary

Total Cost of Ownership - Windows Media Services 2008 is free. Provides 3x the scalability of other services, yet maintains a high level of reliability. Also, there is support for progressive downloading, including bit-rate throttling. Progressive downloading means that the initial 10s or so of content is bursted out, but beyond that it just maintains the 10s buffer instead of trying to get as much content as you can to the client as quickly as you can.

Business Opportunities - Integration of advertising into the Silverlight experience. Jon Harris demos a Silverlight Advertising Template. Template is a Visual Studio 2008 project template and the wizard used to create it. The result is a project that includes a fair bit of commonly used Silverlight functionality

Dean Hachamovitch Keynote - 1

bruce — Wed, 05 Mar 2008 17:19:00 GMT

Dean is responsible for IE 8. And he is talking about 8 points (because developers can count higher than 3). If you've given presentations, you'll understand that reference.

1. CSS 2.1

There are issues with CSS support in IE7. IE8 addresses these by focusing on full support for CSS 2.1 standard.

2. CSS Certification

Getting certified is the best way to ensure that all browsers will render standard CSS correctly. Microsoft has provided a large number of test cases to include in the certification process. The problem will be backwards compatibility. There are instances where pages look gook in IE7, but don't look good in Firefox. Because IE8 is more CSS compliant, it also looks bad in IE8. There is, however, an IE7 compatibility more (under control of the page developer) to force IE8 to work like IE7

3. Performance

They have improved JS script performance by a factor of approx 2.5 times. Not always as good as Firefox/Mozilla, but a great improvement over IE7. And they are still working on it.

4. HTML 5 Support

The back button doesn't work well with AJAX functionality. Sometimes 'Back' doesn't get you what you expect. Support for HTML 5 means (among other things) an interaction that is more like what the use expects

Also, HTML 5 support includes network awareness. A connection gets lost and the page responds, including the ability to modify the content of the page.

5. Developer Tools

IE8 includes built-in developer tools. Includes a script debugging window, complete with breakpoints, watches, an immediate window, etc.

Also includes the CSS debugging info similar to what is found in Visual Studio 2008. When you select a particular element in the document, you can see the styles which are applied to the element. This allows 'wrong' style values to be quickly identified with regards to their source.

6. Activities

Activities are context-sensitive bits on a web page. Select text and quickly get to a map of the address it represents. Or find the selected item on Ebay. "Quickly' invokes a right click or selecting from an Activities menu that is similar in location to the Exception Helper in Visual Studio.The context for the selection is provided through an architecture known as OpenService format. It is called the OpenService Specification and Microsoft has made it available for comment.

7. WebSlices

The Web Slice is a part of a web page that contains basically a summary (a slice) of another web page. Provides quick, pop-up summary of a separate web page. A summary of a Facebook friend can be retrieved through either a context-sensitive click or a toolbar click. And the current page is not left.

The is a WebSlices spec that contains the details.

8. IE 8 Beta 1 is now available. Or at least, after the keynote.

Ray Ozzie Keynote - 2

bruce — Wed, 05 Mar 2008 16:53:00 GMT

The idea behind the concept of connected devices is to create software to provide a personal device mesh using the Internet as a hub. By having a central personal data store, complete with synchronization, the devices will become much more a part of 'you'. A current research team has been working on this starting with the PCs.

A second scenario is connected entertainment devices. The vision includes having DRM be transferable between your own devices. Purchase music and be able to listen to it on your computer, your Zune and your XBox without requiring additional licenses.

Office Live Workspace, opened up to a broad public beta as of yesterday, has a major role in the connectivity picture. You will be able to tag Office documents and make them available to people who are interested in what you have to offer.

You will be able to run Exchange, Sharepoint and Office Communications Server in either the typical, on-premise server or as a hosted service (called Exchange Services, Sharepoint Services, and, well, you get the idea).

He also touched on SQL Server Data Services as a developer database in the cloud. I'll have to check that out.

And now, on to Scott Guthrie.

Ray Ozzie's Keynote - 1

bruce — Wed, 05 Mar 2008 16:41:00 GMT

If you want to know why Microsoft made the play for Yahoo, look no further than one of the three main focuses that Ray Ozzie sees for the near future. He expects on-line ad revenues to double to $80B annually over the next two years. And to not make such a play is to basically concede the bulk of the market to Google (my opinion, not his)

The second prong in Microsoft's strategy is based on the idea that the Internet has become a hub of a large number of devices. The list goes from PC to gaming systems to cell phones to cars. The idea of the Web is to bring together a collection of personal devices. And one of the guiding principles of Microsoft's software offerings is to provide a mechanism to facilitate this future.

The business side of the "Internet is a hub" is being brought out in virtualization. Current software will be "refactored" to support virtualization in many different ways.

"Small pieces loosely joined" (a Weinberg quote, I believe) is the new motto.

More to come...

Looking for Clues

bruce — Wed, 05 Mar 2008 14:06:00 GMT

So one of the question about MIX is whether there will be a 'surprise' announcement. Last year, it was the Windows Live Streamer that allowed people to store video in the cloud and have it served to your site.

I don't think the availability of Silverlight 2 qualifies. There are many sessions that have a Silverlight 2 label and in the hands-on lab section, I was told that the Silverlight 2 labs that are in the list won't be available until after the keynote. So not much of a surprise there.

However, there is a block of hands-on lab computers that were not active yesterday. And there is a rumour of a session titled "X talking about Y" that will be dropped into one of the open session blocks. Both of these suggest that some announcement in the tool realm will be dropped sometime in the next couple of hours. Stay tuned.

Off to MIX

bruce — Tue, 04 Mar 2008 21:46:11 GMT

First off, let me comment on the dearth of posts for the last few months. As always, it has to do with my workload. I have been working heads down on a major project for client for about six months. On top of that, my evenings are spent co-authoring the Training Kit for the WCF exam. The result is that I don't have a lot of time left for extra-curricular writing, which is what this blog is. I expect both of those to change shortly, so there should be more posts in the coming months.

The client project is actually one of the slickest that I've worked on. It uses a ton of cutting edge technologies, including WCF, the component application block (CAB) and even WPF. It's that last piece that's the most interesting because it's the first time that I've seen WPF used in a line of business application in the wild. My colleague, Rob Burke, is the author of this coolness. He demoed it at our At the Movies presentation and has blogged about it here. Take a look if you get the chance. It's well worth seeing.

But all of this is beside the point of this post. At the moment, I'm on a place heading to Las Vegas for the MIX '08 conference. I'm expecting a ton of blogging activity this trip, so get ready for a flurry of posts over the next week as I try to keep up with what's happening.

Can't Save Test Results?

bruce — Tue, 02 Oct 2007 12:52:04 GMT

For some bizarre and unknown reason, I started getting the message "Can't save results of the run since ResultFilePath is null" when I was trying to run a test through the VSTS Test Manager. A quick Google search revealed the suggestion that a ResultFilePath element be added to the PropertyGroup tag in your solution file. That didn't have any affect for me.

It turned out that my testrunconfig file went missing. It can be added to the solution by right-clicking on the solution in Solution Explorer and adding a new item. Still, when I added the testrunconfig file back into the solution, the problem still existed. What it took was to close and reopen the solution along with adding the testrunconfig. Now life is good once again and testing can continue.

Anchor and AutoSize Properties (on GroupBox, at least)

bruce — Fri, 24 Aug 2007 21:31:14 GMT

I had a weird problem earlier today involving the width of a GroupBox. I had dropped a GroupBox onto a panel. The panel was configured to automatically expand and contract as the size of the form is modified (using the Anchor property). I set the Anchor property on the GroupBox expecting it to be displayed in the same manner. But that was not to be

After a fair bit of fiddling around, I stumbled upon the problem. AutoSize. I had set AutoSize to true because I was dynamically adding controls that were to be displayed in the GroupBox. That setting, combined with the AutoSizeMode set to Grow and Shrink, let the control grow as I added more items.

What I didn't count on was that AutoSize also (appears) to control the horizontal size as well as the vertical. As a result, in order to get GroupBox to expand along with the size of the form, I had to turn AutoSize off and manually size the GroupBox as more items were added.

I am, however, open to other suggestion, should someone have one to offer.

GetType on a Dynamically Loaded Assembly

bruce — Fri, 24 Aug 2007 04:58:42 GMT

The application on which I'm working has the opportunity to dynamically load and assembly. Later in the application, one of the types from the loaded assembly need be retrieved using GetType. More specifically, the GetType was performed using a fully qualified type name (including the name of the assembly). But the GetType failed. Naturally, this begged the question of why GetType didn't find the type in the dynamically loaded assembly.

Ultimately, it comes down to how GetType operations. If you provide a string of the form "A,C" (for assembly,class), then GetType operates as if it were performing Assembly.Load(A).GetType(C).

Notice the Load method that is in there. If A exists in the default probing path, then there is not problem. But A doesn't include a fully qualified path. And if the assembly was originally loaded from a location other then the executable's directory, GetType will fail.

There are a couple of solutions to the problem.

1 - Put the assembly in the GAC. Then Load will find the assembly and GetType will work

2 - Add a codebase element to the config file. This element can be used to control the probing path, but you cannot probe outside of the executable's directories and subdirectories. The codebase element (which has to be created for each DLL) allows you to specify the full path to the assembly.

An Old Problem is New Again

bruce — Wed, 22 Aug 2007 14:34:17 GMT

I ran into a problem yesterday that brought back memories. And not the good kind of memories either.

I'm doing some work using TypeConverters. In particular, I'm creating a Windows Forms control that functions in a manner similar to a PropertyGrid, but with a user interface that looks more like a typical Windows form. You know, with labels, and text boxes. Because this is a generic control (that is, the fields which get displayed depends on the object associated with the control), I'm doing a lot of reflection to retrieve the properties that are required. And I'm using reflection (the GetValue/SetValue) to interact with the object. This last part (the SetValue method in particular) means that I'm using type converters to move the string values that are in the text boxes into the actual properties themselves.

Now type converters are quite useful. They expose a ConvertFromString method that (not surprisingly) takes a string value and converts it to a value of the associated type. If the string is not valid for the destination type, an exception is thrown.

Problem 1: the raised exception is System.Exception. I have no idea why the exception surfaced from ConvertFromString is an Exception. The InnerException is a FormatException, which is the type of exception that I would have expected. But no, ConvertFromString throws Exception. This forces me to use a pattern that I loathe - try {...} catch (Exception) { }

Whenever I teach, I always harp on this. You should (almost) never catch the general Exception object. You should only catch specific Exceptions. But because of ConvertFromString, I have to add to my list of cases where catch (Exception) is required.

But why should this matter, you ask. TypeConverters exposes an IsValid method. You should be able to check for the validity of the string value prior to calling ConvertFromString. This would completely eliminate the need to catch any exceptions at all. And it's the best practice/recommended/ideal way to go.

Problem 2: Int32Converter.IsValid("bad") returns true.

Think about that last one for a second.

According to the type converter for Int32, the string 'bad' is a valid integer value. In my world, not so much. If you spelunk the various classes in .NET Framework, you find out that IsValid is supposed to be overridden in the various converter classes. But the numeric classes don't bother to do so. As a result, the IsValid that actually services my request just returns a true regardless of whether the string is valid or not.

What's worse, this is a known bug that will never be resolved. Apparently to make IsValid work for Int32Converter is considered a breaking change.

So my suggestion (courtesy of Dave Lloyd) is to add a new method to the TypeConverters. Call it IsReallyValid. IsReallyValid could then be implemented properly without the breaking change. It could take the CultureInfo object necessary to truly determine whether a string is valid. For the base type converter, it could simply return a true.

Heck, let's go a step further and mark IsValid as being Obsolete. That would force people to move to IsReallyValid and correct any problems in their applications. And maybe, in a couple of versions, Microsoft could reintroduce a working version of IsValid and mark IsReallyValid as being obsolete. In this way, four versions from now (that's about 10 developer years), IsValid will work the way it's supposed to (and everyone would expect it to).

Looking for Mr (or Ms) GoodDeveloper

bruce — Mon, 16 Jul 2007 22:01:40 GMT

Business has been booming of late at ObjectSharp. Don't know whether it's the weather or the business cycle, but our recent company barbeque had more new faces that I've seen in many years. And we haven't lost any of the old faces either.

And yet it doesn't seem to end. At the moment, we're looking to add some consultants to our team. Specifically, we have the need for someone with Windows Forms experience, either in creating commercial-grade user interfaces on their own or with the CAB application block.

If you (or someone you know) has that experience and is looking to join a fun team of top-notch developers, drop me your (or your friend's) resume. You'll get a chance to work on projects that use cutting edge technology. You'll learn about (and sometimes use) technologies that aren't yet available. And, if you have the interest, we have six MVPs on staff to help you get your own designation.

If you don't fit into this skill set, fret not. There will be others coming along in the very near future. Just keep your eye tuned to this blog.

Relieving File in Use Problems

bruce — Mon, 18 Jun 2007 04:54:44 GMT

It's quite possible this is old news to people, but it took me more than a couple of minutes to find the solution. I was using the FromFile method on the Image class to create a new Image object. When I was done with the Image, I needed to move the file. But it turns out that the file was still 'being used by another process'.

The solution is simple, but it didn't come immediately to mind because I'm so used to basically ignoring the scope of variables. The trick is to call Dispose immediately rather than waiting for garbage collection to do its thing. Once Dispose has been invoked, you can manipulate the underlying image file as you need to.

Connection Strings and TableAdapters Revisited

bruce — Wed, 06 Jun 2007 00:25:37 GMT

In a previous post, I had ranted about an issue that I had regarding connection strings and TableAdapters. Since that time, I have dug deeper into the problem and identified what my problem was. And I have a suggestion to help keep it from happening.

First off, it's important to understand how the particular project was structured. It was a Web application and like all good ASP.NET developers, I had segregated various pieces of functionality into different tiers. Specifically, I have an assembly which contains the data access code. It is in this tier that the TableAdapters were being used.

When you use the designer to create the TableAdapter, you have the option to put the connection string into the configuration file. The person who created this assembly (it wasn't me) did exactly that. Which resulted in an app.config file being created in my data access assembly's project.

So now it comes time for me to use the data access assembly. While I have web.config file, complete with (what I thought) was the correct connection string, the name I gave to the string did not match what the TableAdapter had created automatically. This is the beginning of the problems. As I go through the testing, all appears to be working exactly as expected. But now I come to deploy the application.

After deployment, I get the application 'pausing' for about 30-45 seconds followed by an 'unable to connect to the database' message. I check the web.config and see the (still badly named) connection string has been modified appropriately. So I can't figure out why the application can't connect to the server. And I eventually find out the name of the connection string is incorrect. This is where the rant came in.

But the question that I was too relieved to ask at the time was "which server could the application not connect to". After I had cooled down, I started looking. And it turns out that it was trying to connect to my development database. Since I had changed the connection string through the configuration file, I couldn't figure out why the application would even know about the development database. Until I found it. My development connection string was embedded in the TableAdapter code. It was set up as the default value, so that if the connection string couldn't be found by name, it would just use the original string.

Now I have a couple of problems with this approach. First off, it kept me from noticing that I didn't have the correct connection string name being defined. I'll take some of the blame for this. But worse, it means that the connection string to my development database is hard-coded as a string in my assembly. And since I don't treat development database connection strings with the same security reverence as a production connection string, it also means that a valid user id and password were also hard coded in my assembly. And by 'hard coded', I mean that anyone with my assembly and a decompiler would have an easy time finding out a set of valid credentials.

So, ultimately, I'd like to request that Microsoft disable this automatic 'caching' of connection strings. Or at least give me the option to be able to turn it off myself. Because without this, I'm sure there are a number of assemblies that contain secrets people don't expect to be there.

Certification 2.0?

bruce — Tue, 05 Jun 2007 20:46:14 GMT

For reasons which I'm contractually obligated not to disclose (meaning I could tell you, but I'd have to wound you...it's not that important :)), I have an abiding interest in the certification process at Microsoft. Prior to the release of these new certifications, I was not a huge fan. Not just of Microsoft, you understand, but any certification that I had been exposed to. The biggest problem (as I saw it) was a combination of meaningless questions (who wants to remember whether it's Save or Write...I can just Google...er...MSN Search for it) and the watering down of the value of the certification through sites that include 'dumps' of questions and answers from people who have taken the exam. When I saw a 9-year old as the youngest MCSD, I figured the overall value was not that high.

The latest round has made an attempt to solve the problem of meaningless questions. However, it is still possible to get dumps of the questions and answers, so the watering down process still exists.

But the value of certifications is not dead. A friend of mine, Howard Dierking, is in a position to improve the process to make them more valuable on a number of fronts. Check out this post to get a sense of the ideas that he is working on. More importantly, let him know if they make sense or if you can suggest any improvements. I think these ideas are a good step towards making certifications relevant. And since I now hold a couple of them, I have a vested interest. ;)

It was only a matter of time...

bruce — Tue, 15 May 2007 11:14:12 GMT

until someone developers a Flash to Silverlight conversion utility. And the first one that I've see is called Harmony from Electric Rain. The product is not yet in beta, but the promise is to convert SWF files into XAML for either WPF or Silverlight. It also appears to be taking a more holistic approach to the conversion by trying to identify the graphical elements involved in order to create a 'better' XAML file. The only downside that I can see is that ActionScripts are not converted.

That's one more piece to the acceptance rate puzzle.

Code-Name Jasper

bruce — Wed, 02 May 2007 16:56:56 GMT

Named after a venerable Canadian national park (due to the overwhelming influence of Canadians on the Microsoft Data team, who are taking over the U.S. one developer at a time), Jasper is one of the incubation projects from the System.Data team introduced at MIX '07.

Built on top of the Entity Framework, Jasper provides a set of classes that can easily be used to perform CRUD operations on data. While this doesn't sound particularly exciting when phrased like that, the reality is that the classes are generated under the covers at run time.

So if I had a database that contained a Customers table, then Jasper allows me to create a DynamicContext object that has the connection string to the database. Then I can say "DynamicContext.Customers" and a Query object containing the customers in the database will be returned. Each customer object within this query has a set of properties that match to the columns in the table. The magic here is that database schema is being queried at runtime to determine which classes should be included in the application. And once retrieved, the query can easily be used to bind to elements on an ASP.NET Web page.

There are a number of interesting aspects as the talk gets closer to a real-world scenario. For example, it seems to be taking the Ruby approach of 'by convention' rather than 'by declaration'. If the Customers table had a property called address, you can create a class named Customers and add a GetAddress method. When the data classes are generated at runtime, a call to the GetAddress method will be used in the property getter for Address. This is how override certain functionality can be achieved.

All in all, there are some interesting possibilities that could arise from this. If you want to play with what is there right now, check out http://msdn2.microsoft.com/en-us/data/bb419139.aspx

WPF Found a Home!

bruce — Tue, 01 May 2007 22:48:31 GMT

The more I see about Silverlight, both 1.0 and 1.1, the more I realize that WPF has found a client to service. From the moment I heard about XAML and WPF, I questioned where it was going to fit in the real world. A large part of the 'coolness' of XAML revolved about transitions and transformations. But business applications don't really need that. Business applications are, generally speaking, not flashy, demo-candy-ful systems. So this disconnect between the needs of business and the strengths of XAML left me wondering.

While I don't believe that WPF is going to replace Windows Forms anytime in the near future, I think that it's pretty obvious that the raison d'etre of XAML is to support Silverlight.

But it's important for developers to realize that XAML/WPF/Silverlight is sill new technology. The one thing I haven't seen here at MIX is an integrated development environment. Orcas doesn't have a XAML designer...it has a link to edit the XAML in Expression Blend. The data binding story in XAML is a step back from what ASP.NET developers gained in .NET 2.0. Jasper and Astoria are interesting technologies, but the security and error management stories are still being developed. In other words, temper the excitement of some very, very slick technology with the realization that we still have a little time before it becomes 'real'

Drilling Down on the Silverlight Hype

bruce — Tue, 01 May 2007 14:54:07 GMT

First off, I do think that Silverlight is a very cool piece of technology. Want to see just how astounding? Check out the Top Banana demo application that was part of yesterday's MIX keynote. You can also find it here.

What I found most astounding is that Top Banana is a browser-based application with cross-browser support.

Silverlight is also touting that it allows .NET to run on the various browsers. Which it will do at version 1.1. Keep that in mind. The Silverlight that was released as a beta version yesterday (albeit with a "Go Live" license) does not have .NET support. Programming against the object model is done using JavaScript. The version that contains .NET support was released as an alpha version without the Go Live license. In other words, the cross-platform .NET support is only available as a preview.

Not that it won't be cool when it becomes 'real', but keep that in mind when you're looking at the various demos. Remember to ask which version was used to put the demo together.

Expression Web

bruce — Mon, 30 Apr 2007 21:41:03 GMT

I just sat through a session on Expression Web. They were showing some of the functionality that was currently being used, along with some of the plans for the next version. There are a couple of points that I'd like to make clear that came out of the session.

Expression Web fills the same space as Visual Studio. They are targeted to different audiences, naturally (Expression Web is aiming at designer-type people), but they are both development environments. They even work on the same project structure, although Expression Web is incapable of modifying the code behind files.
Expression Web does not currently have any support for Team Foundation Server. My first thought was 'ewwww'. But (and this is a killer but) you can only modify the Web pieces of the application. No code behind can be touched. While I'm not thrilled with not having integration, I'm more willing to relax it for the Web content.
They are currently thinking about whether to include TFS support in xWeb (the cutesy name for Expression Web) in the next version. If you want to influence their decision, send them a message through http://connect.microsoft.com.

I'm looking forward to playing with the elements of Expression Web to see what kind of trouble I can get into. :) If you want the same opportunity, you can download a trial version from http://www.microsoft.com/expression.

Computer Canada Feature Article on Employees as Assets

bruce — Mon, 30 Apr 2007 21:18:46 GMT

The April 20th edition of Computer Canada had a feature article on (generally) the asset value that employees bring to a company. I mention this because, as it turns out, I'm quoted in the article. I believe that documentation is not the solution to the knowledge leakage problem discussed in the article. Developers don't like documentation, so the trick is to keep code clean and easy to read. Standards are important. Unit tests are important (they document the assumptions made by the developer). Enforcing both standards and appropriate levels of unit testing would, quite naturally, be even more important.

This combination is a significant benefit (albeit a soft one) that a company can accrue by using tools such as Team Foundation Server. Imposing process on software development efforts can be challenging, however. The metaphor that a development team is like a herd of cats is frequently quite accurate. Getting them to buy into the process is very important to it's success. But a well planned implementation that takes into consideration appropriate levels of training along with a process that mirrors the current situation can greatly help a company achieve it's goal with respect to securing application knowledge.

Identifying Formatting Errors with Expression Web

bruce — Mon, 30 Apr 2007 19:44:34 GMT

One of the more interesting aspects of Expression Web is its ability to help debug CSS errors. I'm in a talk on Designing with Expression Web and the story is about how to use Expression Web to identify problems in a web page. The web page is loaded and the problematic element is selected. One of the windows is a rules summary pane that includes all of the formatting rules that apply to the selected item, in the order in which they occur.

So the process of identifying the problem is finding the particular rule that actually causes the unexpected formatting. And having tried to suss this out on my own in the past, I can greatly appreciate the benefits of having such a tool available.

Dynamic Language Runtime announced

bruce — Mon, 30 Apr 2007 16:44:53 GMT

As I mentioned previously, Microsoft has announced a Dynamic Language Runtime (DLR), the idea being to enable dynamic languages (e.g. Python, Ruby, etc.) in .NET. Although the site hasn't opened yet, I suspect that you'll be able to download the DLR from the Silverlight community site at http://www.silverlight.net. And CodePlex already has some samples at http://www.codeplex.com/dynamicsilverlight

There is an eWeek interview with former colleague John Lam and Jim Hugunin about the DLR here.

Getting your hands on Expression Studio

bruce — Mon, 30 Apr 2007 16:28:48 GMT

If you're an MSDN subscriber, you might be wondering what parts you can get hold of without purchase the product. Expression Studio is made up of: Expression Web, Expression Blend, Expression Design and Expression Media. From a developer's perspective, it is really Expression Web and Expression Blend that are of greatest interest. You might be able to make the case for including Design in this list, but personally (since I was born without the graphics gene), I wouldn't

Microsoft has thankfully included the two pieces (Web and Blend) into the MSDN Premium subscription. Expression Web can already be downloaded. Expression Blend will be available in the very near future. See Soma's announcement (from earlier this month) here.

What's the Big Announcement?

bruce — Mon, 30 Apr 2007 16:06:00 GMT

For weeks now, there has been a buzz about a big announcement at the Mix '07 conference. Well, in his keynote, Ray Ozzie made the following announcements:

Expression Studio is shipping today - See here for the details. One of the interesting elements of Expression Studio is that it includes the standard edition of Visual Studio 2005. As I mentioned in my last post, I haven't seen the developer experience for Silverlight. Hopefully with this will be at least similar to what developers already expect.

Silverlight Streaming - A companion service to Silverlight. The idea is to allow Silverlight applications to be posted to a set of Microsoft servers in the cloud. From this cloud, the applications can then be delivered to client browsers through your web site. First I've heard of this, so if I misunderstood this 'third part' of the Microsoft strategy, I'll correct it later.

Scott Guthrie announce that Silverlight includes a cross-platform .NET Framework. As of 20 minutes ago, there was a preview for this functionality that was available on the web. While it is a Beta version, it does have a "Go Live" license.

Silverlight can be downloaded from here. The SDK can be found here.

More to come

Technorati tags: Mix 07, Silverlight, ASP.NET 2.0

Into the Mix

bruce — Mon, 30 Apr 2007 05:11:43 GMT

So I arrived at earlier today and dove pretty much staight into the gestalt of Mix. Registration was a breeze. And there were plenty of open seats at the two-monitor hands-on labs. So I dove into Expression and Silverlight. The technology looks interesting, although the labs didn't have any development experience. Yet. Word on the street is that may change later this week (hint, hint).

Also, I heard confirmation of a rumour that had been making the rounds. Specifically, that the Entity Framework will not make it into Orcas, but instead will be released by the middle of 2008. This is a disappointment to me for a number of reasons. You can read more about the announcement here.

Calgary Code Camp

bruce — Sun, 29 Apr 2007 12:40:47 GMT

So my yesterday was spent having a good time at the Calgary Code Camp. For those of you who want my slide decks, you can find them below. For anyone else, suffice it to say that the camp was smoothly run, contained lost of great content and appeared to be thoroughly enjoyed by all. I was especially impressed by the content in the Agile track. Based on what I saw, I would guess that it is more firmly intrenched among the Calgary influencers than in Toronto.

As well, I had the change to talk to some old acquaintances and meet a whole bunch of new faces. But more, I learned that Sam is in trouble and doesn't even know it and that I expect D'Arcy to be publishing some YouTube content on the pros and cons of chicken wings. :)

Now for the slides decks/code.

Language Integrated Query Slide Deck

Extending the ObjectDataSource Slide Deck

Extending the ObjectDataSource Demo Code

If you're looking for the LINQ sample application, you can find it here.

A Big Strike Against TableAdapters

bruce — Thu, 26 Apr 2007 12:32:49 GMT

I'm hoping that someone reads this post and corrects me. But I'm not holding out much hope.

I don't normally use TableAdapters, but for a small application I decided that they seem like a reasonable choice. And so long as I was using them on my development platform, all was well and good. The problem arose when I delivered the application.

Like any good developer, I store the connection string to the data store in the configuration file. Which is what I did for this application. When I defined the TableAdapters, I pointed the connection string property to the same setting. Or so I thought. But what actually happened was that the connection string was actually stored in the DLL that contained the adapters. Hard-coded. As in not modifiable through the config files. And, naturally, this wasn't discovered until deployment.

So I started to look for ways to have the TableAdapter pull the connection string from the config files. I figured that this would be a fairly common scenario, so it should be address. Not so much

Apparently there is no way to automatically have TableAdapters use config settings. The "solution" is to use the fact that TableAdapters are partial classes to create a write-only ConnectionString property. It looks like the following:

public partial class FormTableAdapter
{
   public string ConnectionString
      {
         set
         {
            System.Data.SqlClient.SqlConnection conn = new
               System.Data.SqlClient.SqlConnection();
            conn.ConnectionString = value;
            this.Connection = conn;
         }
      }
   }
}

Then, where the adapter is instantiated in your code, you set the ConnectionString property to the value from the config file.

To me, this is unacceptable. I was already a little skeptical of TableAdapters (I don't like the DataSet and the data access code in the same assembly), but this takes the cake. It almost seems like they were designed to not allow a reasonable deployment model. Maybe it will get better in the next version, but until then, I'm sticking with DataAdapters.

A Peek into the Future Of Dynamic Languages

bruce — Tue, 24 Apr 2007 16:50:27 GMT

Technorati tags: Mix 07, dynamic languages, clr

There has been a lot of nothing coming out of Microsoft over the last couple of months. I mostly noticed it at the MVP Summit in March, where the level of NDA content (for C# people anyway was non-existent) and I got a lot of 'you should come to Mix' tossed in.

So I am going to Mix '07, and for a taste of the sort of announcement that should be commonplace, check out this post from Mary Jo Foley about a "Dynamic Language Runtime" for .NET. It even includes a quote from an old colleague of mine, John Lam, who knows a thing or two (or a thousand) about dynamic languages and Microsoft.

And I'm pretty certain this won't be the only groundbreaking announcement that comes out.

Taking it on the Road

bruce — Sun, 22 Apr 2007 20:13:46 GMT

This coming Saturday (April 28th), I'm going to be doing my Extending the ObjectDataSource talk at the Calgary Code Camp. While this isn't the first time I've spoken in Calgary (I did an MSDN User Group Tour there a couple of years ago), it has certainly been a while. I'm looking forward to participating as well as connecting with some people I haven't seen in a while. If you are in the area, you should seriously think about attending. Code Camps are a lot of fun and the price (free) enhances the value even more. You can find out more about the sessions and register at http://www.calgarycodecamp.com

Extending the ObjectDataSource - VB Version

bruce — Sun, 22 Apr 2007 19:59:22 GMT

This past Tuesday, I did my Extending the ObjectDataSource talk for the Toronto Visual Basic User Group. Although you can find the slides here, the demo code is in C#. To make it fair for all, here is the VB.NET code for the same demo.

Extending the ObjectData Source Demo Code - VB

Joining the Patent Parade

bruce — Fri, 13 Apr 2007 01:14:05 GMT

In another life, I did some development work on a application that involved extracting data from a faxed image. It was difficult work and the results were surprisingly good, considering the challenges (faxed images are notorious for being of poor quality, being skewed, etc.). As it turned out the work that we did was patentable and, as of May 1, the U.S. patent (#7212301) will be approved.

This is one of those process patents that I've always been surprised that actually qualified. But there was a very experienced attorney saying that it was and, lo and behold, four years later there it is. Please excuse me for a moment of personal pride.

Abstract:

One or more parameters such as time is reported to a center using a form. The center then automatically extracts data from the form and converts it for storage and subsequent processing or review. The form is preferably a physical form, which the sender fills in and then faxes to the center. Image capture, registration, and feature recognition routines are included to enable the center to extract the reported data with no need for data reentry or human intervention. The invention is particularly suitable for employees who need to submit time sheets, expense reports, and the like to an employer, or for automatic analysis of submitted inventory reports, product orders, etc.

Distributing SOA Information

bruce — Thu, 12 Apr 2007 19:25:27 GMT

As you might have guessed from the name of my blog, I have a long-term love of distributed applications. My infatuation with the technology actually goes back to earlier forms of COM+ and Web services. I believe that a well designed distributed application can be used to address the scalability, reliability and even identity issues that spring up in most large scale business applications. The biggest problem with designing distributed application is knowing which of the many available technologies is the best choice for the situation.

This is the reason that I was looking forward to the release of the Windows Communication Foundation (WCF). If nothing else, WCF provided a common interface to the multiple technologies used to build distributed applications. Well, WCF has been released for a few months now (and was actually in a 'go live' state for a lot longer), which means that interest in how it can be used in real-life is growing. To help people learn and use this very cool technology, ObjectSharp is introducing a new course on the best practices surrounding WCF. The course is being developed by Peter Madziak, with more information about the content and thinking behind the course found here. If you have any interest in distributed applications in general and WCF at all, you owe it to yourself to check out the course description.

Roadmap for VSTS

bruce — Mon, 09 Apr 2007 15:20:32 GMT

Microsoft has just released (here) a moderately detailed description of where Team Systems is going over the next 12 months or so. The roadmap also includes the beginnings of the functionality that will be found in the next version of VSTS (code named Rosario). Nothing like a little transparency to get people salivating. :)

Distributed Applications Training Kit now available

bruce — Sat, 07 Apr 2007 02:03:07 GMT

Although the publication date was slipped slightly (and there was conflicting information coming from some of the vendors), the training kit for the Distributed Applications PRO certification (70-549) is now available. Of the three training kits I was involved in, this is the one where I thought the material would be most useful beyond studying to pass the certification test. The concepts and issues associated with distributed applications are commonplace and the book provides a nice consolidation of the latest thoughts on how to address the problems. I am curious about how people find the book, so if you have any feedback, I would love to hear it.

Toronto Code Camp Slide and Demo

bruce — Mon, 02 Apr 2007 12:10:17 GMT

The second annual Toronto Code Camp took place this past Saturday. By all accounts, it was a tremendous success with over 250 people giving their Saturday over to many things technical. I gave a presentation on extending the ObjectDataSource control, and while you should be able to get the slides and demo code from the Toronto Code Camp site shortly, I thought I'd post them here as well, just to get it out as quickly as possible.

Slide Deck - Extending the ObjectDataSource

Demo Code - Extending the ObjectDataSource Demo Code

TFS and Baby Steps

bruce — Thu, 29 Mar 2007 17:56:00 GMT

I just finished attending ObjectSharp's SMART (Software MAnagement Round Table) session on the impact of quality assurance on the development process and had a couple of observations to share.

First off, the biggest takeaway from the session is the need to move quality to the front of the development process. In this way, quality is a lot like security. There is no way to create a really secure application by adding security features at the end of the development cycle. In the same way, there is no magic powder that can be sprinkled on a completed application to greatly improve its quality. The overall quality of an application is found in its architectural choices, whether it was designed to be testable and the approach taken by the development staff with regards to testing.

However, one of the conversations I had with an attendee regarding Visual Studio Team Systems was just as interesting. He had just installed Team Foundation Server and had created a team project using the default Agile template. The team project he created was going to be for a working application. I found this approach interesting, not the least because (by his own admission) there was no "process" for developing software currently in play.

The interesting aspect (for me) was the supposed lack of software development process in his company. I would strongly suggest that there really was a process in place. Even though you might not think a process is in place with your development team, doesn't mean that a process doesn't exist. In any kind of team development environment, processes will form. It's just a question of how formal the process is. So your 'lack of process' (call it an unprocess) is really just a lack of documentation and formalization. Because of its lack of formality, unprocesses frequently operate below the radar of even the people involved.

If you haven't worked with Team Systems before, let me preface my comments by saying that it absolutely introduces structure to the development process. If you plan on using it 'out of the box' with no customization, you will need to use the process described by one of the canned templates. For those who don't currently have a process, the Agile template is the most likely starting point. But the Agile template includes process. There is a workflow for tasks. There is a workflow for defects. And workflow equals process.

I can appreciate the idea behind starting out with the canned templates. Its presence would indicate that it's a process with proven success. And using the product as it arrives is a first, small 'baby step' into the world of development process. The problem is that the first step you're taking isn't a small one. Instead, you have taken a giant step into the world of Agile development. Complete with all of the process that is codified in the Agile template. And Agile has more process than most people think. The result is that the first 'baby' step can be a killer for Team Systems.

If someone new to a development process truly wants to take baby steps with TFS, they should start by thinking about the unprocess which is currently being used in their organization. Spend a day or even a few hours talking to someone who is familiar with development methodologies, to identify the flows that are currently at play. The default template should be customized to follow this unprocess. Then, over time, the structure originally defined by the Agile template can be added back in, if needed.

Does this require a little more effort on your part? Yes. But the steps involved in modifying the template are both well documented and fairly easy to follow. By taking this approach, you truly can learn Team Systems by taking baby steps. And this is a lot less painful than trying to make the leap from unprocess to Agile.

Accessing Content Page properties in Master Pages

bruce — Tue, 20 Mar 2007 17:36:10 GMT

I'm teaching our ASP.NET 2.0 Best Practices course this week. I only get to teach about 1 week a quarter, so I greatly enjoy whenever I do. One of the interesting things about teaching, even content that you know very well, is that there are always questions and topics that I haven't run into in the past. Today was no exception.

I was covering Master Pages and Theming when I was asked about accessing information on the content page as part of the master page's processing. As it turns out, there were two solutions.

1. The Page property on the ContentPlaceHolder control has a reference to the Page class formed by the content page. In other words

this.ContentPlaceHolder1.Page

give you access to the Page object for the content. So you can cast that object onto the specific page class and access any public properties normally.

2. Use another ContentPlaceHolder control. In the specific request, the goal was to include a link to an optionally present, page-specific CSS file. This link (ideally) would be in the header. The solution was to put a ContentPlaceHolder into the HEAD section. Now the content page was completely capable of filling in the content with a CSS link, if one was available.

I was surprised by this second answer, as I didn't think that the ContentPlaceHolder would "work" other than in the body. No reason why I thought this. But one of the students suggested it and, lo and behold, it worked just fine.

As most instructors will tell you, the number of things you learn while teaching a class is quite astounding.

WebParts and the need for a Database

bruce — Thu, 08 Mar 2007 13:20:14 GMT

I'm doing some work creating WebPart components in ASP.NET 2.0 and discovered a dependency that I wasn't initially expecting...the need for a database.

It appears that in order to even place a WebPart onto a form, you need to have a database. Or at least a persistent data store. A little bit of investigation found this information available in a number of places. The WebPart isn't actually the problem, so much as the WebPartManager. The manager is responsible for keeping track of the various WebPartZones and which WebPart is in which Zone. To persist this information across iterations of the page, the location information is stored in a database. So, even when the page is displayed the first time, a database connection needs to be available.

While you can create your own provider, the easiest mechanism is to use the aspnetdb, which is also used by the Membership and Role providers. To add the database to an existing SQL Server instance (either SQL Server 2000 or 2005), use the aspnet_regsql command, which is found in c:\Windows\Microsoft.NET\Framework\v2.0.50215. Once the database is available, a connection string (call it AspNetDbConnectionString to match the upcoming example) should be defined in the web.config file, along with a webParts element that includes a personalization tag, similar to the following:

Captain SOA to the Rescue

bruce — Wed, 28 Feb 2007 14:31:25 GMT

From Howard Dierking (former real person, now Microsoft drone :)), here is a detailed breakdown of the many ways that SOA can help your business, your professional career and even your life. Yeah. That's it. SOA is "Life Transforming"

http://soafacts.com/

Windows Training Kits now available

bruce — Sun, 18 Feb 2007 15:35:24 GMT

I just found out that twp of the training kit books for the Professional versions of the latest Microsoft Certification tests are not available. Specifically, the books for Web Applications and Windows Applications. Why am I mentioning this seemingly meaningless piece of news? Because I'm one of the co-authors. In other words, the books (along with a third that is coming out in the next few weeks) represent a large portion of the last six months of my business life. So rush right out and buy a copy. Or 10 :)

Microsoft Vista Launch in Toronto

bruce — Mon, 29 Jan 2007 20:18:08 GMT

One of the benefits of being an MVP is that occasionally you get to do really cool things. And, in this particular case, I'm using the traditional meaning of cool rather than the geeky.

This event is going on all week, but I get to spend Groundhog's Day in an ice house helping introduce Visa and Office to the community. I'm looking forward to the opportunity, although I do need to go out and get some long underwear before Friday. I've been told that the temperature inside the house is a few degrees below zero. Could be all the ice in the vicinity. ;)

Decrypting Stored Procedures

bruce — Wed, 24 Jan 2007 06:10:51 GMT

As part of work that I was doing recently, I had to generate the creation script for a SQL Server database. While running through the Generate Script task in Management Studio, I received an error that indicated that the stored procedure was encrypted. Never having running into encrypted stored procedures before, I was a little surprised. It turns out that encrypted stored procedures can’t be scripted. Could be that they’re encrypted. Duh!

Anyway, the documentation says that, for encrypted stored procedures, it is important to generate the creation script prior to encryption. So I started asking the client if they had the creation scripts. It turns out that a previous DBA had invoked the annoying ‘job security’ clause when creating the stored procedures, so the creation scripts were nowhere to be found.

Some additional research on the problem and I find a third party component that can decrypt the stored procedures. It’s called SQL Decrypter and it’s from Orbital Technologies (http://www.orbitaltechnologies.org/decryptor/). I have to say, it’s a nice tool. Does exactly what it’s supposed to do, quickly, easily and painlessly. So the client gets the generation scription and Orbital gets another (I’m sure) satisfied customer.

DataFormatString doesn't seem to work on BoundField elements

bruce — Sat, 06 Jan 2007 03:02:10 GMT

I was using the BoundField element in ASP.NET 2.0’s GridView control. More specifically, I was attempting to use the DataFormatString element in order to change the look of dates and dollar amounts as they get displayed. Much to my dismay, it didn’t look like the format string was being applied to the data.

After digging around a bit (and making sure that my memory of the format codes was accurate), it turns out that the problem is caused by a combination of factors. The first is that the default value for the HtmlEncode is true. The HtmlEncode property determines whether the value of the bound field is HTML encoded before being transmitted to the browser. The second factor is that, when the DataFormatString is applied to the value, any HTML encoding takes place prior to the formatting.

When, for example, a date is rendered, the date value is converted to string using the ToString() method. The string is then HtmlEncoded. Finally, the String.Format method is used to format the string using your format codes. However, your date format codes won’t work because the ‘date’ is no longer a DateTime variable. It’s a string. So instead of formatting the data, it is displayed using the ToString() layout. The same problem exists for other non-string types, including currency, floats, etc.

The solution is to set the HtmlEncode attribute to false on the BoundField element. Now the value is not converted to a string prior to the Sting.Format method call, the result being that the String.Format method uses the typed value (not the ToString version) and the format string in the manner that you (and I) expect.

Register for the Toronto Code Camp

bruce — Wed, 03 Jan 2007 21:58:30 GMT

The registration page has been available since the middle of December (at http://www.torontocodecamp.net), but my heads-down end of year mode kept me from mentioning it until now.

If you’re not familiar with the Code Camp concept, it is a free day-long conference on all things geeky. Geeky to developers, that is. Code Camps are run on a Saturday to give people who might not normally be able to attend a conference the opportunity. The Toronto Code Camp has its focus on Microsoft technologies (although not exclusively) and includes content on current and future technologies, both at the introductory and advanced level.

For those of you who don’t get enough technology during the course of a normal week, the Code Camp is a wonderful opportunity to get the latest and greatest in information from some wonderful speakers. Also, if you have wanted to speak to a group of enthusiastic users, the Code Camp provides a nice, safe, informal environment to get started.

So if you haven’t registered already, get to the Toronto Code Camp site and sign up now. You’ll get much more than your money’s worth. :)

Tagging isn't just for walls anymore

bruce — Wed, 03 Jan 2007 06:04:52 GMT

You may or may not be aware of the current craze sweeping the (cringe) blogosphere. When you get tagged, you are supposed to reveal five things about yourself that the typical reader is unlikely to know. Since I was honoured by Rob Windsor with a tag, I feel compelled to continue the chain.

1. My first job in the computer industry was also my first job ever. I was fifteen and I spent the summer writing computer games for the Oxford County Board of Education. On a Commodore Pet. The coolest part of this is that a number of the games that I designed were eventually converted into LOGO and were still being used by the province of Ontario more than 10 years later.

2. I was a poor writer when I was in high school and university. Not that I’m a great writer now. Only that it comes much more easily than it used to. The key for me was a suggestion to write the way that I speak. Don’t worry about the grammar or coherence. That can be added in the editing process. Just get words down and work from there.

3. I grew up in Canada and never learned how to skate. Not until this past December, when I laced up skates for the first time in over 35 years. Now I play in two hockey leagues. Not well, but not killing myself is my only bar to success in the sport.

4. I love playing volleyball. I played the sport on and off for years, but took it up with a vengeance once I moved back to the Toronto area. My height (or lack thereof) means that I set when I’m playing court volleyball. But I also play beach volleyball in the summer, where I mostly play doubles.

5. When I lived in Los Angeles, I tried out for a number of game shows. This includes a couple that never made it to air, as well as the venerable Jeopardy. I actually appeared on one show, QuickSilver. It was on the USA Network for a couple of seasons. I won the grand prize for the show that I was on, said grand prize being a week at a Dude ranch in Colorado. And I still have the tape to prove this.

Now to pass the baton on to others. I’ll start with one of my partners, Dave Lloyd. Next is Dave Totzke. The someone who probably doesn’t know that I read his blog: Eli Robillard. Finally I go way up the food chain to two blogs that I read to help me get better with my writing and presentation skills, And I know that they have no idea that I read their posts religiously: Kathy Sierra and Garr Reynolds.

A Nice New Year's Gift

bruce — Tue, 02 Jan 2007 05:10:13 GMT

So when I popped into my In-Box this morning, I received a nice gift from Microsoft: news that I have been re-upped as an MVP.

For those of you who have never heard of the MVP program, you can visit http://www.microsoft.com/mvp. But it’s basically an award to for those who are active in the community. You don’t have to be a pure evangelist of Microsoft technologies. In fact, being honest and up front about the good and the bad is considered as part of the package. But you do have to offer help and advice to those who need it. There are many forms that community involvement can take, including writing blogs (such as this one), answering questions on forums, writing books/articles for magazines, and speaking at user groups. I’m lucky enough to enjoy participating in all of these activities, as well as working in an environment that encourages it.

So thanks Microsoft for the honour and I look forward the technology developments in the next year.

How to start the year

bruce — Mon, 01 Jan 2007 15:19:23 GMT

Happy New Year all.

How better to start the year with a couple of personality tests.

My results:
You are Superman

Superman		55%
Spider-Man		55%
The Flash		55%
Green Lantern		55%
Iron Man		50%
Supergirl		40%
Wonder Woman		35%
Robin		35%
Hulk		35%
Batman		15%
Catwoman		10%

You are mild-mannered, good,
strong and you love to help others.

Click here to take the "Which Superhero am I?" quiz...

Or:
You are Lex Luthor

Lex Luthor		84%
Dr. Doom		81%
Apocalypse		68%
Mr. Freeze		64%
Juggernaut		60%
Magneto		59%
Kingpin		59%
The Joker		51%
Green Goblin		48%
Poison Ivy		44%
Dark Phoenix		42%
Riddler		40%
Venom		39%
Catwoman		34%
Mystique		32%
Two-Face		20%

A brilliant businessman on a quest for world domination and the self-proclaimed greatest criminal mind of our time!

Click here to take the "Which Super Villain am I?" quiz...

Precocious Children

bruce — Thu, 28 Dec 2006 14:48:00 GMT

I usually don’t talk about my ‘real’ life on this blog as I try to keep it more technically slanted. I probably should create a category about the trials and tribulations of raising young children, as I’m a relative expert in this process. As of this moment, I have four who range in age from 10 down to 4. I say ‘as of this moment’ not because I expect more (we’ve taken steps) but because the oldest is almost 11.

Of the four, the one that is most ‘interesting’ is number two. He has just turned 9, reads two grades above his age level and finds most of what he’s taking in class boring. This, as you might guess, is a recipe for trouble. Not bad trouble, but he’s the kid who we get regular communications from his teacher about behavioral issues.

On the up side, he will occasionally do things that give us hours of laughter. Such as the following, which is from an email that appeared in his in-box a short time ago. And yes, I do read his email. He’s 9 and I feel a responsibility to keep track of what his up to.

From: "Job Search Agents" <jagent@route.monster.com>
Reply-To: "Monster Job Search Agent" <jagent-feedback@monster.com>
To: <hisemailaddress>
Subject: Monster Jobsearch Agent - 22/12/2006
Date: Fri, 22 Dec 2006 02:30:43 -0500

Great news! We have found new jobs matching your job search agent criteria!

Here are the results that were found on December 22, 2006:

Your job search agent titled "magician" matched new jobs based on your search criteria. Listed below are the top 3 match(es)... (Just click on the job title to view a job.)

Dec 21, Seasonal Warehouse Magic!, Ellusionist.com, US-CA-Sausalito
Dec 21, Assistant to Operations Director, Ellusionist.com, US-CA-Sausalito
Dec 21, Marketing Manager UK, Aladdin Knowledge Systems (Deutschland) GmbH, UK-London-Windsor

First off, notice how he has gone to Monster.com to create a job search for himself. He’s in to an ‘I need to earn money’ phase, so this definitely fits. He even started a blog that I’ve mentioned previously (http://camsreviews.blogspot.com) as a way to make money. Second, check out the type of job he’s looking for – magician. He’s an amateur magician with an emphasis on ‘amateur. Finally, notice that indeed Monster went to great lengths to find a match.

Believe me that the finding of this email gave us much in the way of holiday cheer.

Why the Silence

bruce — Sun, 24 Dec 2006 03:11:00 GMT

Those of you who actually read my blog on a regular basis might have wondered what had happened to me. While I’ve never been a ‘post-a-day’ kind of writer, it’s rare to have two months go by without a post of any substance. Well, I do have a reason for my absence.

I have spent the past months working on three separate writing projects, specifically the training kits for the Web, Windows and Enterprise Pro exams that are part of the MCPD certification. The names are too long to include, but they are MCPD Self-Paced Training Kits for exams 70-547 (Web), 70-548 (Windows), and 70-549 (Enterprise). None of these books are available yet (Amazon has them being released on Feb 28th), but I put the final stamp of approval on my part a short time ago.

This isn’t the first book I’ve been involved in. The other one was called The ASP 3.0 Code Maintenance Handbook from Wrox. The Friday before it was release, Wrox went bankrupt, so you can imagine that it didn’t sell incredibly well. In one of life’s little ironies, all three of these unreleased books are already selling better than my first ever did. And I can’t imagine that I’m a bad enough writer to drive Microsoft press out of business.

Anyway, once the holiday season has passed, I fully expect to be increasing my blog post output. So look for topics of interest for people who are working with ASP.NET 2.0, as well as anything else that might catch my interest.

SOA Article in IT Business

bruce — Sat, 23 Dec 2006 03:52:00 GMT

I love it when it happens like this. A few months ago (roughly August, I believe) I was interviewed by Gail Balfour about some of my thoughts and experiences on Service Oriented Architecture. She put my comments (along with a few others) into an article. For various reasons, the schedule for including that article kept getting pushed back from Sept to Oct and then Nov. Finally, (at 4:43 on the Friday before Xmas :) it has been released. You can find it at http://www.itbusiness.ca/it/client/en/ComputerCanada/News.asp?id=41590

Since it's the first time I've been quoted in a publication of this size, I'm a little proud. Forgive my self-indulgence. And, since I haven't said it yet, I hope that all of you enjoy the fun and excitement of the holiday season.

NHL on Google Video

bruce — Thu, 02 Nov 2006 20:56:00 GMT

What do you do when you’re the fourth most popular major sport in a three-sport country? Or when your television ratings are lower than arena football? You go viral. Apparently the NHL has made an agreement to put full-length videos of hockey games up on Google Video. Way cool.

Check the link out here: http://video.google.com/nhl.html

An inside view of the GooTube saga

bruce — Tue, 31 Oct 2006 00:50:00 GMT

I’ve been following the Google/YouTube deal relatively closely, if only because of the copyright implications. The following post on Mark Cuban’s blog contains an interesting and apparently insider’s view of the mechanations behind the purchase.

Renaming Windows Workflows

bruce — Mon, 30 Oct 2006 16:01:00 GMT

I’m spending some time at the moment working with Windows Workflow. Specifically, getting the WF engine to drive a state machine for a Web application that uses a Web service as the ‘next state’ determinator. And it’s as much fun as it sounds.

I did run into one unexpected problem while working with WF. I had created a workflow and added a number of activities to it. After working with it for a while (including adding some values to the activities), I decided to change the name of the Workflow from Workflow1 to something a little more meaning full. When I made this change, it appeared as if the renaming functionality was doing what it was supposed to do, but upon recompilation, it turns out that it was just teasing.

All of the values for the activities are in the form of “Activity=Workflow1, Path=AuthenticateResponse”. Although the workflow was changed to ‘PLCWorkflow, none of the property values were modified. Probably because internally they are stored as strings, but it does mean that you really need to name your workflow before you start any significant work on it. Just something to keep in mind.

TFS Email Notifications

bruce — Fri, 27 Oct 2006 13:47:00 GMT

Consider this post to be little more that a future reminder for me. If you’re looking for a mechanism to send an email message when a work item is assigned to a developer, check out the solution offered here. Thanks to Andre for finding the link.

Looking for Kid Book Reviews?

bruce — Thu, 26 Oct 2006 12:12:00 GMT

I don’t normally verge away from the technical when it comes to this blog, but I promised my son this post. A little over two weeks ago, he started a blog. Specifically, he starting writing book reviews for the many books that he reads. So if you have a boy in the range of 6–10 years old , check out http://camsreviews.blogspot.com. The one thing I will say is that, if you’re trying to get your child starting to read, these are the books to go for. The content, at least in some situation, may not seem perfect (some of the books are scary and the Captain Underpants series has what most would consider to be bathroom humor). But the content is also the reason why they keep reading. Something about gross humor seems to work like that. And ultimately, that’s really what’s important.

If you like what you see, leave him a comment. He’ll be thrilled to know that someone is reading his reviews.

Math Humour

bruce — Wed, 18 Oct 2006 14:50:00 GMT

I found this news clipping in a blog post that has since gone broken. If some knows where it originally comes from, please let me know.

NEW YORK - A public school teacher was arrested today at John
F. Kennedy International Airport as he attempted to board a flight
while in possession of a ruler, a protractor, a set square, a
slide rule, and a calculator.

At a morning press conference, Attorney General John Ashcroft
said he believes the man is a member of the notorious Al-gebra
movement. He did not identify the man, who has been charged by the
FBI with carrying weapons of math instruction.

“Al-gebra is a problem for us,” Ashcroft said. “They desire
solutions by means and extremes, and sometimes go off on tangents
in a search of absolute value. They use secret code names like ‘x’
and ‘y’ and refer to themselves as ‘unknowns,’ but we have determined
they belong to a common denominator of the axis of medieval with
coordinates in every country. As the Greek philanderer Isosceles
used to say, ‘There are 3 sides to every triangle.’

‘When asked to comment on the arrest, President Bush said, “If
God had wanted us to have better Weapons of Math Instruction, He
would have given us more fingers and toes.” White House
aides told reporters they could not recall a more intelligent or profound
statement by the president.

Adding a New Item Template to Visual Studio

bruce — Tue, 19 Sep 2006 19:56:00 GMT

Problem number two I ran into was how to include my newly minted item template into Visual Studio. There are two steps that need to be followed to accomplish this.

First, the appropriate ZIP file needs to be placed into the directory located (for me) at C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\ItemTemplates\CSharp\1033\ItemTemplates. The ZIP file contains the .mht file that I had created, along with a .vstemplate file. The biggest problem I had with this seemingly simple process was how I created the ZIP file. I had a directory called ObjectSharpManualTest that contained the necessary files. I right-click on the directory and sent the directory to the Compressed File option. A nice zip file gets created and all is good with the world.

Except that it’s not in the correct format.

If you look at the ZIP file, the top level contains a Directory called ObjectSharpManualTest. The .mht and .vstemplate files are in that directory. But when Visual Studio loads the item templates, it only looks at the top level of the ZIP file. And, seeing no .vstemplate file, it moves on without loading. The solution is to select the .mht and .vstemplate files directly (i.e. not the directory in which they are loaded) before creating the compressed file. This results in a ZIP of the correct layout.

Once the ZIP file has been created, the following command (when executed from the Visual Studio 2005 Command Prompt) loads the item template into Visual Studio.

devenv /InstallVsTemplates

This command takes a few minutes to run, but when you’re finished the item template is ready to be used.

Finding the Export Template menu item in Visual Studio

bruce — Tue, 19 Sep 2006 19:18:00 GMT

I’m in the process of doing some customization to support a new Team Systems project template and I needed to create a new manual test template. It seemed like it should be pretty simple, but I ran into a couple of issues that are blogworthy. I’ll focus on the one described in the title, but there are other posts coming.

The instructions that I read on how to create an item template were to create the code needed for the template in Visual Studio and then use the File | Export Template menu option. Like I said, sounds easy. Until you discover that there is no Export Template menu option.

The solution is to add the menu option to the File menu. To do this, from within Visual Studio start with Tools | Customize. On the Commands tab, there is a Rearrange Commands button. Click it and the Rearrange Commands dialog appears. Make sure the Menu Bar radio button is selected and the drop down immediately to the right is “File”. Then drag the Export Templates command (you’ll find it under the File category) from the Customize dialog to the list box area in Rearrange Commands. Close these two dialog boxes and you now have an Export Template menu option exactly where everyone seemed to think it already was.

Changing the Web Service Port for TFS

bruce — Thu, 14 Sep 2006 14:34:00 GMT

One of the challenges associated with installing Team Foundation Server in the real world is the hard-coding of some of the ports. Not hard-coding, per se, but the inability to easily modify the assigned ports during the installation process. For example, at the company where I just performed the installation, port 8080 was already being used by some RAID monitoring software. So while the installation process was doing its system check, it balked because port 8080 was already being used. Is there any way to change this during the installation dialog? No. It might be possible to change the msiproperty.ini file, but according to an MSDN Forum post, there are known issues with doing so. So we killed the RAID monitoring process and performed the install on 8080.

But now I was faced with the need to change the port after the fact. Because, after all, it was much more difficult to change the RAID monitoring software. And should brand new software be able to cope? As it turns out, it can. There are only two steps needed to change the port on a running system. At least two that I’ve seen so far and I’ve been able to connect to TFS, create projects and modify security. If there are other gotchas, I don’t know what they are. The steps are:

1. Change the port that is being listened to by IIS. This is done through the Internet Information Systems Manager. If you right-click on the Team Foundation Server web site and select Properties, the port number is on the Web Site tab. When finished with this change, make sure that you restart IIS.

2. In the installation directory for TFS, there is a Web Services directory. In that directory, there is a web.config file. The web.config file has an element named TFSNameUrl. This is the URL, complete with port number, for the web service. Change the port number to reflect the change that you made to IIS.

These two changes were all that I’ve seen in the way of requirements, but if someone runs into trouble, let me know and I’ll take a look.

SQL indexing and parameters

bruce — Thu, 20 Jul 2006 14:16:00 GMT

I’ve spent some time over the last couple of weeks pondering an unusual SQL tuning problem. The situation is as follows:

The following statements are executed against a SQL 2000 database that contains >1M records in the act_item table. They are run using Query Analyzer and the Duration and Reads come from SQL Profiler

exec sp_executesql N'update act_item set Priority = @Priority where activity_code = @activity_code', N'@activity_code nvarchar(40),@Priority int', @activity_code = N'46DF335F-68F7-493F-B55E-5F9BC6CEBC69', @Priority = 0

Reads: ~22000
Duration: 250-350 ms

DECLARE @Priority int
DECLARE @Activity_Code char(36)

SET @Priority = 0
SET @Activity_Code = '46DF335F-68F7-493F-B55E-5F9BC6CEBC69'
update act_item set Priority = @Priority where activity_code = @activity_code

Reads: ~160
Duration: 0 ms

As you can see, the first and second block should do the same thing and you might expect it to take the same amount of time. But it obviously doesn’t. And just so that we’re clear, the activity_code field is indexed in the table. So I would have expected the first update statement to run quickly too.

The reason for the discrepancy is not readily apparent in the information I just provided, although a clue is there. The reason for the difference revolves around the data type for the activity code. In the table definition, it is a char(36). But when the a parameter of type nvarchar(40) is used, rather than converting the nvarchar(40) to a char(36), it converts the char(36) to an nvarchar(40). Which means that instead of using the index to retrieve the row to update, it performs a table scan. Which on a 1 million plus row table is a significant operation.

If you’d like to read about another persons journey down this road, check out http://www.sqlservercentral.com/columnists/dpeterson/bewareofsearchargumentsargdatatypes.asp (thanks to Doug Smyth for this post). This post also refers to a document in SQL Books On-Line that describes the conversion precedence of the various data types. While memorizing the list probably isn’t important, it is important to be aware of this list when defining the parameter types for the values passed through ADO.NET. I’m sure many of you are diligent about this, but for those who aren’t, you need to be keep in mind that not matching the parameter in the database might cause you some performance issues.

Another MVP for ObjectSharp

bruce — Tue, 04 Jul 2006 13:36:00 GMT

I found out yesterday that Matt Meleski has been awarded a well deserved Microsoft MVP award in the BizTalk arena. Matt has been working with the community for years spreading the good word about BizTalk, as well as providing a vast array of examples of how to make BizTalk dance on his blog. If you have any interest in learning about BizTalk or have particularly gnarly problems, Matt is definitely one of the people to talk to.

Congratulations Matt.

The Name Game, Part Deux

bruce — Thu, 22 Jun 2006 01:41:00 GMT

So long DLinq. Hasta la vista XLinq. You now have new names. And while they are more descriptive, they just don’t have the same ‘cool’ factor for me. Especial since I would have expected ELinq, SLinq and OLinq to have been added. Oh well.

http://blogs.msdn.com/somasegar/archive/2006/06/21/641795.aspx

The Ramifications of .NET 3.0

bruce — Wed, 14 Jun 2006 20:22:00 GMT

If you weren’t listening closely, you might have missed the announcement that the WinFX technologies have been renamed to .NET 3.0. One of the questions I have been fielding frequently here at TechEd is ‘what does .NET 3.0 mean to .NET 2.0 applications’.

The answer is ‘nothing’.

.NET 3.0 is an additive upgrade for the Framework. That is to say that the actual installation process for .NET 3.0 involves first checking to see if .NET 2.0 is installed. If not, then .NET 2.0 is installed. Only after .NET 2.0 is available do the four pillars of WinFX (Windows Communication Foundation, Windows Presentation Foundation, CardSpace and Windows Workflow). get installed.

If you’re looking for more information about this, check out http://www.netfx3.com. But in the short term, take away the fact that the introduction of .NET 3.0 means nothing when it comes to developing .NET 2.0 applications.

TechEd 2006 - Best Practices for ASP.NET Security session

bruce — Tue, 13 Jun 2006 15:13:00 GMT

So if you put best practices in the title for a session, whether it be at TechEd, PDC or whatever, then I think it should be mandatory to actually discuss what the best practices are. Yes, I know that best practices is a dumb name for what is really prescriptive guidance, but it’s not my title.

As I sit here in a session that is titled ‘Best Practices for Building Secure Web Applications using ASP.NET and IIS 6.0’, I’m being told about authentication modes, impersonation and identity. Interesting stuff, sure. But not best practices. I don’t need to learn this stuff, as I’m already more familiar that I care to think about the various authentication modes and the user identities that are available at different times. I want to know about the challenges, limitations and (okay, I’ll say it) best practices regarding authentication and authorization.

Next up was a brief discussion of the Membership API. Again, stuff that I learned about last year. And nothing that talks to when and why I’d want to use this.

The final section was a description of ASP.NET trust levels and the impact that the levels have on web applications. Telling me stuff like, changing from Full trust to High trust can gain some benefits. But as the speaker goes into some of the details, again, I’m not getting enough information. For example, he says ‘may need to move code into the GAC’. I want to know why, but it’s not coming. The speaker talks about application pools and that each pool can be given it's own identity. But no mention of when this might be useful. Or what problems I might run into if I try to communicate between web sites in different pools.

I feel for the presenter. This is not content that lends itself very well to code demos. Which means that there are more Powerpoint slides than is optimal. And the demos deal with configuration of IIS and ASP.NET, because that’s where the changes are. Sigh

An answer to a CardSpace (aka InfoCard) question

bruce — Tue, 13 Jun 2006 12:49:00 GMT

At the beginning of June, I worked at the realDevelopment ‘06 tour stop in Toronto as one of the MVP experts. Half of the day is devoted to Web security and a great deal of attention is paid to CardSpace. If you’re not familiar with CardSpace, try remember way back to when it was called InfoCard. If that still doesn’t click, think of it as a mechanism for maintaining all of the credentials that you use when you log into various web sites. Unlike Passport, it’s not necessarily the same email/user id for every site. Each site can be provided with a distinct set of information about you.

But that’s not the question that was left sitting there. At the question and answer session after the talk, a number of people were asking about exporting CardSpace cards so that they can be imported onto, say, their machine at work. It’s quite simple, as it turns out. But, the conversation goes, if it’s easy to export the cards, what’s to stop someone from walking up to your unattended machine and exporting your cards.

First off, the possibility that you leave your machine, complete with all of the credentials to access your bank account, unattended is the beginning of the problem. But fortunately, CardSpace is willing to deal with this.

One of the fun parts of TechEd is that you get meet people who know things. That’s what happened last night. I ended up talking with Rich Turner, the Product Manager for CardSpace. Who better to ask this question? As it turns out, it was the perfect person to ask.

The trick is to use a PIN to protect the cards before they get exported. By doing so, you can ensure that, even if they are exported, they cannot be used unless the PIN code is provided. This isn’t an unbreakable solution, but what is? It does, however, alleviate the problem that seemed to be on the forefront of most people’s mind.

TechEd 2006 - Day 1

bruce — Tue, 13 Jun 2006 12:02:00 GMT

Yesterday was my first full day ever at a TechEd conference. The first part of it was blown working with customer issues, so it wasn’t until the afternoon that I got to go to my first session. Which was a talk on how to get Windows Workflow and Windows Communications Foundation to work together. Actually, not so much on how, but what’s possible.

I thought it was an interesting talk. Well structure and a good blend between technical demos and the story that you need to keep audiences going (which, as an aside, was what was lacking from the keynote…but that’s another issue). Because I’ve already played with the technology, the fact that it was about level 200 meant that there wasn’t much new in terms of the details. In fact, I left with one question that I still need to get answered. One that deals with threading.

Over the course of the presentation demos were shown to illustrate starting a workflow using a WCF (web service, basically) call and how a workflow can call out using WCF. In other words, there is no question that these two pieces of technology know how to talk together. The question I was left with dealt with starting up a workflow using a WCF call. Specifically, who manages the threads that need to be generated. Is it IIS spawning a separate request? Is it the WF host creating a new thread? And what level of thread-safety do I need to have in any custom activities to avoid causing problems?

I don’t have the answers yet, but I’ll let you know when I do.

And so it begins...TechEd 2006

bruce — Sun, 11 Jun 2006 21:41:00 GMT

Arrived at the hotel a few minutes ago, after spending a wet by nice weekend at Cape Cod with my wife. Yes, I wasn’t as eager as my colleagues to get started on the technical content. So sue me. :)

Throughout the week, I’ll be blogging whenever I come across something interesting to say. I’ll be spending a fair bit of time working in the Connected Systems area at the Technical Learning Center. I’m looking forward to talking about some of the brand spanking new technologies that fits into that particular niche. I’ve already done some work with WCF, but Workflow and WCS (formerly InfoCard) have some potential as well.

There will be more when I have more.

The Five Stages of .NET Conversion (for VB6 Developers)

bruce — Wed, 07 Jun 2006 14:07:00 GMT

For developers, the move from VB6 to VB.NET (or any .NET language) is much more of a mental one than anything else. The syntax of VB.NET is sufficiently familiar to avoid syntax overload. But the functional differences are significant enough to make one question how .NET could make anyone more productive. It has been a while since I made the move myself, but I’d like to share the stages that I, and I suspect most other converts, have passed through.

Anger

Unfortunately this was the first emotion I experience and the one that lingered the longest. When I made the move to .NET, I had been a VB/ASP developer for about 7 years. I could make VB/ASP sing and dance like a virtuoso. I didn’t need to think about the commands to type…my fingers knew what to do with no conscious bidding. I strongly believe that more current VB6 developers are living in this state of grace, which is the reason for the lack of acceptance that .NET could increase productivity.

The first two weeks of .NET were hellacious. I went from coding expert to coding simpleton. Things that were just ‘known’ took 45 minutes of Googling to find. Simple functions, like how to convert a string to a date; how to get the current time; how to identify the current working directory. I estimate that I 20% of what I knew was lost with the move to .NET. Anger doesn't begin to describe the feelings of frustration I felt. Rage would be closer.

Depression

Anger gave way to depression as I gradually realized that .NET was the way of the future. The size of the base class library was (and still is) quite intimidating. How was I going to get my head around all of the various namespaces/classes/properties/methods? After the frustration of the previous two weeks, I sunk into a depression as I realized that I was much further away from becoming “.NET virtuoso” than I had hoped I would be. The days of boundless productivity were both far behind me and far into the future.

Shock

The turning point in this process came when I tried to do something in .NET was was challenging in VB6. For me, that was the creation of a Windows Service. In VB6, the ability to create an application that started automatically when the computer was started and responded appropriately to start/stop/pause/continue commands required some high-end programming or a third-party component. But for .NET, it is dirt simple. In VB.NET, you simply create a class that derives from the ServiceBase class. Create the OnStart method that is invoked when the process first starts and you’re done. Even adding the mechanism to support installing the Windows Service from a command line was easy.

I was stunned. I started to take a second look at some of the other functionality that were challenging in VB6/ASP, to see if the same improvements had been made. My first stop was creating a simple data-driven Windows form. While it wasn’t exactly what I was looking for (a problem that has since been corrected in VS 2005), it was certainly better than VB6. And in ASP.NET, DataGrids rocked as a way to display tables of information pulled from a database. Maybe there was something to this productivity increase after all.

And it didn’t stop there. Creating a text box that accepted only phone numbers and looked like a normal text box(really…anyone *like* the inflexibility of the MaskedEdit controls display?) was also a breeze. Derive a class from the TextBox class and implement the KeyPress and Text property overloads to ensure that the format is appropriate. All dirt simple.

Denial

Now my world was really in an uproar. Could it be that VB6 wasn’t the epitome of development tools…that combination of ease and power that makes it such a staple for business developers? Not possible. After all, look at the millions of lines of code and thousands of developers being successful with VB6. That’s the only measure of a development environment, isn’t it?

Acceptance

And yet, VB.NET ultimately wasn’t that different from what I was used to. Object-oriented concepts had been floating around since VB4.Controls have properties and methods. So could classes. The syntax, nor the idea, isn’t that new. It took a little while to get my head around the power of inheritance, but that doesn’t come up in business development as much as people might think. I was now at the end of the made the journey through the stages of .NET. Once you get over the hump, VB.NET is definitely more productive than VB6 for the average business developer. And keep in mind that I went through these stages in 2002. Assuming you’re moving to VS 2005, then you have even more areas where you have less work to do than you did in the past.

I do have a word of warning for VB6 developers. The Base Class Library (BCL) is incredibly daunting. While I would like to tell everyone not to be intimidated, it’s hard not to be. Enhancements, like the My namespace in VB.NET 2005 relieve some of the stress, but there is still a lot of surface area that the average developer needs to be aware of to maximize their effectiveness. When you first buckle down to learn .NET, make sure you focus on the namespaces and classes that make up the bulk of what you’ll be doing, whether it’s data access, ASP.NET or graphics. Knowledge and familiarity was ultimately the reason that I was able to move through these stages without any -cide effects…that would be homicide or suicide.

Good luck with your own journey.

Update: Title changed, mostly because I can't count. Thanks Rob.

The Future of Languages: Java vs Everything Else

bruce — Thu, 27 Apr 2006 15:07:00 GMT

I’ve been lucky enough to meet and talk with a lot of really smart people during my career. And by smart, I mean off-the-charts, jaw-droppingly brilliant. One of the things I have come to take for granted is that people that smart have the ability to see through much of the clutter and religious rhetoric that pervades so many technical discussions. Which is why I was surprised to read (via Don Box) about the comments that James Gosling, the father of Java, has about the current state of languages.

While (like Mr Box) I wasn’t surprised to see him knock C#, the rationale was not exceptional. Basically he said, Java is better because Java runs everywhere. This is a tired argument that lost any real weight when the myth of “Write Once, Run Anywhere” was dispelled.

But I found his comments about Ruby to be even more stunningly out of touch. While I can’t comment on PHP, I have been exposed to Ruby through the evangilizing of one of my partners, John Lam. It is definitely not restricted to producing Web pages, even though the web framework Ruby on Rails is the vehicle by which most people are familiar with Ruby. As for Mr Gosling’s comment on performance and scalability being a limiting factor, I find that a little disingenuous in light of Java’s history.

The scariest part of the interview is when Mr Gosling suggests that the only way to have power is through complexity. I would think that the goal of a programming language would be to reduce complexity while retaining power. I’m pretty certain that the introduction of C reduced the complexity of writing computer programs (as compared to assembly language) without reducing power significantly. I think that C# reduces some of the complexity of C++ without a corresponding reduction in power. I would expect that the next wave of languages will do the same. I really don’t like the idea of the braintrust of a language throwing in the towel with regards to complexity. That is the beginning of the end of that language’s reign. And if this is really the attitude of Mr. Gosling, I think that the future of Java is pretty bleak.

You Won't Believe What Chalk Can Do

bruce — Wed, 26 Apr 2006 05:47:00 GMT

A friend of mine sent along this link of chalk drawings. Yeah, I know. My kids do them too. But not like this. Unless you have heard of Julian Beever, you haven’t seen chalk like this. Enjoy.

Team Foundation Server and SQL Collations

bruce — Wed, 22 Feb 2006 02:22:00 GMT

I just got through a grueling session of installing the release candidate for Team Foundation Server. And by grueling, I mean about 16 hours worth. And given all of the glowing reports, I was surprised that this install turned about to be more challenging that the Beta 3 Refresh.

My problem centered around one particular point in the process. After having installed IIS, SQL Server, and Sharepoint Services on a fresh version of Windows 2003 (and the .NET 2.0 Hotfix), the installation of TFS performs a health check. My results coming out of the health check was that the running SQL Server instance was using an unsupported collation. Now while I have installed SQL Server many times, I’ve never given much thought to the collation. So I started looking at the problem. Since I had made no changes during SQL Server installation (with respect to collation), I uninstalled SQL Server and reinstalled it specifically choosing the Latin1_General option. Also, because the instructions in the installation help file said that TFS didn’t support case sensitive, binary or binary 2 collations, I left all of the check boxes on that form blank. To no avail. The SQL Server collation was not supportable by TFS

Just to be clear, after all of the dust had settled, my SQL Server’s collation was Latin1_General_CI_AI and TFS just didn’t like that.

So I go digging into the installation log file and come across the SQL statement which gets executed as part of the collation health check:

SELECT * FROM (SELECT CONVERT(char(100), SERVERPROPERTY('collation')) AS Collation) as c WHERE (Collation LIKE '%[_]CS%') OR (Collation LIKE '%[_]AI%') OR (Collation LIKE '%[_]BIN%') OR (Collation LIKE '%[_]BIN2%')

The thing that stood out for me was the inclusion of the Collation Like ‘%[_]AI%’ clause. Unless I’m reading this wrong, it means that TFS doesn’t like Accent Insensitive collations. And I don’t see this small tidbit documented anyplace.

The sole bright spot is that after I reinstalled SQL Server with the ‘Accent – sensitive’ check box on the Collation Settings portion of the installation checked, all went well. I now have a running version of TFS that is capable of working over HTTP. Let the games begin.

Another Notch in a Colleague's Belt

bruce — Tue, 14 Feb 2006 15:53:00 GMT

One of my ObjectSharp partners, Barry Gervin was recently interviewed on .NET Rocks! about one of my favorite topics: LINQ. At the moment, links to the interview in various formats are on the .NET Rocks front page.

Migrating from VB6 to .NET in the Real World

bruce — Fri, 10 Feb 2006 18:08:00 GMT

In the Windows world, my developer life starting with Visual Basic 3. As a result, I have a great deal of respect for what can be accomplished using a ‘toy’ development environment. It also means that I have an on-going interest in helping people who have been working in VB6 transition to .NET. But the conversation at the following link (from Scott Swigart posted by Roy Osherove) hits way too close to home. If you want to gain an understanding of at least part of the reason for resistance, put yourself on the receiving end of the conversation. I’m hoping that Microsoft is aware of just how common this pattern is in the real world. And how much it violates the RAD culture that exists in VB6.

Java, .NET, Web Services and Enums

bruce — Tue, 31 Jan 2006 21:34:00 GMT

While working on getting a Java Web service and a .NET Web service client to talk to one another, I ran into an interesting situation. The problem had to do with the WSDL being produced by the Java service. Actually, the entire process involved the following steps:

An interface written in C# was used to generate a WSDL file.
That WSDL file was imported into JDeveloper and a web service was created
The WSDL file exposed by the JDeveloper web service was used (through the wsdl.exe tool) to create a proxy class to be used by a .NET client.

The problem was caused by enumerations being used in the interface. The WSDL file generated using the C# interface included defined a separate type (with a base of string) for each enumeration and then restricted the string values for that type. However, the WSDL file exposed by the JDev web service expected that the enumerated parameters would be of type string. Not the restricted, created type that C# wants to send. The resulting type mismatch caused the requests from the .NET client to the Java web service to be rejected with an ‘unknown type’ message.

The solution, while admittedly a hack, demonstrations a little discussed features of enumerations. Consider property called Status that is declared as an enumerated type of CallStatus. I added a field called StatusString defined as below and decorated the Status property with a SoapIgnore attribute as follows:

[SoapElement(“Status”)]
public string StatusString
{
get { return Enum.GetName(typeof(CallStatus), status); }
set { status = (CallStatus)Enum.Parse(typeof(CallStatus), value); }
}

[SoapIgnore()]
public CallStatus Status
{ … }

The SoapIgnore attribute hides the ‘real’ Status property from the SOAP serialization process. Instead the StatusString property, which is used to convert enumerated values to and from a string, is marked as being the ‘Status’ from the perspective of SOAP serialization. One item that may or may not be a problem is that the assigned value of StatusString could be null. This isn’t considered as part of this example, as the Web service was under a compulsion to return a valid value. But if the field is nilable, then you would need to code for that in the StatusString setter.

A Must-Attend Conference

bruce — Tue, 31 Jan 2006 14:49:00 GMT

For those of you interested in furthering your development career, might I suggest checking out Waterfall 2006. It’s new, but oh so relevant.

Thanks to Howard for the heads-up.

Automatic Check-Out Not Working with VSTS/TFS

bruce — Fri, 27 Jan 2006 17:38:00 GMT

For the last little while I have been having an issue using source control under TFS. Specifically, when I go to edit a file that (I believe) is under source control, I'm allowed to do so. What's worse, when I go to save the file (like when the application is executed or I'm running through TestManager), I'm told that the file is read-only and I'm asked if I want to overwrite it. Even if I overwrite the file, I still have to go to the Source Control Explorer and manually check the file out for editing. This is, as I'm sure many of you would agreed, annoying beyond belief. I could easily go on for paragraphs about how I'm being taken out of the flow and why isn't this happening automatically.

When I first discussed this problem with others, I was told to go to the Tools | Options dialog box. Once there, in the Source Control | Environment section, there is a couple of controls that control what happens to files upon Saving and Editing. It was suggested that setting these to “Check out automatically” would work.

Unfortunately, this wasn't the first. First off, it appears that these settings are the default values. At least, they were on my system. Frustration ensued for another couple of weeks.

Then, for reasons which I'm not sure of, some of the projects in my solution started acting the way they were supposed to. As I started editing a file, a quick “checking out” message appeared. I was confused, to put it mildly. Not to mention intrigued. As I started looking I found that the working projects contained a file with an extension of .vspscc. This is the source control bindings information for the project. After a little more work, I discovered how to create this file through the Visual Studio IDE. From the File menu, select Source Control | Change Source Control. In the dialog box that appears, the non-working projects will not be bound to a TFS server. Assuming that you are already connected to the correct TFS server, select the unbound projects and click on the Bind button at the top of the screen. This will check out the project files and you will (naturally) need to revolve any conflicts and check them back in. As well, you may need to restart Visual Studio to get the automatic check-out to work (I'm 50-50 on having to do this). But most importantly, source control will now work more like you would expect.

News on TFS Release Candidate

bruce — Thu, 19 Jan 2006 19:49:00 GMT

Just passing this information on to any who might have missed it. Look for the Release Candidate for TFS in early February.

http://blogs.msdn.com/jeffbe/archive/2006/01/19/514801.aspx

Equality Overloading and Code Analysis

bruce — Tue, 17 Jan 2006 16:19:00 GMT

One of the things I like about VS 2005 is the integration of FxCop functionality into the IDE. Most of the time, it informs me of better practices to things that I would have done differently in previous versions of .NET. A good example is the IsNullOrEmpty method on the String class. Code analysis pointed out that, for some of my code, this would be a better performing replacement for the

x == null or x == String.Empty

tests that are quite common on parameter validation.

One of the problems that I ran into, however, was when I was trying to correct a code analysis note about validating arguments. Specifically CA 1062 - Validate Arguments on Public Methods. I had a equality operator overload that looked like the following:

public static bool operator==(BusinessObject x, BusinessObject y)
{
return x.Name = y.Name;
}

The code analysis complaint was that I should be validating the arguments of the public method. OK, I said, and modified the code to the following:

public static bool operator==(BusinessObject x, BusinessObject y)
{
   if (x == null)
      return false;

   if (y == null)
      return false;

return x.Name = y.Name;
}

First off, the reason for the two if statements was because if I only used one, code analysis still complained. But what's worse is that when I ran my unit tests, I got a fatal exception saying that VSTestHost.exe had crashed. Walking through the code, I discovered a fatal oversight that caused the problem. Feel free to take a few seconds to consider the possibilities before reading the answer.

Figure it out? It's much easier if you debug the app.

The problem is that the if (x == null) line introduces a stack overflow. This is because in order to evaluate whether x equals null, what does the code do? It calls the overloaded equality operator. Over and over again.

The solution is to modify how a null value is checked.

public static bool operator==(BusinessObject x, BusinessObject y)
{
   if (Object.ReferenceEquals(x, y))
      return true;

   if (Object.ReferenceEquals(x, null))
      return false;

   if (Object.ReferenceEquals(y, null))
      return false;

return x.Name == y.Name;
}

Now you should be good to go.

Update: Corrected the fact that I can't write C# code without the benefit of a compiler :) See the comments for the rationale

Toronto Code Camp is in the Books

bruce — Mon, 16 Jan 2006 05:05:00 GMT

Well the first Toronto Code Camp is finished and, as far as I can tell, it was a success. There was somewhere north of 175 people who spent their Saturday to hear some wonderful speakers discuss technology. Current technology. Future technology. And lots of demos galore. Worst thing that happened was that Saturday morning was the first below freezing day in Toronto in quite a while. Meaning that many of the attendees were colder than normal when they walked through the door.

Kudos to Chris Dufour and Jean-Luc David, as well as their crack team of volunteers, for putting on a first-rate conference. When you hear about the next code camp, make sure you get your name in quickly. I’m sure it will ‘sell’ out as fast as this one did.

Upgrading to WSE 3.0

bruce — Mon, 21 Nov 2005 14:38:00 GMT

If you weren’t aware, the version of WSE 3.0 built against the release version of Visual Studio was released on the Nov 7. I’m sure that it would have received launch parties and wide mention in blogs were it not for the conflicting launch of Visual Studio .NET, SQL Server 2005 and BizTalk 2006. :)

If you did any work with the CTP versions of WSE or if you are upgrading from WSE 2.0, there is one thing you should definitely be aware of. Specifically, I had created a WSE policy that use Anonymous over Certificate security. It was working in the CTP version. Then I upgraded to the release version. All of a sudden, I received the following error message on the client side:

WSE910: An error happened during the processing of a response message, and you can find the error in the inner exception. You can also find the response message in the Response property.

The inner exception was an InvalidOperationException with a Message of:

Security requirements are not satisfied because the security header is not present in the incoming message.

After a fair bit of digging, I determined that this message is actually a “can’t validate the user’s credentials” message. But the real cause (because, after all, I was still sending the same credentials that I did prior to upgrading) was a little more subtle. In order for the WSE functionality to work in 3.0, a new element needs to be added to the web.config of the service.

<system.web>
   <webServices>
      <soapServerProtocolFactory type="Microsoft.Web.Services3.WseProtocolFactory, Microsoft.Web.Services3, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
   </webServices>
</system.web>

When this tag gets added, all of a sudden the message went away. To be fair, this tag is documented as one of the changes between WSE 2.0 and 3.0. What surprised me is that it appears to also be one of the changes between the earlier CTP versions of WSE. Hopefully this post will help others avoid my not-so-brief struggle.

Hilarious

bruce — Wed, 16 Nov 2005 17:36:00 GMT

Check it out:

http://www.sellsbrothers.com/news/showTopic.aspx?ixTopic=1906

How geeks pass the time

bruce — Fri, 11 Nov 2005 18:32:00 GMT

As I mentioned earlier, I was at the Visual Studio/SQL Server/BizTalk product launch in Ottawa yesterday. I was lucky enough to be included I love getting a chance to talk to people who are just getting into .NET 2.0. I have been working with it on a daily basis for more than 6 months, to the point where I almost forget whas VS 2003 is like. Answering questions helps put my world back into perspective.

But it's not all talk at this sort of event. There is a fair bit of down time while most of the people are in sessions and there is no one to ask us questions. And when a bunch of geeks get bored, you know the results are not going to be pretty. One of my co-experts, Richard Lander, presented the following challenge: http://hoser.lander.ca/PermaLink,guid,20c75894-5947-4a62-a9c6-01b14516ecf8.aspx

Make sure that you give the code a try. I can pretty much guarantee that the number of people who will guess correctly will be incredibly small. After all, Richard is on the CLR team (and smart to boot) and he wasn't jumping up and down with the answer. Even after seeing the results, those of us in the room were scratching our heads looking for the reason. So give it your best shot and let me what you think and why.

VS 2005 Launch Events

bruce — Fri, 04 Nov 2005 14:16:00 GMT

Next week, I'm going to be a cabana boy at the VS2005/SQL2005/BizTalk2006 launch events in Toronto and Ottawa. It should be an interesting experience. I'm looking forward to finding out the areas of interest for most people. I've been pretty much immersed in VS2005 for so long, that I almost forget what's new. This should be a nice chance to get caught up with reality.

If you've already made plans to attend, you might want to check out this post from Mark Relph about a 'hidden' contest. If you haven't made plans, there is still room to register in Toronto. The Ottawa event is currently waitlisted. Up-to-date information can be found at the official Canadian Launch Site.

RTM Version of VB Linq

bruce — Thu, 03 Nov 2005 15:38:00 GMT

For those of you that think the bleeding edge is not sharp enough, the bits that include the LINQ preview have been redone for the final version of Visual Studio. You can get it here. Personally, I think you should at least let the code cool before working examples of the next version of a language is available, but what do I know.

Not enough to retire on, but still...

bruce — Thu, 03 Nov 2005 13:44:00 GMT

By way of the Freakonomics blog:

My blog is worth $6,774.48.
How much is your blog worth?

Developers, start your downloads

bruce — Fri, 28 Oct 2005 14:02:00 GMT

If the noise rising up from the blogosphere hasn't reached you yet, Visual Studio 2005 and SQL Server 2005 are now available for download for MSDN subscribers. This would be the 'real' versions as opposed to the beta/CTPs that we've been working with to this point. Also, .NET 2.0 Framework is available at www.microsoft.com/downloads, so that the beautiful VS2005 apps can be deployed to non-development machines.

Big day, to say the least. And T-minus 9 hours before both downloads have finished for me. ;)

Too good, it is. Shared, it must be

bruce — Thu, 13 Oct 2005 19:43:00 GMT

http://blogs.msdn.com/mattwar/archive/2005/10/09/479008.aspx

Toronto Code Camp Registration Opens

bruce — Wed, 05 Oct 2005 18:07:00 GMT

The rumours have been swirling. Now the truth is out.

On Sat. Jan 14, there will be a Toronto Code Camp. You can register/find more infomation/hang out at http://www.torontocodecamp.com/

If you're a developer looking for in-depth content from the people who know (that would be other developers), then the code camp is the place to be. If you're a developer that has in-depth content that other developers could use, this is you're chance to shine. Regardless, it will be a blast. Clear your schedule now to be there.

The end of Begin/End

bruce — Sun, 02 Oct 2005 16:23:00 GMT

While on my way back from the MVP Summit, I was playing around with some of the things I had discovered about VS 2005. I mean, if I was going to drip geekiness for the entire conference, why not extend it to the absolute limit. And what I found was something mildly disturbing.

A pet peeve of mine for a while has been how easy it is to make an asynchronous Web service call. Whether the caller knows it or now, that call actually makes your application multi-threaded. For the simplest case, that’s fine. But when you’re making the call from a Windows form application and need to update the user interface with the results of the Web method call, you are getting into an area of complexity that’s more complicated than you realize. Ask any decent developer what the hardest time of bug to crack is and invariably you’ll get ‘race conditions’, ‘deadlocks’ or just the generic ‘multiple threads’ back as the answer. And you have entered that realm unknowingly.

For VS 2005, Microsoft took my complaint and said ‘hey…if updating the UI is soooooo hard, we should make it easier’. Not what I had in mind, trust me. Ask me about a /nomultithread default compiler switch and you’ll be closer. So now instead of calling BeginHelloWorld and EndHelloWorld, it is possible to call HelloWorldAsync and create an event handler for HelloWorldCompleted. Yes, it’s a familiar model. And, as it turns out, HelloWorldCompleted actually fires on the main UI thread, so that ugly MethodInvoker stuff no longer needs to be understood.

But along with changing this asynchronous model, Microsoft also eliminated the Begin/End versions of the methods. Which means if you need to do something like a fork/join pattern, you can’t. Just so that we’re clear, a fork/join would have previously consisted of:

IAsyncResult ar = ws.BeginHelloWorld(null, null);

// Do some stuff in parallel with the web service call

string result = ws.EndHelloWorld(ar);

Because of how EndHelloWorld works, the main thread will block until the background thread has completed. And if the background thread finishes first, processing will continue normally. This is a very common approach if you’re web page were to fire off an asynchronous call to a Web service and wanted to include the results on a page being returned to the client.

As I was saying, since the Begin/End methods are no longer included in the proxy class, this pattern (at least as I have outlined it) is no longer possible. And to replicate the pattern using the event handler model is non-trivial. So my solution was to take the class generated by WSDL (or by adding a Web reference) and putting back in the Begin/End methods that I need. The basic structure is:

  public IAsyncResult BeginHelloWorld(AsyncCallback callback, object asyncState)
  {
   return this.BeginInvoke("HelloWorld", new object[0], callback, asyncState);
  }

  public string EndHelloWorld(IAsyncResult ar)
  {
   object[] results = this.EndInvoke(ar);
   return ((string)(results[0]));
  }

The second parameter on the BeginInvoke call is an array of objects representing the parameters to HelloWorld, so if you’re doing this for a method that takes parameters, you’ll need to change the dimension of the object array and initialize it appropriately.

You know you're living on the edge when...

bruce — Fri, 30 Sep 2005 18:11:00 GMT

…you hear a presenter say “In the past…er…I mean in the version that’s about to ship”

Blogging from the MVP Summit

bruce — Fri, 30 Sep 2005 18:04:00 GMT

One of the cool things about being an MVP is that I get invited to the annual MVP Summit. One of the bad things about being at the summit is that it is covered by an NDA agreement. Which means I don’t get the blog about anything that I’m seeing here. That having been said, I think I can get away with this.

Yesterday there was a morning of executive keynote presentations. It was in a large facility, complete with big screens, translators and closed captioning. Closed captioning that was hand-typed as the executive was speaking. By someone who isn’t intimately familiar with technological terms. The following is a brief list of the mistypings:

Lynn Yucks = Linux
urine testing = unit testing
martyr = smarter

Almost seems Freudian, doesn’t it.

Atlas for VS 2005 Release Candidate

bruce — Tue, 27 Sep 2005 15:59:00 GMT

It looks like the version of Atlas that is capable of running with the VS 2005 release candidate is being...er...released. The link, from what I can see, is here or here. If it doesn't work, keep trying. The page has been alternating between available and missing.

Get it while it's hot.

What Inferred Types in C# 3.0 are Not!

bruce — Sat, 24 Sep 2005 18:06:00 GMT

I had the opportunity earlier this week to listen on a MSDN chat covering the enhancements to C# that were unveiled at PDC. Listen being an imprecise term given that it was a chat, you understand.

I had two main takeaways from the chat. First, there was a ton of interest in LINQ and the various inner and outer workings of that. I’ll post some observations on that shortly. The second thing I learned was that there seemed to be a high level of confusion over exactly what inferred types are bringing to the table. I think that the real problem is that they don’t bring nearly as much as people expect/want/are afraid of. Please allow me to put the underlying thought into my own words.

In its simplest form, an inferred type looks like the following:

var a = 1;

The ‘var’ keyword is used in place of a data type. At compile time, it is inferred that a is intended to be an integer. From that point forward, the compile treats a as if it had been defined as:

int a = 1;

So much for the simplest case. And, in fact, using this as the example is a bit of a problem because no one should ever write code this way. In this simple a case, you should use the second code rather than the first. This makes it difficult to understand when inferred types are even useful. So let me pull the example that was used in the chat:

Dictionary>> peopleOrders = new Dictionary>>();

Now everyone who thinks this is easy to read hold up your hand. In this blog, where there is no syntax coloration, it’s hard to figure out what the name of the variable is, much less what the type is. When this code is read, the programmer will have to give it a second or third glance to get what is going on. And since variable declarations are not normally that important to the business logic of a method, all this syntax does is add friction to the process of understanding. So consider the inferred version:

var peopleOrders = new Dictionary>>();

Isn’t this much easier to digest? I’m sure that even those people who put their hands up for that last question will agree. At that, ultimately, is the purpose for inferred types. To reduce the friction involved in reading code. Strong typing is still in place. Programs are still type-safe. Casting exceptions will still be thrown when appropriate. In other words, inferred types are just a way to pretty up the syntax of C#. And given some of the code that I’ve looked in the past, anything that helps keep modules cleaner is worth it.

Great Customer Services Sells

bruce — Tue, 20 Sep 2005 03:59:00 GMT

One of the things that really turns my head when it comes to software is great customer service. I have been using a product called ClearContext for about six months now. It is a tool that allows you to prioritize the email that arrive in your Outlook in-box. I have found it quite effective in whittling my in box from almost 1000 to less than 75.

But this post isn’t intended to be an ad for ClearContext. Instead, it was their service that set them off. A little while ago, I lost a hard drive on which I ran Outlook. Which means I also lost the licensing information for ClearContext. While I could download and run the product without the license, the nag screen eventually got to me. On Saturday at 1:33 pm, I sent an email to ClearContext asking if they could resend my registration key. Before 1:45 pm, I had received the keys I requested.

Why is this so incredible? Because I don’t get the sense that ClearContext is a huge company. It’s certainly not a Dell, Microsoft or Oracle that have support staff 24x7. But they gave me exactly what I wanted when I wanted it. Can’t do any better than that and it’s certainly worth a plug in my blog.

Getting the schema for an XML column in SQL Server 2005

bruce — Tue, 06 Sep 2005 12:27:00 GMT

There is no question that the XML column data type in SQL Server 2005 opens up a large number of interesting possibilities. Some that I’ve even been lucky enough to work on myself. In this particular instance, I needed to find out the schema against which a typed XML document will be validated. The idea is to provide some client-side validation for the XML before submitting it to the database server. This doesn’t prevent SQL Server from redoing the validation (there isn’t any way to prevent that from happening that I’ve found), but it does reduce network traffic in the case of bad data.

The problem I faced was that the schema information is not readily apparent. After some digging, the I found that the following SQL will get the string representation of the schema.

SELECT Object_Name(Object_id) [TableName], col.name, s.name, XML_SCHEMA_NAMESPACE(sch.name,s.name)
   FROM (sys.columns col INNER JOIN sys.xml_schema_collections s ON col.xml_collection_id = s.xml_collection_id)
      JOIN sys.schemas sch on s.schema_id = sch.schema_id
WHERE Object_Name(Object_id) = @TableName
   AND col.name = @ColumnName

The first two columns are the table and column name. The third column is the name of the schema used for the column. This is the name as found in XML_SCHEMA_COLLECTIONS. The fourth and final column contains the string representation of the schema.

I'm sensing some battle lines being drawn

bruce — Wed, 31 Aug 2005 21:50:00 GMT

I’ve gotten my hands a little more dirty with SQL 2005 over the last couple of months. I’ve used CLR triggers and stored procs to implement some functionality that would have been difficult to do using T-SQL. I’ve worked with XML datatypes to generically extend the fields that can be persisted in a table. In other words, I’ve played with some of the newer and potential more contentious features of SQL 2K5.

While cruising through a number of blogs today, I came across this post from Don Demsak. In it, he refers to an eWeek article DBAs Bar Door Against Big Bad .Net Wolf.

My own experiences suggest that this tone is just the beginning. I recently had a chance to hear a presentation on the Web Service functionality that SQL Server provides. For the uninitiated, it is possible to define an HttpEndpoint in SQL Server. On this endpoint, methods can be defined that expose stored procedures. Interesting functionality to include in SQL Server, but what I found most interesting was the angle that the speaker took in support of the idea of exposing your SQL Server machine to the Internet. The suggestion was that, with ASP.NET Web services, the DBA has no idea what data or functionality that the ignorant (my word, but their tone) developer created. By exposing their own Web services, the DBA could take control over the exposed data by eliminating the middle man.

My first instinct was ‘whoa’. The approach seemed a little extreme. Maybe I’m just an ignorant developer, but for most of my professional life, the idea of having the machine running the database server exposed to the Internet, even if it was ‘only’ port 80, was never considered a good idea. And the HttpEndpoint doesn’t include support for any of the WS-* standards. It is basically just the same sort of Web service that was available back at ASP.NET 1.0 before the introduction of WSE.

Does anyone else thing this feature is a good idea? Am I just being short-sighted and/or narrow-minded?

SQL Server User's Group Meeting in Los Angeles

bruce — Thu, 25 Aug 2005 20:39:00 GMT

Just in case anyone reading this blog happens to be in the Los Angeles area, I’m speaking at the SQL SIG chapter of the Los Angeles .NET Developer’s Group this evening. The topic is Using Managed Code in SQL Server 2005 and it should be a combination of demo and architectural discussion (because the demo is, for the most part, pretty ordinary…that’s what happens with the design is solid:). For more information, check out the event description.

EXECUTE permissions needed for XML Schema Collections

bruce — Sun, 21 Aug 2005 03:51:00 GMT

I’m working in depth with the new XML data type in SQL 2005 for the first time. There are a number of aspects that I really like. In particular the ability to strongly type the column using an XSD as the validation. For what I’m doing (it involves allowing a client to extend and persist database tables), they are almost perfect.

As you work through this process, however, it’s important to be aware of the permissions that are required to utilize the schema. Once I had added my XSD to the XML Schema Collection, I tried to INSERT a record into the table. I received the following exception:

System.Data.SqlClient.SqlException: EXECUTE permission denied on object 'OrdersExtension', database 'Northwind', schema 'dbo'

It turns out that in order to use the schema, the user needs to be granted EXECUTE rights. Specifically, the following statement needed to be executed:

GRANT EXECUTE on XML SCHEMA COLLECTION::dbo.OrdersExtension to DBUser.

Whoo-hoo. Problem solved.

Ridding yourself of the Print Status Dialog

bruce — Mon, 15 Aug 2005 15:53:00 GMT

I had the need this past weekend to eliminate the Print Status dialog from a printing process. Just to make sure that we’re speaking the same language, the Print Status dialog is that message box-like artifact that appears while a job is printing. The text in the dialog shows progress with a ‘Printing 1 of 10’ sort of message. It is this generic message that I was trying to get rid of.

Research into this area introduced me to a class that I was previously unaware of – the PrintController. This class is responsible for driving the printing process, detecting when the process has been cancelled and raising the PrintPage event. As such, it is also in charge of displaying and updating the print status dialog.

There are a number of classes in the .NET Framework that provide print controller functionality. The StandardPrintController actually doesn’t display the Print Status dialog, so it is a simple process to instantiate a StandardPrintController object and assign it to the PrintController property on the PrintDocument. Now that annoying (to me, anyway) goes away.

Or does it. All is good until you want to preview the document. Setting up a PrintPreview dialog and activating it results in that Print Status dialog reappearing. Even after the StandardPrintController is being used. Nothing I try makes the message box go away. Some in depth digging reveals the cause of the problem. Deep in PrintPreviewControl class there is a method called ComputePreview. The purpose of ComputePreview seems to be to generate the entire report and make it available for previewing. Within this method, the PrintController property on the PrintDocument associated with the preview control is temporarily replaced. Replaced, it turns out, with the PreviewPrintController. And the PreviewPrintController displays the print status dialog. To this point, I can’t seen how to avoid this problem. Any suggestions are welcome.

Unexpected Locking in SQL Server 2005

bruce — Tue, 26 Jul 2005 04:51:00 GMT

I was working a little bit with SQL Server 2005 today and ran across an unexpected (at least to me) situation. From within the Management Studio, I opened up a table to view the contents. Nothing complicated, although I did modify the default SQL slightly to reorder the results. Then, in another query tab, I executed a script that did a DROP TRIGGER against the table that I had just opened. Problem is, the DROP statement just hung there. Waiting on a lock. Specifically, waiting on exclusive access to the table. A lock that it couldn’t get because I had opened the table through Management Studio. Like I said, unexpected.

The solution was simple once I saw who was holding the lock. Close down the tab and everything was hunky-dory. But the time I spent researching the problem is gone, never to be recovered. I also did a bit of digging into why this was so unexpected. It doesn’t appear to happen in Enterprise Manager. Simply opening a table and retrieve all of the rows does not establish a lock on the records. Doesn’t even appear to if you start to edit a particular record. Chalk it up to one more thing that is new and improved.

Getting out of the Longhorn Habit

bruce — Fri, 22 Jul 2005 17:15:00 GMT

One of the problems with keeping one eye on the next version of software is getting too comfortable with the name. I still say Whidbey instead of VS.NET 2005 and it will take me a while yet before that problem goes away. And Microsoft has just added another synonym to that problem. Please welcome Microsoft Vista as the ‘real’ name for that which has been called Longhorn for what, about two years. Yeah, like I’m going to be able to make that adjustment quickly.

A Rare Personal Post

bruce — Fri, 22 Jul 2005 15:15:00 GMT

I don’t normally post on what’s going on in my personal life. For the most part, nobody would care. Not to mention that my life just isn’t that interesting. However, having just had our 5 month old chocolate labrador spayed, I found this particular comic (found at Basketcase Comix) to be the biggest laugh I’ve had in a few weeks. So how could I not pass it on.

Invalid XPath Expression in a BizTalk Mapping

bruce — Mon, 18 Jul 2005 14:22:00 GMT

While working on a BizTalk mapping for a client, I ran across an unusual problem. When the mapping was tested, an XSL transform error was thrown. Specifically, the error message was:

XSL transform error: (0,0) : 'userCSharp:(string(*[local-name()='Times' and namespace-uri()='']/*[local-name()='WindowCloseTime' and namespace-uri()='']/text()))' is an invalid XPath expression. 'userCSharp:(string(*[local-name()='Times' and namespace-uri()='']/*[local-name()='WindowCloseTime' and namespace-uri()='']/text()))' has an invalid qualified name.

Since this came from the XSL that is generated by the mapping, the first step I took in identifying the problem (ok…the first step after scratching my head for 30 minutes or more) was to examine the XSL for the mapping. This can be created by running the Validate Map option from the Solution Explorer. My search for this particular XPath expression found it in an XSL segment that looked like the following.

<xsl:variable select="userCSharp:(string(*[local-name()='Times' and namespace-uri()='']/*[local-name()='WindowCloseTime' and namespace-uri()='']/text()))" name="var:v18"></xsl:variable>
<xsl:if test="string($var:v15)='true'">
<xsl:variable select="string($var:v18)" name="var:v19"></xsl:variable>
<xsl:attribute name="FIRST_PU_MINUTE">
<xsl:value-of select="$var:v19"></xsl:value-of>
</xsl:attribute>
</xsl:if>

Now that I have a better look, it appears that the userCSharp namespace has attached itself to an XPath expression. Normally, it is attached to a function that is defined further down in the XSL file. No wonder it’s invalid.

The good thing is that I was able to see from the attribute name that the problem is in the mapping for the FIRST_PU_MINUTE attribute. When I looked, it turned out that the scripting functoid I was using hadn’t been defined. Instead of defining the external assembly function, I had left it as the default, commented-out code. Once I corrected that problem, my transform error went away.

Update: The XSL fragment didn't appear when I first posted it. My bad. Now it makes much more sense.

Updating Config Files in ASP.NET 2.0

bruce — Fri, 15 Jul 2005 05:13:00 GMT

One of the new features of ASP.NET 2.0 is the ability to not only more easily read from config files, but also to update them. If you’re looking for a pretty good description of what’s possible, check out the ASP.NET QuickStart Tutorial. Going over the basic process isn’t the point of this post. Instead, I want to talk about an unexpected, but yet expected, side effect.

The situation is quite common. Your web site utilizes Session variables. Over the course of your application, you update one of the config files that you had defined. All is fine and wonderful right up to the point where a Session variable was accessed. For some unknown reason, it was gone.

If this particular situation sounds familiar, there could very well be a good reason. It is similar to what happens if web.config gets updated on an active virtual directory. At least the symptoms are. What is actually happening is that the web application gets restarted. So it should be a surprise, should it.

Well, no. With one minor exception. In the particular case we were looking at, the config file was actually defined as an external file. So in web.config there was an entry similar to:

So the actual updates were taking place outside of the web.config file. Since web.config isn’t updated, the application shouldn’t restart. Should it?

Well it turns out that the default behavior of the Config API is that changes to the external file cause an application restart just like web.config. And with the application restart comes the loss of Session information

There is a way to modify this default behavior. In the <section> tag where the config section is defined, the restartOnExternalChanges attribute gets set to false.

All of a sudden updating the config file doesn’t cause an application restart and all of the little session variables remain fat and happy.

Invasion of the Language Snatchers

bruce — Mon, 04 Jul 2005 02:43:00 GMT

While spending my weekend perusing blog and other light bedtime reading. In doing so, I came across an interesting entry by Rocky Lhotka. He discusses the Mort persona and it’s impact on the features found in VB.NET. I agree with his observation that the continuous suggestion that VB is not a ‘real’ language has driven a large number of Morts to C#. I did a number of the MSDN Whidbey User Group tours across Canada and was surprise how often C# is the language of choice even if the development team is already VB familiar. So the trend to adding Mort-desired functionality is only going to pick up speed.

So is this a good thing for C# developers. I, for one, believe that it is. Many of the productivity advancement for Visual Studio come up through the VB.NET ranks. Improved intellisense. Edit and continue. Having Mort push on the C# IDE will only improve it over time. If your disappointed by the impurities that might be added to C#, don’t fret. You can always take up Ruby.

Missing vcvarsall.bat in VS.NET 2005 Command Prompt

bruce — Sun, 03 Jul 2005 05:34:00 GMT

I took a few moments to dig into a nagging problem this weekend. Seems that whenever I launched the Visual Studio 2005 Command Prompt, I received an error message indicating that a file called vcvarsall.bat couldn’t be found. A thorough search of the Visual Studio 8 directory found nothing of that name, although there was the old standby of vsvars32.bat. I took a further search through ladybug and I see that it had already been reported and marked as fixed for the release version. If you find this annoying, there is a workaround available. The details can be found at http://lab.msdn.microsoft.com/productfeedback/ViewWorkaround.aspx?FeedbackID=FDBK24480#2, but it works out to be either install C++ or change the shortcut for the command prompt to run vsvars32.bat.

And so the migration begins...

bruce — Mon, 27 Jun 2005 13:59:00 GMT

I’ve been a fan of NUnit for quite a while now. There is nothing like it for increasing the likelihood of creating quality software in the face of shifting requirements. The philosophy involved with parallel development of unit tests and code is one of the reasons that I’m looking forward to Visual Studio Team Systems. With NUnit-like functionality embedded in the IDE, the number of developers utilizing this approach should increase. And, as it turns out, all of those NUnit tests that have already been created don’t have to be left behind. Thanks to Roy Osherove, I found out that a tool to convert NUnit tests to VSTS tests is being created by James Newkirk. I’ve already downloaded it and the playing begins.

Advancing the Cause of Social Science

bruce — Fri, 24 Jun 2005 22:53:00 GMT

Have a weblog? Take the following survey and help out an MIT research project.

BTW, the 'Cameron' I was thinking of is my son. He needs freeing from the enslavement he feels from being 7. :)

A Return to BizTalk EDI Base Service

bruce — Thu, 16 Jun 2005 04:39:00 GMT

A while ago, I described a problem where BizTalk’s EDI Base Service wouldn’t restart on a system reboot, even though it was set to start automatically. It turns out that the problem is apparently caused by the timing of the starting of other services. The EDI Base Service requires that the main BizTalk service is running. If it’s not, then the start for the EDI service fails. If after your system has settled down from the reboot, you try to start the EDI service manually, all works well.

The solution is to add a value to the registry to force the EDI Base Service to depend on the BizTalk service. This is done by adding a value to HKLM/System/CurrentControlSet/Services/EDI Subsystem. The value name is DependOnService. The type for this particular value is REG_MULTI_SZ. The value for this value (yes, I know how that sounds) is the name of your BTSSvc entry. For me, it’s BTSSvc{DC267C4B-9C82-4B6F-B5CA-F4571593C6DE}. Yours may or may not (I’m guessing not) be the same, but it is a key underneath HKLM/System/CurrentControlSet/Services that starts with BTSSvc followed by a GUID.

Once you’ve made this change, the next time you restart, you shouldn’t see that error. At least, that has been my experience to date.

And you think SQL injection is dangerous

bruce — Tue, 14 Jun 2005 02:05:00 GMT

I’m a regular reader of thedailywtf.com. I find it to be an interesting source of examples that I use to lighten up the classroom experience. But this particular example (appropriately called Tossing Your Cookies) is worth spreading around more quickly. I know that defensive web development says that you should validate every input coming into your system, but really…

Just to make VB.NET developers feel better...

bruce — Mon, 30 May 2005 18:04:00 GMT

From Don Box’s blog, I found the following post describing why C# might become irrelevant. Think of the fun if the VB6 petition was replaced by classicCSharp.org (note to self…register that domain). Would each of the points have to end in a semi-colon? Would each objective be surrounded by curly brackets? Enquiring minds want to know.

The Dual Life of Code Behind

bruce — Sun, 15 May 2005 19:52:00 GMT

When you create an ASP.NET page using Visual Studio .NET, the default processing model is to use code-behind (the basics of which I described here). One of the more interesting aspects of code-behind is that you can specify the code for the code-behind assembly using two different techniques. The first, and most commonly used is to build an assembly and deploy it to the bin directory on the web server. The second mechanism is to specify the file containing the source code in the Page directive for the ASPX file.

Compiled Assembly

<%@ Page Language=”C#” Inherits=”ObjectSharp.WebPageClass” %>

Source Code

<%@ Page Language=”C#” Src=”WebPageClass.cs” %>

There are pros and cons to both of these approaches. Functionally, they are equivalent. When the first request is made to the page, the source code file is compiled and the resulting assembly loaded into memory. For every subsequent request, no compilation is required. Not only does this mean functional equivalence, but it also means that there is no performance penalty for deploying source code instead of a compiled assembly.

The biggest downside of the source code technique is exactly that, however. That the code file needs to be deployed onto the web server. This, naturally, has the potential to be a security problem. A deployed assembly doesn’t have quite the same exposure, if only because it can be deployed into the Global Assembly Cache instead of directly into the application’s virtual server.

While it might seem that the security risk might tilt the tables entirely towards compiled assemblies, that isn’t true. The problem with compiled assemblies has to do with updates to the web site. When a new version of a compiled assembly is deployed to the web server, IIS is smart enough to detect the change. The current web application is stopped and restarted so that the modified assembly can be loaded. Unfortunately, the stopping and starting of the web application means that every Application and, more importantly, Session variable is discarded. Depending on how the web application has been designed, this can be a significant problem.

Source code deployment doesn’t suffer from the same problem. As with compiled assemblies, IIS monitors the source code files, so that when an update occurs, a recompilation takes place. So the updates do get activated immediately. The difference is that the web application does not have to be stopped and started in order to get the changes in place.

Choices, choices. The trick to ASP.NET, as it is with almost any discipline, is to understand not only the choices but when each can and should be used. This not only helps you design better web applications, but also solve those nagging times when the web application seems to restart for no apparent reason.

How Consultants Work...well, some of them :)

bruce — Sun, 15 May 2005 18:52:00 GMT

As a person who works in the computer industry, I have been a fan of Dilbert for years. As a consultant, I get a special kick out of cartoons such as this one. Not that I’ve ever been questioned about the process I use. But even if I was, I’d make sure to take my time and consider my answer carefully. :)

The Code Behind Model of ASP.NET

bruce — Sun, 15 May 2005 18:16:00 GMT

Almost from it’s beginning, HTML has been a mixture of data, display and logic. While the original static pages might have only combined data and display, once scripting was introduced the three disciplines have lived together uncomfortably. ASP only made this situation worse by introducing a different location (the server) where the scripting code could be executed.

Ugly doesn’t adequately describe this problem. There is little possibility for functional reuse in this scenario. It is difficult even to modify existing business logic, much less make sure that it’s capable of being using by other components. This is not how enterprise-class applications are suppose to be created.

While ASP.NET supports this older processing model (known as in-line), it also introduced a newer model known a code-behind. While this particular model doesn’t eliminate the data/display co-mingling, it does take the business logic away from the web page. Instead, the events are handled by methods in a separate class. The code behind class. Let’s take a brief look at how these pieces (the ASPX page and the code behind class) get wired together.

<%@ Page Language="C#" Inherits="ObjectSharp.WebPageClass" %>

Above is a standard, if simplistic, ASPX page. Were it not for that first line, it would look like pretty much a run-of-the-mill HTML page. And it’s that first line that brings the code-behind class into play.

That first line is known as the page directive. When the ASPX file is processed, the directive is interpreted to mean that a) the language in any of the script blocks in the file will be in C# and b) that the processor should use methods in ObjectSharp.WebPageClass to handle the events raised by the web form. As an example, this means that the MyButton_Click method (seen above as the Onclick event handler for MyButton) would be implemented in the assembly that contains the ObjectSharp.WebPageClass class.

using System;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace ObjectSharp
{
    public class WebPageClass : Page
    {
        protected System.Web.UI.WebControls.Label MyLabel;
        protected System.Web.UI.WebControls.Button MyButton;
        protected System.Web.UI.WebControls.TextBox MyTextBox;

        public void MyButton_Click(Object sender, EventArgs e)
        {
            MyLabel.Text = MyTextBox.Text.ToString();
        }
    }
}

Above is an example of a code-behind file for that example ASPX page. Again, there are a couple of points worth noting. First off, the class itself inherits from System.Web.UI.Page. This is the base page for all ASP.NET code behind files. The fully qualified name for this particular class is ObjectSharp.WebPageClass, which matches the Inherits attribute in the Page directive. There is a public method called MyButton_Click that will be invoked whenever the MyButton control on the web page is clicked.

The final item of note for this class definition are the three protected variables MyLabel, MyButton and MyTextBox. You might have noticed that they correspond, by name and type, to the three elements of the example ASPX page that have asp: as the element’s namespace qualifier. That is not a coincidence. By utilizing that asp: qualifier, a corresponding object is created in the code-behind. Then when the methods of the object are manipulated within the code-behind class, the values on the web page are modified as well.

In the example, the MyButton_Click method sets the Text property on MyLabel. As a result, the MyLabel control on the page that is sent back to the browser will have it’s text updated. This mapping is managed automatically by ASP.NET and has the effect of moving the web page development model much closer to the Windows Forms model. While you can accurately claim that as an abstraction the ASP.NET code-behind model is leaky, as a starting point for ASP.NET developers, it is nice to have a familiar base from which to build.

Last Developer Standing

bruce — Sat, 14 May 2005 15:33:00 GMT

In case you were unaware, Microsoft Canada is in the middle of running a Last Developer Standing competition. Modelled on the wildly popular (or at least, moderately watched) Last Comic Standing show on television, the idea is to give developers a series of tests. For each test, only the developers who answer the most questions correctly get to move on to the next round. What’s even better is that the final developer gets more than just good wishes…to the tune of $25,000. More information can be found at http://www.lastdeveloper.com.

So why am I mentioning this now? As part of this contest, I have been asked to blog about some of the topics that contestants will face. These posts are available on a specific feed (http://objectsharp.com/Blogs/bruce/category/104.aspx), as well as my main feed. So stay tuned for information that might very well be what you need to be the Last Developer Standing.

Licensing VSTS

bruce — Fri, 13 May 2005 04:24:00 GMT

If you're at all interested in using VSTS in your company, the announcement of the pricing for Team Systems was probably quite disturbing. More so if the number of developers on your team numbered in the single digits. Fortunately, Microsoft listened to the feedback (some might call it backlash, but that's just semantics). Here is an announcement by Rick LaPlante outlining some of the changes to Team Systems pricing. Being able to get VSTS 'Lite' (that is, for less than 5 users) will greatly increase the market for the application. And given the issues that VSTS is aiming to solve, the wider the reach of the tool, the better.

App.Config for BizTalk 2004

bruce — Thu, 21 Apr 2005 16:52:00 GMT

As part of a current project, I'm utilizing some standard .NET assemblies in the BizTalk mapping. Because these same assemblies can be used in other non-BizTalk applications, they utilize the app.config file to store potentially changing information. Naturally, because these assemblies and indeed pretty much all of BizTalk run out of the Global Assembly Cache, the location for the app.config file becomes a little challenging to determine. While there are a number of potential solutions for where the information can be stored, I found that the simplest is to place the config information in to the BizTalk server config file. This file is called BTSNTSvc.exe.config and can be found in the installation directory for BizTalk. Also, if you're going to make a change to this file, you need to stop and restart the BizTalk services to get it picked up.

Ready to Go Live

bruce — Mon, 18 Apr 2005 01:45:00 GMT

One of the reasons that I've been eagerly awaiting Beta 2 is the Go Live license. This means that I'll be moving bits and pieces of the ObjectSharp web site to Whidbey over the next few weeks. It gives us ObjectSharpees a chance to see what, if any, problems are encountered when creating, testing and deploying in the real world. While our site is not nearly as complicated or demanding as some of the projects that we have under our belt, there is always something that is not quite what we anticipated.

For those of you who might be worried about the dangers associated with putting a Beta product into production, consider this post from Scott Guthrie describing some of the stress testing that must be endured before the beta version got released. If that doesn't give you some sense of security that the beta is worth working with, nothing will.

Installing Beta 2

bruce — Mon, 18 Apr 2005 01:30:00 GMT

I just finished installing Beta 2 of Whidbey. For the most part, it went pretty smoothly.

I initially started with a VPC image that had the February CTP installed. I tried to uninstall the bits using the technique suggested on the download page. Didn't work for me. To be fair, I didn't uninstall in the same order that they listed. I just started at the top of the Add/Remove Programs list and went down. I was unable to uninstall any of the SQL Server Express pieces. The uninstall threw up a fatal error during installation message box.

Since it was just a VPC image and I was in a hurry ;), I just created a VMC image from scratch. Now the installation worked to perfection. And I have a Beta 2 version to play with. There goes the evening.

Philosophy, Debugging and Star Wars

bruce — Sun, 17 Apr 2005 14:35:00 GMT

I find it amazing how certain quotes stick with you over a much longer period of time then they probably should. Allow me to give two examples. The first is an oft-repeated phrase spoken by Yoda in the second (or fifth, depending on your numbering system) Star Wars movie: "Try not. Do or do not. There is no try'

Yeah, I know. I simultaneously dated myself and added a geek label to my business card.

The second quote is a little more professional and, unfortunately, I don't know the origin. "Debugging is the process of discovering how many invalid assumptions you made during the design and implementation of your program".

While cruising my blog roll today, I came across this post from Ted Neward that links these two apparently unrelated quotes. Nice work and something to keep in mind the next time you're faced with a challenging problem in your code.

Now featuring Go Live

bruce — Sun, 17 Apr 2005 14:16:00 GMT

In case you hadn't heard, Beta 2 is now available for download for anyone who is an MSDN subscriber. As someone who is just 20 minutes from completing, a couple of points to consider.

These are large images. I'm pulling down the Team Suite and it lists at 3.6 GB.
There is a list of the pre-beta 2 components (from beta 1 or the CTP) that need to be removed from your system before installation.
Did I mention that it's large. Which means long download times. Mine seems to be coming in at around 15 hours overnight. So don't be holding your breath after clicking "Download"

Enjoy playing with the pieces and try not to blow all of Sunday. Although, if you haven't started the download yet, the weekend is already safe.

Creating Your Own EDI Schema in BizTalk - Part II

bruce — Wed, 06 Apr 2005 18:56:00 GMT

See. I told you.

Actually, this was an error of my own making. The error that appeared on building the schema project was

Error in inserting document definition: Error = [Microsoft][ODBC SQL Server Driver][SQL Server]Violation of PRIMARY KEY constraint 'PK__codset__2D27B809'. Cannot insert duplicate key in object 'codset'

A similar error was displayed for the segcon and elmnts tables as well.

The problem was that I had badly defined the EDI schema. The schema I built had two N1Loops (that is a loop that contained N1, N3, N4 and G61 segments). The second loop also contained one more segment, meaning that I couldn't reuse the loop. But, in a moment of boneheadedness, I created duplicate definitions for the N1, N3, N4 and G62 segments. The result was an error such as the one shown above. The solution is to rename the duplicated segments (say N1_2) while (and this is important) keeping the tag_name attributed of the recordInfo tag at N1.

One thing I will say is that the message that appears is completely useless for identifying the duplicated elements. To see what went wrong, I modified the table definition for segcon, sgmnts, codset and elmnts to get rid of the primary key violation message. Then a build would work to success. Once the build was complete, I used the following statement to see the duplicated records.

SELECT fc, envr, code, COUNT(*) from codset GROUP BY fc, envr, code ORDER BY COUNT(*) DESC

Any row with count greater than 1 would cause the violation exception. The envr value contains the segment that is duplicated.

004010204_004010_DEFAULT_X_<G6101>

means that the G61 segment is being duplicated. Realize that if G61 is duplicated, then you will also seen records for G6102, G6103, etc.

Once I had solved all of my duplication issues, I needed to rebuild the database schema. For me, I only had a couple of schemas, so it was no problem for me to rebuild. I deleted all of the tables and rebuilt the table structure using the Edi.sql script found in c:\Program Files\Microsoft BizTalk Server 2004\EDI\Adapter\bin\config. If you have already compiled a number of schemas and don't want to go through it again, make a backup of the BizTalkEdiDb database before removing the primary keys and perform a restore when all of the problems have been addressed.

Metro Toronto User Group - Taking Charge of VS.NET

bruce — Wed, 06 Apr 2005 18:55:00 GMT

I know that it's late notice, but I'm actually a last minute replacement. I'm going to be speaking at the Metro Toronto User Group meeting this evening. To keep as many people happy as possible, I'm going to keep the same topic with a bit of a twist. The original topic, which is Taking Charge of the VS.NET IDE, included some demonstrations of automatic data binding using a custom built framework. Since I don't have such a framework at hand, I'm going to fall back on a bird of a feather trick used by my colleagues Dave Lloyd and Barry Gervin. I'll be talking about macros and the extensibility framework, sure. But then I'm going to break into a collection of tips and tricks that can help make the IDE more useful. I'll be looking to the audience members to kick in their own favorites as well. So if you're planning on being there this evening, bring your faves and be ready to share.

Architect's Breakfast - Enterprise Integration Patterns - Kitchener, April 6

bruce — Tue, 05 Apr 2005 15:42:00 GMT

In case you happen to be in the area and haven't heard about it by now, I'm going to be doing another Architect's Breakfast session at the Sheraton Four Points starting at 7:30 on April 6. The topic is Enterprise Integration Patterns and I'm going to be talking about how to apply patterns and message to solve some common integration issues. If you want more details or would like to register, check out the official invitation here.

Did I mention that breakfast will be served?

Creating your own EDI Schema for BizTalk - Part I

bruce — Tue, 05 Apr 2005 15:17:00 GMT

First off, you'll notice that the title of this blog includes Part 1. I don't have any other parts...yet. But from what I've seen so far in terms of paucity of documentation and general gotchas, I fully expect there to be.

So I'm create an EDI schema for a 204 transaction. Not a very large transaction, so it figures to be relatively easy to put together. As it turns out, there are a couple of loops within the transaction. Since the 204 transaction is a load tender, there is a header/detail relationship between some of the segments. So after create the header segments, I define an element called DetailLoop. Then, further down in the schema, I define DetailLoop as containing, among other segments, an S5 segment.

Once the schema has been built, I build the project that contains it. A build error is generated. Specifically, the error is:

Segment name [DetailLoop] does not start with value of tag [S5]

The problem is that the EDI schema validator gives more weight to the loop name than I originally thought. It is expecting that the name of the loop start with the name of the first tag in the loop. In other words, when I changed the name of the loop from DetailLoop to S5Loop, the error went away.

Authenticating senders and recievers in BizTalk

bruce — Mon, 04 Apr 2005 15:32:00 GMT

Once more back into the EDI/BizTalk breach.

While testing an BizTalk EDI-document orchestration that I created, I ran into a couple of problem. Specifically, an EDI document was rejected because BizTalk was unable to authorize the sender and receiver. The specific error message (as found in the Event Log) was “The recipient of the document is not recognized” or “The sender of the document is not recognized“. The documentation on exactly what is being done here is sparse, so let me describe what BizTalk is looking for. To start with, consider the following fist couple of lines in the EDI document. These lines are before the transactions contained within the document and are used by EDI subsystem authenticate and route the document.

ISA*00* *00* *ZZ*CONTOSO *12*4162164603 *050328*0852*U*00401*000004393*0*P*>
GS*OW*9055551212*5198581234*20050331*1052*3733*X*004010

When an EDI document is received through the pipeline, the subsystem opens the document to find the send. In the above code, the sender is indicated by the 'ZZ' and 'CONTOSO' blocks in the first line. As well, the sender id is found in the third field ('9055551212') in the second like. These data are combined to form a party identifier. The party identifier looks like EDI://CONTOSO:ZZ:9055551212. Once the identifier is created, the EDI Subsystem examines the list of Parties to find the sender. If not found, then an entry is put into the event log saying that the sender could not be authenticated.

The second part of the authentication process is to authenticate the receiver. The identifier for the receiver is constructed in a similar manner. For the above example, the recipient party identifier is EDI://4162164603:12:5198581234. The information used to create this come from the first line (segments 6 and 7) and the second line (segment 4). Not only does the EDI Subsystem look for the sender party identifier in the Parties list, but also the recipient party identifier.

What this means is that in order for the EDI Subsystem to accept an EDI document, both the sender and recipient need to be defined as a Party. To do this, open up the BizTalk Explorer, expand the view to reveal the Parties node. Right click on Parties and select Add Party. In the dialog box that appears, give a reasonable name for the party. In the Properties list that appears, add a property called EDI, with a Qualifier of EDI and a Value of the sending party identifier (for our example, EDI://CONTOSO:ZZ:9055551212). Save this new party. Make sure that a second party is created using the receiving party identifier. With this combination of parties, the incoming EDI documents can be correctly authenticated and fed in to the processing pipeline.

New Article - Optimizing the Downloading of Large Files in ASP.NET

bruce — Mon, 04 Apr 2005 14:35:00 GMT

Just to let everyone know, I have posted a new article on techniques that can be used to optimize the downloading of large files in ASP.NET. It discusses some of the architectural issues that impact download speed if you need to push multi-megabyte files to a browser client. If you're interested, you can find it here. As always, comments and suggestions are appreciated.

XSD2EDI Failure locks the repository

bruce — Wed, 30 Mar 2005 16:51:00 GMT

As a result of the problems that I described in my last post, I ran into another little documented (there seem to be a number of these surrounding EDI and BizTalk) problem. When I rebooted my system after the Validate Schema process hung my system, I immediately tried to run it again (by definition, insanity is trying the same thing over and over, expecting a different result, isn't it?). This type around I got an error message saying that my respository was locked. Specifically (and for Google), the message is:

Schema validation failed: Repository was locked on host [hostname] by process [xsd2edi], processid [nnn]

Sympton: Build output:
XSD2EDI failed to convert XSD: Can't lock repository because it is already locked

It turns out that the correction for this is quite simple. In the BizTalkEDIDb, there is a table called parame. This table contains a single record (at least, that's what it has on my system). One of the first in this table is called repolock. In that field is the name of the host, process and process id that is updating (I assume) the repository. It is set by XSD2EDI and, naturally, the information survives a system crash and restart. To unlock your respository and be able to validate your schemas again, set the value of repolock to null using your favorite method.

BizTalk EDI and Virtual PC

bruce — Wed, 30 Mar 2005 16:42:00 GMT

As you might have figured out (from my recent posts), I'm working on a BizTalk project. Specifically, I've been dealing with the joys of trying to get the base EDI adapter working the way that I want/expect. Yesterday, it was trying to get the 850 Schema validated. There are two items that I want to mention that got in my way.

First, because of all the different software I try out, I'm a firm believer and user of Virtual PC. So the BizTalk I'm using is installed on a VPC running 2K3. The system on which it's running has 1GB of RAM, around 650MB are allocated to the VPC.

So back to the story. In the BizTalk project in VS.NET, you right click on a schema and select Validate Schema. This basically runs the XSL2EDI.exe process to validate the schema and convert it into the BizTalkEDIDb tables. On my system, I was finding that running this process would freeze my machine after about 10 minutes of running. And by 'freeze', I don't just mean the VPC. My entire system would seize up, requiring a hard reboot to get started again. After having this happen a couple of times, I looked at what might be the cause.

Turns out that the project in which the schema I was validating still had an orchestration running. Once I stopped the orchestration, the freezing problem seems to be solved. Or, to put it a slightly more pragmatic way, it hasn't happened since and I've validated more than one schema since then. It's only empirical evidence, but it's all that I have.

XSD2EDI Failed to convert XSD

bruce — Tue, 29 Mar 2005 14:30:00 GMT

I've been spending some time on BizTalk Server 2004 these past few weeks. And for the next few, just so that you know the source of future posts. I've run into this situation a couple of times, so I'm posting as much as a reminder to me as for any other reason.

My current project has me working EDI (after a seven or eight year absense) integration with an existing application. As a result, I get the chance to work with BizTalk's EDI Adapter. From a configuration perspective, it's quite simple to get set up, but I was receiving a strange error on my build.

XSD2EDI: Failed to convert XSD: Compiling repository failed

According to a support article (http://support.microsoft.com/?kbid=883549), this is caused by an authentication issue with the BizTalk Base EDI Service. But, in my case, that wasn't the problem. Instead, what appears to be happening is that this server, even though it is marked as being Automatic, wasn't starting. The first time I saw this error, the service actually Disabled, so you need to address that particular issue. But even after that, I would still see the error the next time I rebooted the server. Nothing in the event log to indicate a problem, so at the moment I'm both puzzled and looking for clues. I'll keep you posted if I find something.

Using C# in BAT files

bruce — Fri, 25 Mar 2005 16:25:00 GMT

Personally, writing BAT files has never been my thing. And with the experience I have in C#, the ability to script and automate in that language would be quite useful. Thanks to this post from Jason Clark, I now have the ability to run C# (and for the VBers among you, VB.NET) as part of a BAT file. Incredibly cool.

The floodgates are...well...beginning to open

bruce — Wed, 16 Mar 2005 14:30:00 GMT

From a couple of different sources, I'm seeing that the first set of documentation for Indigo is now available at http://winfx.msdn.microsoft.com. And, as Andy Milligan suggests, the implication is that the bits for Indigo can't be far behind. Personally, my mouse is poised over the MSDN download page. The rest of you probably have a life. ;)

VB6 Support Coming to an End

bruce — Mon, 07 Mar 2005 22:39:00 GMT

Courtesy of Julia Lerman, I am reminded that mainstream support for VB6 comes to an end on March 31. Now contrast that fact with the results of a survey that found over 50% of shops are still using VB6, a fact I blogged about here. Does anyone else see a problem with this picture?

The problem of telling people who are currently running VB6 why they might want to move their applications has been at the front of my brain for a little while. The biggest roadblock is that there really is no direct compelling reason. Put it to you this way. You have an application currently working in VB6. It took a couple of man years to build, but everyone is comfortable with it. Both your developers and users can use and extend it as they need to.

Along comes someone saying that the company needs to convert to VB.NET. This is a working application, not a broken one. There is a cost to doing the conversion, not just in the effort, but in the efficiency of the development team. As someone who made the move from VB6 to VB.NET about 4 years ago, I can tell you I was quite frustrated by how much my productivity dropped for the first few weeks (or months). And what does the company get on the other side? An application that (hopefully) works. Not really the ROI that one would hope for.

The problem is that the benefit to moving to the .NET platform comes about in the future. A well designed .NET application is much easier to extend. Using widely accepted software design processes (like unit testing and FXCop) are more easily accomplished using .NET. Meaning that the quality of the software produced increases. So over the life of an application, the company will definitely make back its investment. Or, more accurately, is quite likely to make it back. But the argument is a difficult one to make to an executive with their eye on the financials of a company. Invest potentially tens and hundreds of thousands of dollars for what return?

I'm still thinking about how to crack this nut. Any suggestions that you have or stories that you've run into would be helpful, so feel free to send them on. And I'm sure I'll come back to this in a later post.

Why Penquins are No Longer at the North Pole

bruce — Thu, 03 Mar 2005 16:31:00 GMT

Courtesy of Hippopotoman, this is pecisely why picture == words * 1000. No question this will be my biggest laugh of the day.

http://today.java.net/jag/page14.html#113

Sending Mail through SMTP with Authentication

bruce — Thu, 03 Mar 2005 15:35:00 GMT

If you have looked at the process of sending emails from within .NET, odds are pretty good that you have stumbled across the SmtpServer class. To send email, you create a MailMessage object, assign the necessary properties and then use the Send method on SmtpServer. The SmtpServer class can be pointed to any mail server that you would like.

MailMessage message = new MailMessage();

message.From = "bjohnson@objectsharp.com";
message.To = "who@ever.com";
message.Subject = "Testing";
message.Body = "This is a test";

SmtpServer.Server = "mail.server.com";
SmtpServer.Send(message);

So all is well and good right? Well maybe not so much. What happens if your email server, like all good servers, doesn't allow relays. Instead, it requires that a user id and password be provided. What I found strange is that the SmtpServer class doesn't include properties like UserId or Password to handle the authentication. So how is this accomplished.

The answer is to utilize a newly added feature(new to .NET 1.1, that is). The MailMessage class has a Fields collection. The necessary authentication information gets added to the fields in the message that is being sent out. Certainly not where I expected it to be, but smarter people than I designed the class, so I'm sure there was a reason for this approach. Regardless, it's knowledge that needs to be easily Googlable, hence the post. An example of the code that adds the three fields follows.

message.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate",
   "1"); //basic authentication
message.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername",
   "userid"); //set your username here
message.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword",
   "password"); //set your password here

Anticipation

bruce — Thu, 03 Mar 2005 15:17:00 GMT

Now here is news that I have been waiting to hear. Whidbey Beta 2 will probably be released in the next couple of days. For me, this is very cool news, as I have been looking forward to getting the Go Live license. For more information, check out Wesner Moise's blog entry here.

Pure Math III - The SHA Also Rises

bruce — Thu, 24 Feb 2005 22:34:00 GMT

While perusing SlashDot, I came across an entry saying that the SHA-1 hashing algorithm has been broken. If you have any familiarity with cryptography, you'll realize just what this means. After all, SHA-1 is at the heart of SSL, digital signature and (wait for it) strongly named .NET assemblies. So does this signify the end of days? Total anarchy? Cats and dogs living together?

Not so much. From a practical perspective, what has really happened is that brute force is no longer the best way to find a string that will hash to a given value. Consider for a moment what the job of a hashing algorithm is: to take a given string of arbitrary length and convert it to another string of a specified length (160 bits for SHA-1). The properties of the hash are that there should be close to a one-to-one correspondence between the initial string and the hashed string. It should also not be possible to regenerate the original string given only the hash.

Of course, complete one-to-oneness is impossible. There are more strings of arbitrary length then there are of a specified length. When two strings hash to the same value, it is called a collision. And it means that when either of those strings are used, for example, as part of a digital signature, the results will be the same. If it were easy to go from a hashed value to any string that would generate the hash, the algorithm would be poor.

For a few years, it was believed that the best way to find the collision for a given hash was brute force. That is, randomly generate strings until a collision was found. What it means to say that SHA-1 is broken is that brute force is no longer the fastest way to a collision. The researchers have described a technique that reduces the effort by a factor of 2000. Now that means that instead of 2⁸⁰ calculations, only 2⁶⁹ are required. Still not a meager number, but quite a breakthrough.

A more complete description of the implications can be found here.

Getting ahead of the Whidbey Curve

bruce — Wed, 23 Feb 2005 22:25:00 GMT

It is likely that, given the relative proximity of the release of Whidbey and Yukon, you will be inundated with information about these tools/products in the next six months. And it's already started. ObjectSharp (in conjunction with Microsoft) is in the midst of giving a series of week-long training sessions on Whidbey and Yukon. If you haven't signed up already, it's actually too late. The last two sessions (Calgary and Montreal) are already sold out.

But that's not all. As well as the Whidbey/Yukon talk, ObjectSharp (again, in conjunction with Microsoft) is presenting a series of day-long, hands-on workshops on Visual Studio Team Systems (at a cost of $299). Five cities (Montreal, Vancouver, Calgary, Ottawa and Toronto), two seminars (with a good chance for a third) each. You heard that right. Hands-on. Right in your backyard. Believe me when I say that VSTS is one of the cooler parts of the next wave of products. Now you get a chance to try it out, first hand. Interested? Click here. If you do it now, you'll actually be ahead of the crowd. This series has just been officially unveiled, so not even the masses have heard about it. And you though there was no real benefit to subscribing to this blog. ;)

Montreal .NET Architecture User Group

bruce — Mon, 21 Feb 2005 14:53:00 GMT

I get the opportunity to travel to Montreal to speak to the GUMSNET study group tomorrow. The topic under consideration will be Windows Services. I'll be making a brief presentation, showing some code and answering any and all questions that I can. I'm looking forward to going to Montreal, as it has been over 15 years since I was last in one of the nicest cities in North America. I won't get more than a half-day to look around, but since the meeting is at McGill University, at least it's close to the downtown area, which is where I'll be hanging up to show time.

And, in case you were wondering, the presentation is in English. My French is such that my 7-year old son who is in French-immersion is beginning to surpass my quite limited vocabulary.

The cost of no hockey season

bruce — Fri, 18 Feb 2005 21:32:00 GMT

This is a (for me) rare trip outside of the realm of technology in my blog. So if that's what you're hear for, feel free to skip to the next entry.

For those of you still with me, how about $1 billion. That's a 1 followed 9 zeros. More than chump change, even BillG. And yet, that's roughly what the NHL players will *not* be paid this year. Check out Mark Cubans blog (always a fascinating look into the business of sports) for the rationale and why he puts Bob Goodenow into rare company.

Putting it into Perspective

bruce — Thu, 17 Feb 2005 00:56:00 GMT

One of the dangers of being a consultant, especially one who focuses on cutting edge technology, is that it's easy to get wrapped up in a small, insular world. In my case, that would be .NET. And at this moment in particular, Whidbey, Yukon and Indigo. Why is this a problem? Because sometimes it blinds you to the problems that the majority of the programming world is working on. To get a look at the world from the perspective of the 'masses', check out the results of this survey (thanks to Dino Esposito for the link).

One of the more interesting points is that almost 50% of the respondees come from 1-2 person shops. Because I don't know the methodology behind the survey, I am suspicious of the accuracy of the percentages. However even allowing for a large margin of error, I find that percentage significant. And I have no doubt that you will have to pry VB6 (if I can borrow a phrase) from their cold, dead fingers. After all, small shops like that don't normally have the luxury of fooling around with new technology. There is too much real work to be done.

That having been said, I have seen many times how great an improvement in developer productivity can be obtained through the proper use of the .NET Framework. And these small shops would probably benefit the most from the productivity gains, if they can just be pushed to the top of the learning curve. My question is: what is the best way to introduce these people, who are already hugely productive in their tool set, to the benefits of .NET? Any suggestions out there, because I'm certainly open to them.

Getting your Message Across

bruce — Mon, 14 Feb 2005 18:04:00 GMT

For those of you who have ever had to deal with the 'how to get your message across' part of every presentation's creation process. Enjoy (thanks to Chris Sells)

http://www.theonion.com/news/index.php?issue=4106&n=3

Why I write

bruce — Sun, 13 Feb 2005 19:12:00 GMT

Just came across (via Kent Sharkey and Gina Smith) a quote that very accurately describes the path that I took to get to where I am right now with my writing.

"Writing is like prostitution. First you do it for love, and then for a few other close friends, and then for money." Moliere

Only a little bit for the money, at this point. But there's always hope ;)

Getting Something for Nothing - Almost

bruce — Sun, 13 Feb 2005 19:03:00 GMT

It's not often that you can get something for nothing. And this case is no exception. But when you realize what you do get, it's still a very, very good deal.

The offer is basically as follows: buy some Microsoft Office Licenses, get a check towards to cost of developing software that utilizes the Office application set. If this sounds lame to you, then you probably aren't aware of all of the development tools that are available for Office. Nor all of the uses to which it can be put.

For example, we have one client that uses InfoPath as one of the interfaces into a workflow application. Users enter data through an InfoPath form. The data is transformed into an XML document which is then submitted to the workflow through a web service. And that is just one application. The Visual Studio Tools for Office (VSTO) toolkit is surprisingly powerful. If your user base is familiar with Office, then the ability to extend Word and Excel to interact with your corporate applications can be quite compelling.

If you want to talk to someone about the possibilities, feel free to drop me a line at bjohnson@objectsharp.com.

Changing Gears

bruce — Sun, 13 Feb 2005 14:14:00 GMT

First off, I apologise for my relative dearth of recent posts. At the end of January, I finished off a fairly long contract. And, as yet, I haven't started onto anything new. Actually, it has been a nice break for me, but for my blog? Not so much.

Whether you realize it or not, I use the current project that I'm working on as fodder for many of my posts. The goal of most of my posts is to describe a situation that I have run into, one that I hope is a relatively common one. For that, I need situations. No current project, then the bloggable situations are much fewer.

What I have been spending my time on is getting back into ASP.NET. And what I apparently blocked out of my mind is some of the annoyances associated with data binding on web pages. Especially the two-way binding necessary to allow web pages to show and update data. I'm very much looking forward to the improvements in this process that will be forthcoming with Whidbey.

Seems like maps are the next big thing

bruce — Wed, 09 Feb 2005 16:55:00 GMT

First there is Google Maps, a masterful example of the power of client-side scripting.

And today, I find out about Blogmaps

How could I resist?

So it has started - the auction for Aceh Aid, that is

bruce — Sun, 23 Jan 2005 14:27:00 GMT

The 10-day eBay auction for 30 world-famous .NET developers got under way less than half-an-hour ago. Check out the auction at http://cgi.ebay.com/ws/eBayISAPI.dll?ViewItem&item=5552696499

Standards at the speed of thought

bruce — Fri, 21 Jan 2005 14:56:00 GMT

I've had to deal with comment spam in the ObjectSharp blogs over the past few days. Through a search of Google, found a simple, trigger-based solution for .Text (the engine that we use) that I suspect will deal with the majority of the spam that was coming through. But, as explained in this post, Google is modifying their ranking engine to pay attention to a newly created attribute on the anchor tag that will basically mitigate the benefit of comment spam, that being to artificially raise the Google rank for the offending links. What impressed me is the speed with which this innovation was implemented, not only by Google but by the list of blog hosts and competitive search engines at MSN and Yahoo. Whoa. Would that other standards could work that way.

Upcoming Architect's Breakfast

bruce — Thu, 20 Jan 2005 16:56:00 GMT

ObjectSharp has been doing a bimonthly Architect's Breakfast seminar for about 6 months now. The idea was to provide architects information on enterprise level topics without impacting significantly on their normal daily routine. It has been quite a success. Enough so that we're making a couple of changes. First, the Toronto sessions will now be monthly. Second, we are introducing a bimonthly seminar in the Kitchener/Waterloo/Cambridge area.

If you are interested, this month’s topic is Business Intelligence and SQL Reporting Services. You can find all the details here:

Toronto: http://www.objectsharp.com/TTDInvitation/BusInt_invite.htm

Kitchener: http://www.objectsharp.com/TTDInvitation/BusInt_inviteKW.htm

Grabbing the contents of your clipboard

bruce — Thu, 20 Jan 2005 14:17:00 GMT

Want to see something that's a little freaky? Check out this post. Apparently you can grab the current contents of a user's clipboard through Javascript running in a browser. While this probably isn't as much a security issue as some might think (after all, there really is no context for the data that is retrieved), it is interesting that it's even possible. Thanks to Blair for the heads up.

I know a celebrity!!!

bruce — Thu, 20 Jan 2005 03:16:00 GMT

One of my colleagues, Barry Gervin, is part of a wonderfully generous effort to raise money for Aceh Aid at IDEP. Twenty-four of the best and brightest of the .NET community are each donating an hour of their time to be put up for auction on eBay. Julia Lerman has more details here. Keep an eye out for the auction and please bid generously. You know the hour of any of these consultant's time is worth it. And you're money does good in an area that desparately needs it. Nice combination, isn't it.

Generating Passion in your Life

bruce — Wed, 19 Jan 2005 18:50:00 GMT

Found another interesting blog entry on passion by Kathy Sierra on generating passion. And we're talking about passion for technology and life, not that other thing. Too much of that other thing resulted in the four kids that currently occupy much of my non-working hours.

The basic premise is that people tend to emulate those around you. Hang with complainers and you will (subtly, perhaps) become one). Hang with people who love what they do, and you will too. Interesting that I've actually seen happen.

My wife, Alisa, is a real estate agent. She has been doing fine, but this past November she had a chance to go to a conference which, as it turns out, contained a high percentage of very successful agents. And by successful, I'm talking $500K per year and up in commissions. On her return, the level of enthusiasm for her profession was visibly higher. Not only that, it carried over into the the rest of her endeavors. She is well on the way to doubling last year's sales. And possibly tripling it. All because she spent some time hanging with passionate people.

As you look towards the rest of the year, there are a number of opportunities for you to do the same thing. VSLive has conferences all over the world. There is TechEd coming in June and a Professional Developer's Conference. Attending and hanging out with people who love what they do might do as much for you as the technical content.

Using Apostrophe's

bruce — Wed, 12 Jan 2005 14:49:00 GMT

One of my pet peeves is the misuse of apostrophes. I find myself particularly annoyed by the misuse of you're and your, but any badness feels like teeth on tin foil to me. Not that I'm perfect, but...well...I'm sure some of you understand. Anyway, courtesy of Blair Conrad, I found the following cartoon quite amusing. Your mileage may vary

P.S. The title was on purpose.

Nerd Score

bruce — Fri, 07 Jan 2005 22:20:00 GMT

Just because there's nothing better to do after five on a Friday.

Should DSL use UML

bruce — Wed, 05 Jan 2005 20:27:00 GMT

I have been quietly following the ongoing conversations regarding Domain Specific Languages (DSL) and whether UML should be used as the mechanism to describe them. My UML and DSL knowledge is not nearly as deep as some of my colleagues, but I believe that the noise level from this space will only increase over the next 12-18 months.

As part of my blog reading (via Don Box), I came across a number of postings from Grady Booch and Alan Cameron Wills talking about both sides of the issue. But to me, the most interesting part was actually in one of the comments to Alan's post. Specifically, Lloyd Fischer says:

Anyway, we spent a lot of time thinking about visual representations of software. It turned out that the times we were successful was when the system in question *already* had a visual representaion. Examples are piping and instrumentation diagrams, electronic schematic diagrams, ladder logic diagrams, etc.

In those cases where we tried to create new visual representations we failed. The "business users" invariably rejected our attempts to turn their knowledge into diagrams because they were unnatural to experts in the field. The fact that they had not yet created such diagrams was a telling sign that no such representation was possible. Those fields where such representations were useful had long ago created them.

That is probably the best argument in favor of using something *other* than UML to describe DSLs that I have heard. That UML (or diagrams, in their world) doesn't fit with the mental model that the domain experts already have is very telling. After all, the experts aren't constrained by anything when it comes to describing their world outside the realm of software. They have white board, diagramming tools, everying that a designer would need. If that was the way they wanted to go, they'd already be there. And yet they're not. I think this is one case where we need to listen to the experts and find a way to represent the mental model that they have spent years developing. Seems more productive than forcing our way upon them.

Maybe I'm just cynical, but...

bruce — Tue, 04 Jan 2005 22:08:00 GMT

Through Dare Obasanjo's blog, I was pointed to a 'conversation' between Adam Bosworth of Google and Krzysztof Kowalczyk about the open source contributions. It all started when Adam 'asked' the open source community to fix a problem with commercial databases for those customers who need to maintain high availability and scalability across large clusters. Krzysztof (and others) suggested that Adam was trying to get the open source community to play tooth fairy.

Although at first blush, it certainly sounds like having the suggestion implemented would greatly ease Google's ongoing operational effort, in a follow-up post Adam says that he wasn't asking for Google, that Google already has what it needs for storage and indexing. He then goes on to scold the critics of his posts, saying that they don't appreciate what Google gives our for free millions of times a day.

I have two issues with Adam's comments. First, if Google has already solved this problem, why have no contributions to the open source community along this effort been forthcoming. While it might not have addressed the dynamic partitioning and schema changes (it's possible), odds are pretty good that Google has an idea about indexing. They would certainly be able to kick start the effort by making a contribution in those areas.

My second issue is the dis-ingenuousness of the “we're giving stuff away for free” comment. Google has a market cap of $53B. Revenues are approaching $3B per year. Some of that revenue comes from sponsored searches, AdWords, AdSense and a number of other products that need the traffic generated by their free service. Which is to say that if Google stopped giving stuff away, their revenues would fall off pretty quickly.

Do I love what Google offers? Of course. Makes my life much easier in many different ways. But please don't pretend that it's being given away for altruistic reasons. I'm really not that naive.

The True Joy of Blog Reading

bruce — Tue, 04 Jan 2005 05:13:00 GMT

I've been a voracious reader since I was a young boy. My current life means that I don't get to read as much as I would like, but I still get a thrill when I find a new author that I like. Especially one that has a whole bunch of books written. Dan Brown's The De Vinci Code was one such author, as it was really the fourth book that he had written. Gave me another couple of months worth of books.

When I get the time, I like to do the same thing with blogs. Follow blog roles, links, etc. to see what other people talk about. I had one of those author epiphanies earlier today with Kathy Sierra. In particular, I started with Users shouldn't think about YOU. That post contains some nice insights into how instructors and authors get in the way of the learning process. It certainly gave me something to think about.

And, of course, I started reading some of the other posts that Kathy has written. Very nice. Like the content, like the style. Consider me subscribed. And happy that I'll have some late night reading for a couple of days.

Caching and Unit Tests

bruce — Fri, 17 Dec 2004 18:40:00 GMT

We've been playing with the Caching Application Block here at the client I'm currently working with and have found a couple of important items that will be of interest to anyone doing the same. I should say that we're using NUnit to run our unit tests, so some of the information applies specifically to that.

Actually, both of the items we ran into had to do with the storage mechanism that we used. The Caching Application Block includes implementations for three separate modes: in process, memory-mapped files and SQL Server. These three modes basically mirror the functionality available with the Cache object in ASP.NET.

For all of the tests run to this point in the project, we had been using the in-process mode both in our unit tests and in the builds that have been sent to the system verification team. However we recently made the choice to share the caching across web services, so we switched to the memory-mapped file mode.

Oops.

First off (and it should have been obvious), there is a different serialization technique used with memory-mapped files. That is to say, that the in-process cache doesn't use serialization at all. The memory-mapped version does serialize and deserialize the object as part of the default processing. This change in caching mechanism should have caused us to go back to our unit tests, updating the storage type used there. A couple of issues might very well have been exposed. But after just a couple of minutes of seeing unexpected errors occur in unusual places, we did just that.

Second oops.

If you didn't realize it, NUnit depends a great deal on the AppDomain model to work its magic. This allows things like the config file to be taken from the DLL's home directory. A completely new AppDomain is created for each run of the tests. So, as a for instance, you had created an in-process cache in one test, that cache wouldn't be there the next time the test was run. New AppDomain = new memory = no old variables.

But what if you were to change the storage mechanism to a memory mapped file. A mechanism that is specifically designed to share data across AppDomains. So now, NUnit does its AppDomain creation thing and pow! Cached value already exists. Imagine our surprise. Imagine how good you feel not having to go through it.

As a pointer, using the Flush method in the TestSetup section of NUnit is a good way to avoid this problem in the future. Just something for you to consider.

Pure Math and Real Life II

bruce — Wed, 15 Dec 2004 16:05:00 GMT

From Raymond Chen's blog, check out this article that describes not only the concepts (in basic terms) behind the uniformly distributed points algorithm, but also some of the practical applications. First of all, the idea behind the algorithm is incredibly elegant. Forgetting about the math necessary to prove that it works for a moment (because that is complex to the extreme), the idea that the points on the surface are like dictators fighting for space is an easy one to visualize.

Second, the number of applications for what might appear at first glance to be nothing but nonsense will surprise most. That the same algorithm could be applied to everything from baked goods (the perfect poppy-seed bagel) to virus research to computer generated graphics says a lot about how math is the thread the weaves its way through the fabrice of our life.

Finally, for those you are continually amazed at the interconnectedness of the universe, that the most effective 's' variable (the power of the force between the poinst) is equal to the dimensionality of the shape is mind boggling. I just add this to the “famous five” equation as one of those things that make me go hmmm.

For those who care and don't already know, the famous five equation takes the five most basic values in math (e, i, pi, 1, 0) and combines them to create a single equation: e^{i * pi} + 1 = 0. Whoa.

Waiting for WinFS? Might want to rethink that.

bruce — Sat, 11 Dec 2004 16:06:00 GMT

For those of you who already have grand plans that require the very cool functionality that will be offered by WinFS, you might want to think about some redesign. Finding out that it wouldn't make it into Longhorn was the first blow. Now, according to this news.com article (found thanks to Rocky Lhotka), the wait for WinFS might last until the next decade.

The article confirms that not only will WinFS miss Longhorn client, but also the (scheduled) release in 2007 of Longhorn server. So now WinFS won't likely be included until Blackcomb, which is the next Windows version after Longhorn. Realistically, this means 2010 at a minimum. And that assumes a minimal slippage of schedule, an outcome that is probably one of the few that can be counted on.

One of the downsides of being involved with the leading edge of technology is the teasing that goes on. The promise of ObjectSpaces is certainly enticing. But I spend most of my life coding in the here and now, a place that ObjectSpaces won't be invading for quite some time. Too bad, but I'm pretty certain I can make the adjustment. ;)

Things C# allows you to do, but shouldn't

bruce — Thu, 09 Dec 2004 20:05:00 GMT

So the offending line of code is as follows:

string a = String.Empty, b;

If you can explain what this is doing, you're a better person than I. Just to give you a second hint, the following is also legal syntax.

string a = b, c = d, e = f;

So what do these statements do? Give up?

In the first case, you end up declaring two string variables: a and b. And a is initilized to String.Empty. In the second case, you end up with string variables a, c and e initialized to b, d and f respectively. Sure having multiple declarations on a single line is legal. But should you inflict this upon unsuspecting maintenance developers? I don't think so.

The Memory Reclamation Phase

bruce — Thu, 09 Dec 2004 18:14:00 GMT

The project that I have been working on for the past few months has now entered it's performance tuning phase. This means that code is being gone over in great detail, looking for areas where speed gains can be realized. Because there is a high concentration of former C++ developers here (the project is done in C#), I have been getting a number of questions regarding the allocation and deallocation of memory. Questions like when does it happen and how can memory be reclaimed faster.

Whether you are coming from a VB or C++ background, you should be aware of the allocation and garbage collection process in .NET. For no other reason than the things you might have done for optimization in the past may very will be completely wrong. Two examples: Setting variables to null (based on the Set var = Nothing best practice in VB) and implementing finalizers (a common memory deallocation technique in C++). For an excellent description of the reasons behind not doing this (and other practices), check out http://weblogs.asp.net/ricom/archive/2003/12/02/40780.aspx. And if you feel compelled to use the GC.Collect method, read http://blogs.msdn.com/ricom/archive/2004/11/29/271829.aspx. Very useful information indeed.

The Case for Unit Testing

bruce — Thu, 09 Dec 2004 14:16:00 GMT

A posting on Roy Osherove's blog taking issue with a post by Joel Spolsky on the failure of methodologies like MSF got me thinking. In particular, I (like Roy) took issue with the following section (which is actually written by Tamir Nitzan, but agreed to by Joel).

Lastly there's MSF. The author's complaint about methodologies is that they essentially transform people into compliance monkeys. "our system isn't working" -- "but we signed all the phase exits!". Intuitively, there is SOME truth in that. Any methodology that aims to promote consistency essentially has to cater to a lowest common denominator. The concept of a "repeatable process" implies that while all people are not the same, they can all produce the same way, and should all be monitored similarly. For instance, in software development, we like to have people unit-test their code. However, a good, experienced developer is about 100 times less likely to write bugs that will be uncovered during unit tests than a beginner. It is therefore practically useless for the former to write these... but most methodologies would enforce that he has to, or else you don't pass some phase. At that point, he's spending say 30% of his time on something essentially useless, which demotivates him. Since he isn't motivated to develop aggressively, he'll start giving large estimates, then not doing much, and perform his 9-5 duties to the letter. Project in crisis? Well, I did my unit tests. The rough translation of his sentence is: "methodologies encourage rock stars to become compliance monkeys, and I need everyone on my team to be a rock star".

The problem I have is that the rock stars that are being discussed are not at all like that. Having had the opportunity to work with a number of very, very good developers, I found that they embrace unit tests with enthusiasm. And their rationale has little to do with the fact that they might be create a bug that needs to be exposed. While that might be part of the equation, it is not the real reason for creating a unit test.

The good developers that I've encountered are lovers of good code. They believe that well crafted code has a beauty all of its own. They strive to write elegant, performant classes because, well, that's what craftsmen do. But when put under the time constraints of business, it is not always possible to create the 'best' solution every single time. An imminent deadline might require that 'good enough' classes be checked into production. Such is the life of a paid developer.

But you and I both know these good developers are many times more productive than their 'average' conterparts. As a result, they frequently have time within a project schedule to refactor previously completed classes. In fact, they enjoy going back to those 'good enough' classes and improving on them. This attitude is one of the things I've found separates the good developers from the pack. They are actually embarrassed by some of the 'good enough' code and feel the need to make them right.

This is where the unit tests come in. If the completed classes are supported by a solid set of unit test, then this refactoring process can be done with a low risk to the project. The developers know that when a modified class passes the unit tests, it is much less likely to introduce further bugs. So, rather than thinking them a waste of time, the good developers I know relish the idea of creating unit tests. Perhaps this is one of the characteristics that the rest of us would do well to emulate.

Pack Your Bags

bruce — Wed, 08 Dec 2004 14:30:00 GMT

A couple of conference announcements over the past few days help put my travel plans for next year on more solid footing.

VSLive is coming back to Toronto from April 13-16. This time around, the conference will be held much closer to the heart of Toronto. The Westin Harbour Castle is right on the lake and an easy walk from all of the downtown attractions. Will probably make the ObjectSharp party bus less logistically challenging. Check out www.vslive.com/2005/to for more details.

I saw via Julia Lerman's blog that Microsoft has scheduled PDC 2005 to be in Los Angeles in Sept. Would rather it be some time when travelling someplace warmer would be more beneficial (like, say, the winter), but I'll take what I can get.

Improving the Performance of Asynchronous Web Service Calls

bruce — Mon, 06 Dec 2004 12:19:00 GMT

Notice that the name of this post doesn't say that web service performance can be improved through asynchronous calls. That is on purpose. This particular post deals with a limitation that impacts applications that utilize async web service methods. Actually, it has the potential to impact any application that interacts with the Internet. This is actually one time I wish my blog was more widely read, because I can pretty much guarantee that there are thousands of developers who are unaware that the nice async design they've implemented isn't having the performance boosting effect that they expected. And thanks to Marc Durand for pointing this out to me.

The limitation I'm talking about is one that is buried in the HTTP/1.1 specification (RFC2616). The spec says that, to prevent a single computer from overrunning a server, the limit to the maximum number of connections that can be made to a server is two. What this means is that if your application makes three async calls to the same server, the third call will be blocked until one of the first two is finished. I know that this came as a big surprise to me.

Fortunately, there is a configuration setting that can adjust this number without requiring any coding changes. In the app.config (or machine.config) file, add a connectionManagement tag. Within connectionManagement, the add tag is used to specify the optional server and the maximum connections allowed. The following example allows up to 10 simultaneous connections to be made to 216.221.85.164 and 40 to any server.

<configuration>
<system.net>
    <connectionManagement>
      <add address="216.221.85.164" maxconnection="10" />
      <add address="*" maxconnection="40" />
    </connectionManagement>
</system.net>
</configuration>

For those who like to program, you can accomplish the same behavior on a temporary basis using the ServicePointManager.DefaultConnectionLimit property. But I was never big into adding code when I didn't have to.

Dogs and cats, living together. Mass hysteria.

bruce — Tue, 30 Nov 2004 15:58:00 GMT

For a while now, this has been my catch phrase for situations where stuff is about to hit the fan. Thanks to a colleague, it turns out that the end really is closer than I thought.

http://tv.ksl.com/index.php?nid=5&sid=135591

For the culturally stiffled, the quote is from Ghostbusters.

Web Services and Proxy Servers

bruce — Mon, 22 Nov 2004 17:16:00 GMT

I'm currenting working with a team that is putting the finishing touches on a commercial application that uses web services as a major component of the infrastructure. As part of putting the client portion through its paces, an environment that included a proxy server was tested. The initial result was not surprising to anyone who has significant experience with web services: a connection could not be made exception was thrown. The reason for this problem is that the method for defining a proxy server to the web service proxy class on the client side is a little unexpected. And I apologize in advance for having to use the same word (proxy) to describe to separate items (the server and the web service class).

If you are running Internet Explorer, then the place where the the proxy server settings are configured is in the Tools | Internet Options dialog. Within the dialog, click on the Connections tab and the LAN Settings button. Here you can specify whether proxy server settings are required and which server and port are used. You can also identify whether local addresses are exempt from the proxy process. This is fairly well known information, especially if you normally operate from behind a proxy server.

The disconnect occurs when you make calls to web services from this same machine. Under the covers, the HttpWebRequest class is used to transmit the call to the desired server. However, even when the proxy server information has been specified as just described, those details are NOT used by HttpWebRequest. Instead, by default, no proxy is used to handle the request. This is what causes the connection exception. I know the first time I ran into this issue was a surprise to me.

There are two possible solutions to this problem. The first is to assign a WebProxy object to the Proxy property on the web service proxy class. You can programmatically specify the proxy server information, but that is very difficult to modify. Instead of creating the WebProxy object on the fly, use the GetDefaultProxy static method on the System.Net.WebProxy object. This method reads “the nondynamic proxy settings stored by Internet Explorer 5.5” and returns them as a WebProxy object that can be assigned to the Proxy property . This technique works fine assuming that your client has IE installed and that none of the scripts run at login time have modified the proxy settings.

There is an alternative that is a little more flexible. There is a app.config element called defaultProxy that is part of the System.Net configuration section. Within this element, the details of the proxy server can be specified independently of the IE settings. The basic format of the defaultProxy element can be seen below.

<system.net>
   <defaultProxy>
      <proxy
         proxyaddress = "http://proxyserver:80"
         bypassonlocal = "true"
      />
   </defaultProxy>
</system.net>

The proxy element also includes an attribute called usesystemdefault which, when set to true, causes the IE settings to be used. The benefit of this approach is that no additional coding is required. The settings defined in defaultProxy are use by HttpWebRequest (and, therefore, web service calls) with no change to the application required.

As an added benefit, this element can be added to machine.config, which allows it to be applied to every HttpWebRequest made from the client machine regardless of the application. Keeping in mind that an uneducated developer could assign the Proxy object in code, overriding this nice, easily configurable default.

Deserializing Objects

bruce — Wed, 17 Nov 2004 20:18:00 GMT

Another post about the deserialization of objects after a web service call. In this particular scenario, the web service method was returning an ArrayList. On the client side, I was expecting to see a number of different types of objects. But one of the objects, a custom class, was being returned as an array instead of an instance of the expected class. And inside that array was an XmlAttribute and two XmlElement objects. These were, it turned out, the XML nodes that were being returned from the web service method. It's just that they weren't being converted into the desired object.

After a couple of hours of digging, I found out the cause. Many of you are probably aware of the XmlInclude attribute that is used to decorate web methods to indicate that the schema for a particular class should be included in the WSDL for a web service. That is not, strictly speaking, it's only purpose. To be precise, it is used by the XmlSerializer to identify the types that are recognized during the serialization and deserialization process. It's this second piece that was the solution to my problem.

Because the web service being developed is intended to be used in an intranet environment, the same assembly was available on both sides of the fence. To support this, the generated proxy class was modified to reference the shared assembly instead of using the class that is automatically included by WSDL.EXE. It also meant that we didn't want to perform an Update Web Reference when the web service was modified...it would have meant making the manual changes to the proxy class again (Rich Turner might not remember me from the MVP Summit, but I was the one who was most excited when he described the ability to customize the proxy class generation being available come Whidbey). The down side of this manual process is that, when objects of this type were added to the ArrayList that was returned, the proxy was not updated with the appropriate XmlInclude attribute.

That's right. The proxy class gets the same XmlInclude attribute. WSDL.EXE generates the class with the appropriate attributes. But if you're like me, then it's something you need to be aware of the next time an array of XmlElements appears unexpectedly on the client side.

Moving DataSets across Web Service Boundaries

bruce — Wed, 17 Nov 2004 15:30:00 GMT

A situation last week had me looking deep into the bowels of how DataSets are marshaled across web service methods. The situation is as follows.

For programming ease, the typed DataSet that was automatically generated was modified to include a custom object as one of the column types. If you've ever taken a close look at the code that gets generated when a DataSet is created from an XSD diagram, you'll realize that this is not a difficult thing to accomplish. And, for the most part, there is little reason to modify the generated code. But that being said, there are times when doing so can make the life of the DataSet user a little easier. And this isn't really the point of the blog, only the motivation for digging into DataSet marshaling.

The modified DataSet was being returned to the client by a web service method. When the hacked column on the returned object was accessed on the client side, a StrongTypingException is thrown. Another look at the DataSet generated code shows that the cause of this exception is a casting error in the property. Further examination showed that the name of the class associated with the column was being returned. As a string. Naturally when the literal “This.Namespace.Class” is converted to an object of type This.Namespace.Class, casting exceptions are the result.

This behavior begged the question “why wasn't the object being XML serialized with the rest of the DataSet”. After all, though I haven't mentioned it yet, This.Namespace.Class is completely serializable. In particular, why was the name of the class being returned??? That didn't make any sense.

At this point, I broke out .NET Reflector and took at look at the details of the DataSet. First of all, if a DataSet is returned across a web service boundary, it is not XML serialized in the same manner as other objects. Instead of converting the contents of the DataSet to XML, a diffgram of the DataSet is generated. More accurately, the WriteXml method is called with a WriteMode of Diffgram. Within the DataSet class, there is a method called GenerateDiffgram. This method walks across each of the tables in the DataSet, followed by walks, in turn, through the DataTables and DataRows. When it gets to an individual column, it loads up a DataStorage object. More accurately, since DataStorage is an abstract class, it instantiates a DataStorage derived class, using the column type to pick the appropriate class. A veritable DataStorage factory. When the column type is one of the non-intrinsic types, the ObjectStorage class is used. On the ObjectStorage class, the ObjectToXml method is called. This is where the unexpected happens. At least, it was unexpected for me. The ObjectToXml method does not XML Serialize the object!

In the case of the ObjectStorage class, what actually happens is that a check is performed to see if the object is a byte array. If it is a base64 encoding of the array is returned. Otherwise the ToString() method on the object is called. When it comes to re-hydration on the client side, a similar process occurs. The difference is that the XmlToObject method in the ObjectStorage class instantiates the desired object by passing the string representation of the object (as emitted by the ObjectToXml method) into the constructor.

So what is the point of all this? First, it explains why the name of the class was appearing in the generated XML. Unless overridden, the output of ToString() for an arbitrary class is the name of the class. It also explains why no object was being created on the client side, as the class I was working with didn't have the appropriate constructor. My solution, which I freely admit is a bit of a hack, is to give the diffgram generation process what it's looking for. I overloaded ToString() to return an XML document containing the values of the class, a poor man's version of the WriteXml method that is part of the IXmlSerializable interface. I also created a constructor that took a string as a parameter and repopulated the properties of the class (the ReadXml portion of the process). Problem solved. But still, I have to wonder why ToString was used and not the IXmlSerializable interface methods in the first pace. Here's hoping someone more knowledgeable than me will provide some insight.

ASP.NET 2.0 hits ZBB

bruce — Tue, 16 Nov 2004 12:16:00 GMT

I don't know about you, but I am eagerly anticipating the beta 2 release of ASP.NET. Why, you say? Because it's the one that contains a go-live license. The go-live license gives the ability for production systems to use the technology outside of the development environment. Now I'm not suggesting that a beta 2 release is suitable for every production environment. That would be patently silly. However, there are some instances where running a beta version in production is not a big deal. Like when we redesign the ObjectSharp web site in ASP.NET 2.0. Which will be done as soon as the go-live license is received. So you understand my desire to get to beta 2.

Scott Guthrie, the source of much goodness about the inner workings of the ASP.NET 2.0 development team, announced that beta 2 hit zero bug bounce this past Saturday. In terms of release dates, it means that we're probably looking at 8-10 weeks from now. I'm keeping my fingers crossed.

An offer you can't refuse

bruce — Mon, 08 Nov 2004 17:00:00 GMT

Tomorrow is Halo2 day. And why would you want to spend the evening being shown the goodness that is Visual Studio Team System by my colleague Barry Gervin? Because at the end of it, you get a change to win not only an XBox console, but also a copy of Halo2. Check out Barry's post for more information.

Refactoring for VB.NET 2005 Going Away?

bruce — Tue, 02 Nov 2004 18:41:00 GMT

Well, not completely. You have to read a little bit into this post, but it appears that the only support for refactoring in VB.NET Whidbey is the Rename Symbol function. To me, this means that one of the major differences between C# and VB.NET in Whidbey will be refactoring support, as C# Refactoring implements a few more functions.

By the way, this shouldn't completely surprise anyone. Check out the following post from a year ago. It describes the refactoring features that C# Whidbey will support (subject to change, of course). But in one of the comments from Scott Wiltamuth (a C# Product Unit Manager) it is suggested even then the VB.NET might not get much more than Rename Symbol.

Very prescient.

Random ASP.NET AppDomain Restarts

bruce — Mon, 01 Nov 2004 13:43:00 GMT

Are you having a problem with apparently random application restarts in your ASP.NET application? Does your session information mystically disappear with no discernable pattern? Well, the following may help you out.

One of the things that ASP.NET does to help make it easier for developers to modify running web sites is to keep an eye on files that are part of the virtual directory. If you drop a new version of a DLL into the bin directory, it takes effect from the next request on. If you make a change to an ASPX file, it too is detected and becomes 'live' with any subsequent request. No question that this is useful functionality.

A little known fact about this process is that ASP.NET is also aware of the amount of memory that maintaining two versions of the same assembly takes. If changes were allowed to be made without a restart, eventually it could become detrimental to the overall performance ogf ASP.NET. To combat this, ASP.NET also tracks the number of files that are changed and after a certain number, performs an Application Restart. As with any other restart, this causes the current session information to be lost. By default, the number of changes before a restate is 15. To modify this, you can change the numRecompilesBeforeApprestart attribute in the machine.config file.

While all of this is useful information, there is a small twist that can make our life more difficult. The files that ASP.NET is watching while looking for a change is not limited to those with an .aspx extension. In fact, it is any file in the virtual directory. Also, the name of the setting implies that the Recompiles are what is being counted. It's not. What is being counted is the number of files that change. Or, more accurately, the number of changes to any file in the virtual directory.

How can this cause problems? What if you were to put a log file into the virtual directory of a web site. What if that log file were opened and kept open while the information was written to it. When that log file filled up, it is closed and a new one opened. Of course, this close counts as a file change. That would mean that after 15 log files are created (assuming no other changes to the web site), the virtual directory would automatically reset. And since the amount of information written to the log file will be different depending on which pages/web methods are called, the frequency of the reset is dependent on factors that are not immediately apparent. Imagine the joy of trying to discover why ASP.NET applications are being randomly reset without the benefit of this blog.

The moral of this story: Don't put any non-static files into an ASP.NET virtual directory. My good deed for the day is done.

Moving Data Across Service Boundaries

bruce — Mon, 01 Nov 2004 04:53:00 GMT

Yet another question that has come across my inbox more than once in the past week. Which is a good enough reason to become the topic of a blog. The question:

"Can a SqlDataReader by return by a web service method?"

The short answer: No

If you attempt to do so, you will get an InvalidOperationException indicating that the SqlDataReader could not be serialized because it doesn't have a public constructor. And while that is the technical result, the true reason is slightly different.

The SqlDataReader class is stream based. That is to say that the connection to the database that feeds the SqlDataReader is kept open and busy for as long as the reader is working with data. If an instance of SqlDataReader were to be returned from a web service method, the client would attempt to do a Read. Which would use the connection to retrieve data from a database that is no longer around. And certainly not where the connection expects it to be. Not a situation that's amenable to success.

My head-shaking moment for the day

bruce — Fri, 29 Oct 2004 18:43:00 GMT

Talk about telling a fascinating story. In Scott Guthrie's most recent post, he continues on with a description of the testing process for ASP.NET. 100,000 test cases? Yawn. 500,000 test scenarios? Sure it's a big number, but what have you done for me lately.

But his description of Maddog had my jaw hitting the floor. An application that automatically formats and re-images systems. And builds on them And coordinates test results. Now that's something you don't see every day.

A look inside the process

bruce — Wed, 27 Oct 2004 14:22:00 GMT

For the past few months, I have been working as part of a large team of developers working on the new release of a product. By large, I mean that there are probably over 100 working on various pieces of the code. Going through the process has given me a great deal of respect for the issues that must face any large team of developers. For some reason, the efforts that must be going on at Microsoft as they prep for Whidbey, Longhorn, et al came to mind. Check out the following post by Scott Guthrie about the process that the ASP.NET team is going through as they get ready for Whidbey Beta 2. Quite enlightening.

When is a cache not really a cache

bruce — Wed, 27 Oct 2004 03:39:00 GMT

I spent a large portion of the day inside of the Caching Application Block. Specifically, a colleague and I were tracking down what appeared to be a nasty threading bug caused by having the creation of two different cached objects that were related to one another. As it turned out, the bug that existed couldn't explain away all of the behaviors that we observed.

As it turns out, there was what appears to be a poorly documented aspect of the Caching Application Block that was causing us grief. The problem is that the default number of objects that the cache can store before scavenging begins is set very low. Specifically, it is set to 5. As well, there is a UtilizationForScavenging setting (by default, it is 80) that lowers this number ever more. Once the cache contains the (maximum * utilization / 100) items, the scavenger starts to remove the excess items from the cache, trying to keep the number of items below the calculated value. With the default values, this means that no more than 3 elements will be saved in the cache at a time. The scavenging class uses a least recently used algorithm, however if you're using an absolute time expiration, there is no 'last used' information saved. So the scavenger appears to remove the last added item.

That's right. Unless you make some changes to the default config, only three elements are kept in the cache. Probably not the performance enhancer that you were looking for from a cache. Fortunately, the values can easily be changed. The can be found in the ScavengingInfo tag in app.config. And there is no reason not to set the maximum value much higher, as there is no allocations performed until actual items are cached. It was just the initial surprise (and subsequent fallout) that caused me to, once again, question how closely related the parents of the designers were. But only for a moment. ;)

As one further word of warning, if there is no ScavengingInfo tag in the config class, then the default class (the same LruScavenging class just described) is used. And instead of getting the maximum cache information from the config file, a file called CacheManagerText.resx is used. In that file, the entries called RES_MaxCacheStorageSize and RES_CacheUtilizationToScavenge are used to determine how many items to keep in the cache. Out of the box, these values are set to the same 5 and 80 that the config file contains.

Solving the "No such interface is supported" problem

bruce — Tue, 26 Oct 2004 02:55:00 GMT

I was asked a question today about a fairly common error that occurs when serviced components are used in conjunction with ASP.NET. Specifically, a COM+ component (one that is derived from ServicedComponent) was being used on an ASP.NET page. When the page was loaded, an error of "No such interface is supported" was raised.

To understand the why of this error requires a little bit on knowledge about COM+. When a serviced component is first instantiated, the CLR checks the COM+ catalog for information about the runtime requirements of the class. But if the class had not previously been registered, then no information will be available. To correct this discrepancy, the CLR automatically creates a type library for the class and uses that information to populate the COM+ catalog. This mechanism is called lazy registration.

But wait. It requires a privileged account in order to register a component in the COM+ catalog. In particular, you need to be a machine admin. And, unless you have been silly enough to grant the ASP.NET user admin rights to your machine, the update of the COM+ catalog fails. No catalog information, no instantiation. An unsuccessful instantiation means an exception. An exception that includes an error message of "No such interface is supported". Go figure.

So ultimately, the solution is not to depend upon lazy registration of COM+ components that are deployed for use in ASP.NET. Instead, perform the registration using the regsvcs.exe command manually.

Halo2 is coming, eh?

bruce — Sun, 24 Oct 2004 13:54:00 GMT

For those of you who are Halo fans, check out the following link (http://www.techstuff.ca/archives/915.html) describing what is different between the American and Canadian versions of Halo 2. Thanks to Scoble for the link. And I'd be happy to answer questions from Americans explaining why it's funny. I'm familiar with discussing stuff like this with my American wife. ;)

Cookieless Sessions and Security

bruce — Mon, 18 Oct 2004 16:59:00 GMT

In a previous blog, I pointed out that Microsoft had created an HttpModule that mitigated the ASP.NET cannonicalization issue that was first described a couple of weeks ago. In one of the comments, Amir asked about the security issues surrounding the use of cookieless sessions. Specifically, he was wondering if ASP.NET could tell if a request containing a cookieless session component was coming from a different browser instance or even a different location. In brief, the answer is “No“.

When used as part of a plain text web site (i.e. no SSL), cookieless sessions are not secure at all. The session id is placed into the URL in every local link on a page. The form of the URLs would not be as follows: http://domain.com/(sessionid)/Page.aspx. This session id is not automatically tied to a specific browser instance or even the IP address of the initial request. There is no way that I'm aware of to tie the request to a browser (other then using cookies ;). And while a session can be associated to an IP address, this requires some additional work on your part, in the form of an HTTP Module. The association between session Id and IP address could be done by generating a hash of the IP address for the request (Request.ServerVariables ["REMOTE_ADDR"]) and the session id and using the resulting value to access the session variables. However, this solution doesn't take into consideration the case where people are behind a proxy that causes the IP address to change from request to request. For this, you might want to just use the first two components of the IP address, since these are not normally varied by the proxy. But if the spoofer is on the same subnet... As you can see, all in all, this is a difficult problem to solve.

I should probably mention that cookie-based session suffer from the same problem. There is nothing inherent in how cookied sessions work that makes them safer than their cookieless counterparts. A hacker can easily create a request that includes a spoofed cookies containing a hijacked session identifier. But at least a cookie-based session solution can use SSL to encrypt the entire request. Since the session is not included in the URL directly, it is not easily accessible if the request/response gets hijacked.

So to summarize, while cookieless sessions are nice in theory, in practice they really should only be used on sites where every page is accessed through SSL. And the implementation should be customized to ensure that a portion of the IP address is used to verify the originating IP address of subsequent requests corresponds to the original request.

Remove Those Annoying System Tray Balloons

bruce — Sun, 17 Oct 2004 22:40:00 GMT

If you're like me, the system balloons that are automatically popped by system tray application are annoying. This blog from Scott Howlett describes how to eliminate them from your life.