Andrew Hay's Blog

InnoTech Presentation Notes: Understanding LINQ

Andrew Hay — Wed, 16 Apr 2008 19:50:00 GMT

Since I'm posting this in advance, I hope my session titled Understanding LINQ was a huge hit and everyone loved it. I've been working on the content for a while and its tough whittling it down to fit inside the specified time slots; there's just so much cool stuff. I probably phat-fingered some keys once or twice, but hopefully I didn't start my sentences with "So...." too often or speak so fast that I made a whistling noise. I hope you enjoyed it.

Here's what you need to run my demo:

Here are a collection of URLs that I referenced during my session at InnoTech. They're great references for understanding LINQ.

Session Feedback

If you attended the session, would you please provide some feedback using this online survey?

Launch Survey

Speaking at the InnoTech Conference

Andrew Hay — Thu, 27 Mar 2008 03:54:00 GMT

I'll be speaking at the InnoTech Conference in Portland, Oregon on April 16th and 17th. My session will get you started with LINQ, a new feature available in the Microsoft .Net v3.5 Framework.

Language-Integrated Query is one of the most compelling features for your business in the Microsoft .Net 3.5 Framework. LINQ provides a succinct and expressive layer over your database tables, stored procedures, XML, and other objects. You’ll learn how to get started with LINQ and gain some visibility into what’s going on under the hood with this game changing addition to the .Net Framework.

I'll start with some of the fundamental features that enable LINQ to exist including object initializers, local inferred types, extension methods, lambda expressions and then dive into LINQ to SQL and LINQ to XML. Hopefully, I'll have time to touch on LINQ to XSD and some of the other activies going on with this game changer.

I'm also looking forward to seeing some friends talk about Silverlight and agile development practices. Hope to see you there!

What's Your Pet's Name?

Andrew Hay — Wed, 26 Mar 2008 04:40:00 GMT

Such a casual question at party could have terrible consequences when you use weak passwords on the Internet. The best advice is to use a unique password for each account. If you spend all day online like me, plus a little more at home, you've probably garnered somewhere north of 50 or more accounts.

The question to ask yourself is which of those accounts are just fine for a hacker to slip into because you used a weak password? Probably none, right?

Just to put a little more emphasis on it, let's say you use a reasonably good password for your account on Amazon.com and you liked it so much that you've used the same password when you had to create an account last week just to leave a comment on a blog. Now, let's not get too blue and say that blog site was evil and successfully phished your password. Let's just say the security was a little too low on that site and someone else happened to glean all of the e-mail addresses and passwords from that blog.

So now the bad guys have your password. What else can they get into with it? If you've been adhering to the rule, then absolutely nothing. If you've been lazy, then they just need to guess the username or e-mail address to your bank, your corporate Intranet, your social networking sites or anything else you use. Kinda bleak, eh?

How are you supposed to remember all of those passwords? Well some fine folks are working on that very problem with technologies like CardSpace and OpenID. That's all well and good, but what do you do today with the accounts you already have? Start buying more Post-It notes?

Until you've got a better plan, start out by using a tool like Password Minder. Its free and available here: http://www.pluralsight.com/tools.aspx. This is a simple program written in .Net that helps you collect, organize and use all of the various passwords that make up your life. The data is encrypted into a single XML file that you can store on a USB key, copy to every computer you own or anything else that accepts an electronic file.

You can leave the program running all day, so long as you remember to lock your computer when you leave, or you can start and stop it every time you need to pull out a password. This program is great because its simple, it can be copied to any computer and its protected by a secure master password.

Here's how it works:

Download and unzip file from PluralSight.com
Launch the program file name pwm.exe
Create your master password — this is what you'll have to type every time you launch the application.
Add all of your usernames and passwords into the application; each password is unique, right?
Copy the data file to your other computers or keep it on a USB key for portability. This application is light weight and very portable.

Better yet, take a look at a short Silverlight video I made showing how to get started with Password Minder. If you've kept your computer current with Windows Update, then it should be no problem to use.

Start-Up Junkies

Andrew Hay — Mon, 18 Feb 2008 17:47:00 GMT

When I was 8 to 12, I was big into Dungeons & Dragons. My brother was five years older, and sometimes I could sit with his friends and play. We had all the books, much to the chagrin of my parents. When the D&D cartoon came on, all other things ceased to exist for those short 30 minute chunks of time.

Now that I'm older, I watch a new show called Start-Up Junkies, its on the MOJO channel. I first heard about the show at my local .Net User Group meeting. The PADNUG organization gets together about once a month, sponsors buy pizza and someone presents for 60-90 minutes on a .Net related topic; recruiters abound here. Being so close to Redmond, we're a little spoiled with lots of juggernaut speakers around. At the last meeting, Matt Davis gave what was arguably one of the best sessions I've ever seen here. He's a relaxed speaker and clearly an expert in his craft.

Matt works for a company called Earth Class Mail, a start-up with a great idea. They offer a mail processing service. When you sign up, you change your address and send your mail to them. They scan all of your mail and you access it online. They can scan just the outside of the envelope or open and scan all of the contents too. You can shred it or have the physical document sent to you if you want to keep it. The company was growing at a reasonable pace when they signed on the mysterious giant corporate client, code-named "cheetah". If they make this pilot project with cheetah work, they'll be huge. Matt mentioned the TV show in passing during the presentation and I looked it up.

Start-Up Junkies follows the company through the frantic pace of trying to scale up without failing. I saw the .com bubble rise and fall so I really get this show. The cameras wander all over the offices, covering the CEO, marketing, sales, I.T. and operations. Sometimes I'm cheering and other times I'm yelling and the screen and shouting WTF!?!?!

I love my job and now I get to watch a little bit of it portrayed on HDTV. Watching in the one-piece jammies with feet is optional.

Test for Existence of a JavaScript Method

Andrew Hay — Sat, 16 Feb 2008 07:05:00 GMT

One of my teammates recently had a problem with some Flash injection code. She was setting some properties and then calling a function on a JavaScript object that threw an error. We got a message that said "Object doesn't support this property or method".

We isolated it down to a timing issue by dropping an alert() into the code just before we called the method. With the alert() pausing execution for a few seconds, the browser had enough time to fully instantiate our object. Without the alert(), the method was called before it was built. Its a problem that can make your brain hurt.

Here's how you can test for the existence of a JavaScript method before you call it. You might need to do this if you're working with asynchronous calls or dynamic objects that take a while to build.

I created a sample page to demonstrate the issue and how to deal with it. I put three hyperlinks on the page that each call a JavaScript method. Here's the JavaScript code.

At the bottom of the previous code block, you'll see some JavaScript in the mainline section. This code gets executed as soon as the browser sees it. JavaScript is an interpreted language and the browser processes it in a top-down fashion. So, by definition, the browser already knows about my three methods before it runs my code in the mainline. This is where I define an empty object to test and then create an instance of that object. Just two lines, not much so far.

When I click the link that runs the function named TestForFunction(), I perform some due diligence tests by checking for an undefined object as well as a null object. The last test with the arrow pointing to it is the key part. This will tell me if the method exists without actually running the method. I show one of two messages based on the existence of the method.

The top function named CreateFunction() just spot welds a method onto my object. Even though I've already created an instance of my object, I can still see this method in my instance because I've added the method to the prototype. When this function returns, I've got my new method. When I run TestForFUnction() again, it will see the method.

The bottom method just executes the function I added on the fly. When my DoWork() method fires, it shows a message in the alert() pop-up.

If you find that you need to deal with this type of problem in your code, inspect the object for the method before you call it. If the method doesn't exist, refactor your code to call the window.setTimeout() function for a few milliseconds and check again. Once it exists, your code can continue executing.

Its only Monday, and I'm Already Out on a Branch

Andrew Hay — Tue, 05 Feb 2008 06:34:00 GMT

...or two.

I've had two projects this week where their/my bacon was saved by the branching strategy used for the source code repository. In my line of work, I touch a wide variety of projects. Some are still shiny new and others were written years ago; they're all in a source control repository.

Modern source control repositories (and by modern, I mean things that are not your file server or P:\ drive) let you create a branch. Branching might appear complex at first, but it's really pretty simple - at least conceptually. Here's a little story to illustrate the point of branches.

When I create a branch, I have a snapshot of the code at a particular point in time. So, imagine that on Monday, I have a single branch called the "trunk". It contains all of the code for my web site. On Tuesday, I created a branch based on the code in the trunk. I named my branch "BR-1". When I created BR-1, it was a mirror image of the trunk. I edited the code in BR-1 for a couple of days and nearly got it how I wanted it. My edits were isolated to BR-1 and they did not exist in the trunk.

I got a call early on Friday morning about an important change that needed to go out right away. I couldn't implement the urgent change to BR-1 because it contained my partially completed work. It was a pretty small change; a few hours of brilliant coding and I would be ready for a peer review of my changes. So, I checked out the trunk and made the edit right there and checked it back in. I published the urgent change I made on the trunk out to the live web site in the early afternoon and went back to working on BR-1.

By mid-day on the following Monday, I had finished all of my changes to the BR-1 branch. I had merged the BR-1 code into the trunk too. Now my trunk code contained the changes from BR-1 as well as that urgent change that came through on Friday morning. Complete control with the flick of a switch.

In the previous story, I was able to handle the urgent request efficiently because I used branching to manage my code changes. If I didn't have branching available as a software development tool, I would have some bad choices to make. Either I merge the urgent fix with my own enhancements and risk problems by rushing it, or force the urgent change to wait until my own changes were done; neither are necessary.

Branching is great way to ensure that I can always put my work on the shelf in lieu of more pressing matters. Understanding the concepts of branching is essential to being a valuable member of the team. The keys you actually press to make a branch or merge two branches can be left up to the nerdy folk. For more info, check out Pragmatic Version Control Using Subversion.

Understanding LINQ

Andrew Hay — Wed, 19 Dec 2007 01:43:00 GMT

LINQ is an acronym for Language-Integrated Query and a new feature in v3.5 of the .Net Framework from Microsoft. This new version of Microsoft .Net reached RTM status a couple of weeks ago — this framework is chock full of brilliant things I can use to improve my efficiency and effectiveness on daily tasks here at Pop Art.

As one of my favorite features, LINQ helps me write data-driven application even faster than what .Net 2.0 brought to the table. A common example starts with launching Visual Studio 2008. After dragging a collection of tables from a SQL Server database onto a surface in my solution, I can see a visualization of the columns in the tables as well as the relationships between them. Click the following thumbnail to see a larger image.

Next, I start writing data access code directly in my C# program as opposed to switching languages and writing in the T-SQL language. Visual Studio gives me Intellisense here too; as I type the name of a table and click the period key, all of the columns in the table appear where the cursor is located. Big time saver. Huge! I'm certain that I didn't misspell a column name and that my code will compile.

The syntax for LINQ in a C# program is very similar to the T-SQL language, which is a "set based" language. LINQ statements are compiled, just like the rest of my C# code. The first thing someone well versed in T-SQL will notice is that the columns normally specified in a SELECT query are at the end of the LINQ statement instead of the start as in T-SQL. The idea is that you're articulating your constraints at the start of the LINQ statement and then pulling out the fields you need at the very end.

Behind the scenes, LINQ is using the relationships expressed in the database to generate T-SQL scripts on the fly. This is a clear line of demarcation for LINQ. If you're using stored procedures exclusively for database access, then LINQ isn't going to buy you much. You'll still get Intellisense inside Visual Studio and you can specify an existing stored procedure instead of using the auto-generated SQL, but you're giving up a lot of acceleration tools. Perhaps more than you're getting in return.

LINQ really shines in multiple table joins and aggregation. The following two blocks of code show a query is performed in LINQ and its equivalent T-SQL script. The query retrieves product information from three tables where the list price is below a given amount and a sub-category name exists. If you go the T-SQL route, you will still need to write some C# code to call your database query.

Which of the following versions would you rather author and support?

LINQ Version

T-SQL Version

MSDN is a great online resource for developers and they really hit a home-run here. They have a page with 101 LINQ samples. This is my preferred way to learn when I already know the surrounding technologies and I want to fill in a specific gap. The page categorizes several ways of retrieving and iterating over information.

Dear ClementDesign Mocha Master Coffee Maker

Andrew Hay — Sun, 16 Dec 2007 22:22:00 GMT

I think you're a good person, but I can't be with you. I have to break up. Sure 2007 was a fun year, galloping around the estate with that thick scent of delicious coffee in our hair and eager for the new dawn of a dark roast. We had some good times. The Techni Vorm label made me feel European too and I tried to embrace it, I really did. Its not you, its me.

It wasn't easy with your friend, Virtuoso, the coffee grinder. He never made it simple for us. I don't think he ever really accepted me. What was up with that static electricity? It let forth a brilliant shower of charged coffee grounds after each use. I'm mean really, how can he expect to keep someone around? Sure his sleek exterior and large bean reservoir would make anyone grin, but I've got to think of myself sometimes, I have to ask, what's in this for me? It was just too much of a mess to clean up after every grinding session.

Mocha Master, why did you start spilling over? At first, I was willing to blame it on the other people you saw. There were several accounts sent around on how to properly make coffee. But time and time again, you spilled when no one was looking. The final straw was when you spilled yesterday for me. It was me Mocha Master! I was here all alone with you and yet you forsake me. How could you do it? You know the level of coffee grounds in there was well within the accepted norms. Somehow you clogged up and spilled over the counter just like all of the times before. I have to give you up.

Hello Mr. Coffee, its been a while. I know I've been a bad friend and traipsing all over the coffee producing regions of the globe with my European friend, but its over, I swear.

I see you've gotten some new buttons and they look great, all shiny and in different colors. I've even started using a carafe so you don't need to worry about burning the coffee and ruining the flavor.

Oh, and hello little grinder! How have you been? I sure do miss you. Sure, you're from Starbucks, but that's ok. You're a good little guy and you don't have any static electricity. We love large machines and small machines alike. Sometimes you're abused and blamed for a mess, but its far and few between and I know you mean well. You can't fight gravity! Plus, you can grind your beans in 10 seconds flat. I'm going to enjoy seeing you around.

Mr. Coffee, I want you to know that I'm ready to get down to work and you won't have to worry about any more whimsical adventures from me. We have a simple agreement in place; you make coffee and I'll drink it. We don't need any drama in our lives around this matter and neither of us wants a high maintenance relationship. I'm glad you were willing to come back. I love you Mr. Coffee.

Thinking about ROI

Andrew Hay — Sun, 11 Nov 2007 02:14:00 GMT

In my experiences as a software developer, its fairly normal to hear comments like the following:

That's too many hours
They don't have the budget
I'm not paid enough

I had the good fortune of attending a Portland XP Users Group presentation a few weeks ago by James Shore. He got off on a slight tangent and gave us (well, at least me) a simple equation to chew on:

He explained that at its core, Return On Investment is represented by the previous equation. It can help explain quite a bit about the world. This was in response to someone asking about the high cost of the software development methodology under discussion that night.

If you're presented with a scenario where the value is constant, then the only way to play the game is to minimize costs. Think of a job that never changes. If it always provides the same value to a business, management will seek ways to reduce cost in order to improve the ROI equation.

On the other hand, a scenario where value has the capability for growth is much more interesting. If you wanted to make $500,000 a year then you would be challenged to deliver some multiple of that cost as a value to the business.

Here's my favorite take-away: At some point along the graph, as value increases then cost becomes insignificant. This is the place to be.

The initial cost of software can make some people squeamish. I'm certainly not one to be afraid of zeros; I'm much more interested in the value.

What is this solution doing for the business?
Is there a practice in place for tracking ROI over time?
How soon can it begin providing value?
Can it provide even more value?
It is possible to reduce cost and drive the equation even higher?

This is why I love my job at Pop Art. Driving value higher and then swooping back to cut costs with new technology that makes me more productive. Value will often come in several forms including cash value, brand value and community value. In any case, it all starts with that equation.

Double Hop Disaster

Andrew Hay — Sat, 10 Nov 2007 16:57:00 GMT

I was working with a web service client that talked to SharePoint this week. I wrote a quick Silverlight app that extracted a list of tasks out of a SharePoint list. I love how simple this is to tap into:

http://sharepoint.yourcompany.com/_vti_bin/lists.asmx

The previous URL will show the path to one of the web services provided out-of-the-box by SharePoint. This particular web service provides several methods for dealing with SharePoint lists. I just needed to call the GetListItems() method and pass in the list name and view name as parameters in order to get my data.

This worked fine on my local machine, but when I migrated the solution to a staging server, the SharePoint web service refused to send me the data. After a bit of finagling, I realized the web service was happy to talk to my laptop, but it politely declined the remote web server's request as I lacked the proper credentials. I even was running the web solution with impersonation enabled because I wanted to pass along my Windows credentials during the call from the web server to the remote SharePoint server. I forgot that this is just simply not possible.

For security reasons, the web server does not hold on to my credentials "just in case" I might want to use them later. In this scenario, I do need them - but no dice. This particular list in SharePoint is locked down tight.

I didn't have the proper credentials when my web service client fired off a request to SharePoint. When I was running on my local machine, using Casinni, my credentials were readily available. On a remote web server, the credentials vanish. This is called a "Double Hop" problem - the hops are from the browser, to the web server, to another remote web server. The second hop tanked. It was a silly mistake on my part, but hopefully by writing this down now will help me remember sooner next time.

The code below shows how I solve this problem by manufacturing a credential on-the-fly and then fire off a request to SharePoint. There are multiple ways of solving this problem; I just happened to chose this one.

         MySharePoint.Lists list = new ProjectBoard.MySharePoint.Lists();

         list.Credentials = new System.Net.NetworkCredential(

            ConfigurationManager.AppSettings["Credential.Username"],

            ConfigurationManager.AppSettings["Credential.Password"],

            ConfigurationManager.AppSettings["Credential.Domain"]);

         XmlNode listItemsNode = list.GetListItems(

            ConfigurationManager.AppSettings["LoremIpsum.Guid"],

            ConfigurationManager.AppSettings["LoremIpsum.View.Guid"],

            null, null, "100", null, null);

         XmlNode dataNode = listItemsNode.ChildNodes[1];

         foreach (XmlNode rowNode in dataNode.ChildNodes)

           // extract values here

Now that I've got this little prototype functional, I can encrypt the credentials in the web.config file by using DPAPI, an encryption tool that makes it easy to protect sensitive information. Since I'm creating new credentials here, I can avoid the Double Hop problem and get on with my prototype.

How I Married Into Mathematics

Andrew Hay — Sat, 29 Sep 2007 20:59:00 GMT

I'm working on a solution that requires a special type of chart to visualize results from some elaborate number crunching algorithms. Dundas Chart for .Net has an implementation of the standard polar chart.

That's the closest "buy" option I could find and it might very well do the job. I'm a big fan of using existing software when it can solve a significant portion of the problem domain. When you find a good off-the-shelf option, they're often inexpensive and supported (by someone other than me), two big wins right off the bat. The ultimate solution has a few features that are difficult or impossible in the "buy" option, however they might be deemed insignificant. So the "buy" option might very well win out during the upcoming evaluation of my solution, but as part of my due diligence I had to see what the "build" option could offer me.

When I first envisioned the solution, I had ideas of 3D modeling like the work described by Tim Huckaby at InterKnowlogy for the Scripps Research Institute. They built a cancer research application called the Collective Molecular Environment.

Researchers from around the world can review the same model, zoom in, rotate models and insert annotations of their observations. The screenshot to the left shows one of the sample molecule views that comes with the demo. Spinning the molecule around with your mouse is pretty cool.

It's written in C# using Windows Presentation Foundation. SharePoint tracks the collaboration on the back end, but its invisible to the user. Researchers just launch the application and start clicking on cells in 3D.

Download a demo of the WPF application and twirl cells around on your own computer. The thing that floors me is that the proof of concept took only six weeks to build. WPF and SharePoint were really put to good use here.

Independently, Ben Waldron reminded me of MusicPlasma.com. You enter a band name and it shows related music artists in a 2D model using Flash. The mash-up pulls information from Amazon.com. When you click on another artist, the map adjusts and they become the new "center of the universe". Its a cool way of visualizing relational data.

Then I thought about the specific challenges I would have to solve in order to build the solution myself. I knew my data would have a central point and other points around it at various distances. Related points would have a line connecting them — not all points are related to each other. Each point would also display a short keyword or phrase.

So, to put it in mathematical terms, I had a center point at (0,0) that was surrounded by multiple invisible circles. The solution had to plot an unknown number of points on the appropriate circle. The size of each point could vary between 40 pixels and 4 pixels in size. The unique phrase beside each point could remain the same size. Finally, related points need a line connecting them.

I selected Silverlight for my proof-of-concept vehicle. Its a technology that can extend a web page and draw shapes or play video, like Adobe Flash. I first heard of this technology a while back at the MIX06 conference in Vegas. Silverlight runs on Windows and Mac OS X today and they've announced plans to support Linux so there's no worries about the supported platforms.

I use XAML or Extensible Application Markup Language to express how the Silverlight component appears on the page. The XAML used in Silverlight is a subset of the XAML used in WPF applications since Silverlight is browser based while WPF apps can take advantage of the full Windows platform. Just like a new version of the Adobe Flash player, you have to download and install the Silverlight component the first time. Then any page on the Internet that uses Silverlight can take advantage of the plugin. It takes less than 60 seconds on standard machine to download the 1MB file and install it. Here's the button created with 100% XAML just by launching Visual Studio and clicking File, New Project, Silverlight Project. With just pure XML, Silverlight can draw a fancy glossy button. Pretty cool.

Now my problem was the math. How could I calculate the points on a circle? So I headed straight to The Wife; a number crunching machine with more degrees than that Nick Lachey's boy band.

The Wife ~~taught~~ reminded me about some fundamental principles of algebra and geometry. As she tells it, this is sophomore/junior level high school stuff. First, I needed to calculate the central angle between two consecutive points. We'll call that theta. As it turns out, it doesn't matter where the points are, providing they lie on the same circle. For starters, I just wanted an even distribution, so if "n" equals the number of points on the circle then (2pi)/n gives me theta.

Next, I need to start calculating the exact (x,y) coordinates of the points on the circle. The first point is easy, its just (r,0) where "r" is the radius of the circle.

The second point is a little tougher as it gets into sine and cosine. These are just names for ratios in a triangle. The mnemonic SOHCAHTOA helps you remember this on quiz day. Let's look at a following right triangle.

Sine is calculated as "opposite over hypotenuse", or the "SOH" part of the mnemonic
Cosine is calculated as "adjacent over hypotenuse", or the "CAH" part of the mnemonic
Just for good measure, the tangent is "opposite over adjacent", the "TOA" part

Now that I have all the ingredients, I can bake my pi. Ha! Ok, onto the task of plotting the points. The second and subsequent (x,y) values of my points are calculated by the following formulas.

P₀ = (r,0)
P₁ = (r(cos(θ), r(sin(θ))
P₂ = (r(cos(2θ), r(sin(2θ))
P₃ = (r(cos(3θ), r(sin(3θ))

For the "x" coordinate, I multiply the radius by the cosine of theta. The cosine of theta is "b" divided by "c". For the "y" coordinate, I multiply the radius by the sine of theta. The sine of theta is "a" divided by "c". In case its not obvious, the P₂ and subsequent points need multiples of theta, so the formula has that minor adjustment.

To apply this information, I created a simple XML file with some elements that define the number of points to draw and some supporting information. I'll just focus on a single circle or level for now. If I can make one, I can make more really fast.

Next, I created a simple ASP.Net page that reads the XML file and outputs the necessary XAML that will allow Silverlight to draw the chart. My C# code iterates over the list of elements in the XML file can calculates the (X,Y) coordinates using the previous formulas. Just to keep things simple, I linked all the points to the center for now. Later on, it'll be easy enough to link other points together with lines as I have already calculated all of the necessary (X,Y) values. You can download my solution through the link at the bottom of the post.

This XAML block produces the following output in Silverlight shown below. As you can see, XAML is just a special XML syntax that is pretty easy to pick up.

To draw an ellipse shape, you add the <ellipse /> element. To draw a line on the canvas, you add an <line /> element. Of course there is tooling available to abstract these details away, but its important to have a fundamental understanding of the work going on under the covers.

Silverlight translates the XAML markup into pretty images as shown below.

If this "build" solution turns out to be a winner, we'll be able to apply nice gradients to the images, add click() events to the bubbles so more information is available through a pop-up and maybe even add the "wet floor" look the feels so cliche these days. These are easy enough in Silverlight, so I didn't spend anytime on the glossy extras just yet.

So, my entire exploration of the "build" option in Silverlight took about two hours, including the time spent with The Wife — time well spent, indeed. It'll be interesting to see how the evaluation of my solution options pan out. Can you tell I love my job?

Download the solution described in this blog post.

Ain't No Party Like A Pop Art Party!

Andrew Hay — Sun, 23 Sep 2007 21:48:00 GMT

Ten Years! Wooo-Whooo!!

and I've been here for half of 'em!