Jason Kelly's blog

Portland Code Camp 2009 - Cloud Computing presentation

Jason — Sat, 30 May 2009 19:47:00 GMT

Here are the source files and slides from my presentation on Cloud Computing at Portland Code Camp!

Presentation - cloudpres.pptx

Azure - Wall sample app

Amazon Web Services - Wall sample app

Thanks for attending!

Improve your offshore code quality: Use static analysis tools

Jason — Tue, 03 Mar 2009 05:45:00 GMT

Static analysis is a technique that analyzes the source code (or compiled object code) of your software. Static analysis tools can help you improve your code quality by alerting you to design issues, performance problems, and maintainability constraints.

These tools are designed to be integrated into the development process, and we have baked it into ours. Team Foundation Server even lets you enforce check-in policy so that code that fails FxCop cannot be checked in. We don’t go that far, but every developer is asked to run code analysis before checking in. It’s a key part of our code review process.

My goal here is not to get developers to blindly change code to make the warnings go away. Rather, each warning that comes up is a change to learn something.

Here is some C# code that will trigger a common warning: Do not cast unnecessarily.

        1: void start_Click(object sender, EventArgs e)

       2: {

       3:    Size controlSize = ((Control)sender).Size;

       4:    RightToLeft rightToLeftValue = ((Control)sender).RightToLeft;

       5:    Control parent = (Control)sender;

       6: }

This code casts the same object variable to Control three times. Casting is slow, so this will have a small negative impact on performance. This can easily be fixed by casting the parameter once and storing it in a local variable.

You may be thinking that this is going to be a negligible speed increase – and you would probably be right in most cases. However, it’s not just about saving those two unnecessary casts. By seeing this warning and learning how to fix it, the developer will think about this in the future as well. The performance boost lives forever!

Here’s another one of my favorites: Do not catch general exception types.

       1: try

       2: {

       3:     outStream = File.Open(outFile, FileMode.Open);

       4: }

       5: catch (Exception e)

       6: {

       7:     Console.WriteLine("Unable to open {0}.", outFile);

       8: }

This is in big bold letters in our coding guidelines document, but it still comes up frequently. The code as written here would catch any exception – even exceptions that have nothing to do with the file operation. It’s important to catch a more specialized exception class – in this case IOException would be a good choice. Wherever this code is in your application, it should only be handling IO-related exceptions.

There is certainly a time and place to catch Exception and other general types of exceptions – and that’s when it’s appropriate to ignore these messages. The important part is that you take the time to decide what is the right time, and discuss it with others on the team.

The most frequent objection to using these tools is the noise level. Admittedly, these tools can produce a lot of warnings, especially when running them on pre-existing code. Make the investment! As you bake it into your process, you’ll build up a list of messages to mark as ignorable, and the signal-to-noise ratio will go up day by day. The payback is two-fold; not only do you get more robust code in the project you’re working on, but it’s another way for your team to learn good development practices.

There are great static analysis tools out there for every platform. For .Net programmers, it’s built into Visual Studio Team System, or you can download FxCop for free. If you’re on a Java project, Checkstyle is a good place to start. Whichever platform you’re working on, at least give these tools a shot.

Using jQuery & JSONP for cross-domain AJAX with WCF services

Jason — Wed, 25 Feb 2009 04:00:15 GMT

I’m working on a Virtual Earth application that uses AJAX to retrieve points of interest and plot them on the map. The long term direction for this application is to move the data source into the cloud, while the front-end web page is hosted onto a customer site.

For the front-end, I’ve been using jQuery, which now supports cross-domain AJAX with JSON with Padding (JSONP). The back-end is a Windows server with SQL Server 2008.

It’s a bit complicated to get JSONP working with a simple WCF service. Luckily, there’s some sample code on MSDN to do it for you; it’s just not obvious how to take advantage of it. Here it is in 3 “easy” steps!

1. Implement and test the WCF service with JSON
2. Convert the WCF Service to support JSONP
3. Implement the front end with jQuery

1. Implement and test the WCF service with JSON

Get that WCF service up and running, returning plain-vanilla JSON. This takes a whole host of variables out of the mix – the database connection, WCF endpoint configuration (ugh), etc. You want to end up with a working WCF service with an interface somewhat like this:

public interface ILocationService
{

[OperationContract]
[WebGet(ResponseFormat = WebMessageFormat.Json)]
Location GetLocation();

}

Test your service with cURL, Fiddler, or another suitable tool. Before you start with JSONP, you want to be able to call this service on localhost with HTTP GET.

My GetLocation web service returns a current location in JSON, like this:

{“Latitude”: 47.621389,”Longitude”:-122.356660}

2. Convert the WCF Service to support JSONP

The MSDN article JSON with Padding (AJAX) has a link to some sample code that will makes JSONP easy. You have to download the massive sample package (just do it, it’s worth it). Once you have the samples unzipped, find the JSONP project in WCFWFCardSpace\WCF\Extensibility\Ajax\JSONP\CS and grab these four files:

Add these files to your project. In a future post I’ll dive into how JSONP works and how these files implement it in WCF. For now, let’s just hook your WCF service up to the JSONP interface.

The Interface

The only thing do to in the code is to add the JSONPBehavior attribute to your interface. The example function GetLocation() above becomes the following:

public interface ILocationService
{

[OperationContract]
[WebGet(ResponseFormat = WebMessageFormat.Json)]
[JSONPBehavior(callback = "method")]
Location GetLocation();

}

The (callback = “method”) parameter dictates what query string parameter should be sent in the request URI. We’ll see more about that below.

Configuration

This is where it gets a little hairy. Getting the configuration right is always the most annoying part of implementing a WCF service. Here’s the system.serviceModel section from my Web.config:

<system.serviceModel>
  <behaviors>
    <endpointBehaviors>
      <behavior name="LocationServiceBehavior">
        <webHttp />
      </behavior>
    </endpointBehaviors>  
  </behaviors>
  
  <services>
    <service name="LocationServiceJSONP.LocationService">
	<endpoint address="" 
                binding="customBinding" 
                bindingConfiguration="jsonpBinding" 
                behaviorConfiguration="LocationServiceBehavior" 
                contract="LocationServiceJSONP.ILocationService">
	</endpoint>
    </service>
  </services>
  <bindings>
    <customBinding>
      <binding name="jsonpBinding" >
        <jsonpMessageEncoding />
        <httpTransport manualAddressing="true"/>
      </binding>
    </customBinding>
  </bindings>
  
  <extensions>
    <bindingElementExtensions>
      <add name="jsonpMessageEncoding"
           type="Microsoft.Ajax.Samples.JsonpBindingExtension, LocationServiceJSONP,
 Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
    </bindingElementExtensions>
  </extensions>
</system.serviceModel>

Remember the (callback = “method”) parameter in the JSONPBehavior attribute? That’s the key to making sure this works. To trigger the JSONP behavior, you must put a “method” parameter in the query string with the name of the callback method that will be used to wrap the JSON:

http://yourserver.com/LocationService.svc/GetLocation?method=jsonpCallback

This causes the JSON returned by the service to be wrapped in the callback method you specified:

jsonpCallback( {“Latitude”: 47.621389,”Longitude”:-122.356660} );

3. Implement the front end with jQuery

Finally! It’s time to implement this on the front end. In your web page, make the web service call like this:

$.getJSON("http://yourserver.com/LocationService.svc/GetLocation?method=?”, callback);

function callback(data) {
// data is the JSON returned – do whatever you want with it!
}

The method=? syntax tells jQuery to fill in the “method” parameter with the JSONP callback it generates. The rest is transparent to you – your function gets the unwrapped JSON.

There you go! JSONP lets you do cross-domain web service calls from any web page, as long as the target service supports JSONP.

Quote of the Day: Jetpack Safety

Jason — Tue, 29 Jul 2008 17:01:00 GMT

"We think we have done a lot to make this by far the safest jetpack ever built. But it's not a high bar."

--Glenn Martin, in the New York Times, July 29, 2008, A13

New Release: Windows Live Quick Applications

Jason — Thu, 24 Jul 2008 19:38:00 GMT

One of my jobs at Akona Consulting is to run the dev team that releases Microsoft's Windows Live Quick Applications. That's why I'm excited to announce that we've recently released a whole bunch of new Quick Applications - here's the "press release".

The Quick Applications are sample open-source web applications that show you how to build sites with the Windows Live Platform. Anyone can grab this source code and use it as the starting point for their own site - even if its a commercial site!

Here's a few money shots of some of the sites:

Check out the sites and the code.. and if you have any questions about what you can do with the Windows Live Platform just shoot me an email - jason at jasonkelly dot net.

Zynga makes bank; Facebook apps still have VC potential

Jason — Wed, 23 Jul 2008 05:05:00 GMT

I read about Zynga's $29 million round of VC funding [wsj.com] just after getting home from Bill Bryant's StartPad presentation "Venture Capital - The Good, Bad and Ugly". Considering that just last week I was reading about VC's going dry on Facebook apps, the timing couldn't be better.

Zynga seems to have found the magic formula - build a simple, immersive experience that Facebook is not likely to copy. Games are just the ticket - they are getting tons of casual gamer eyeballs and keeping those eyes glued to the game for long periods. There's no better ad opportunity on Facebook.

What about Zynga's next step - are they going to really push their developer platform? They have the chance to be a huge casual gaming platform, but their big Series B round must be going chiefly to developing new first-party games. It'll be interesting to see what happens with the third-party story.

"Venture Capital Unplugged" at StartPad in Seattle

Jason — Sun, 20 Jul 2008 21:57:00 GMT

I've trying to learn everything I can about starting up a new business. Along the way, I'd like to get acquainted with those who've done it and those who are in the business of funding it.

Along those lines, there's an interesting event coming up at StartPad:

Venture Capital Unplugged - The Good, Bad, and Ugly
http://startpad.org/countdown/venture-capital-unplugged-the-good-bad-and-ugly
When: 6:00 pm, Tuesday, July 22, 2008
Where: StartPad offices, 811 First Avenue, Ste. 480, Seattle

Hope to see you there if you're interested too...

SocialMediaCamp Presentation on Data Portability

Jason — Mon, 14 Jul 2008 00:52:00 GMT

Here are the slides from my presentation on Data Portability at Social Media Camp Seattle.

It was my first BarCamp presentation and I'm really glad I did it. It's a great format, especially because it was so easy to get a conversation started. Instead of the standard "presentation followed by Q&A", it was more like as the presenter, I was spurring a discussion.

Looking forward to the next one!

Who's at Social Media Camp Seattle?

Jason — Sat, 12 Jul 2008 20:28:00 GMT

I'm sitting at Social Media Camp in Seattle.. It's an approachable, intimate group of about 75 people, most wandering between the two presentation rooms and the open space in the middle. There's a nice buzz going on about social media. It seems like everyone here is either working in a startup, revving up their own startup, or (like me) just about to make that commitment to get something started.

The BarCamp format is ideal for this kind of gathering. Those who probably wouldn't take the mantle of presenting at one of the big conferences are getting up and sharing what they're working on and what they are passionate about. It's just the kind of place for a recalcitrant presenter like me!

I'm bummed that I already missed BarCamp Seattle 2008. I'd love to go to a more targeted BarCamp in Seattle later this year.. any pointers? Or do you want to set one up? Drop me a line.

Social Media Camp - I'm presenting in Seattle

Jason — Fri, 11 Jul 2008 19:10:00 GMT

Tomorrow (Saturday, July 12, 2008) is Social Media Camp in Seattle. Social Media Camp is a BarCamp targeted to those interested in Social Media and community-based marketing.

I've never even attended a BarCamp, but I figured I should just go boldly into it... So I'm presenting a session on Data Portability. I've recently started singing the praises of Data Portability, because I'm feeling a growing sense of ownership of my social data. The tools being built out there to create and share social data are changing the world, for sure. But they're just tools, after all. The data we create has a life of its own beyond those tools - and we should be able to do with it as we please.

The benefits of Data Portability go far beyond the ideals of freedom and ownership - it presents great business opportunities as well. Yoono is the primary sponsor of Social Media Camp, and they probably wouldn't even exist if it weren't for the fledgling efforts the big social media companies have made toward portability.

The most passionate supporters of Data Portability put together a working group - The DataPortability Project - to encourage services to use open standards. Many of the big companies in this space have joined the group (deep breath... LinkedIn, Twitter, Flickr, SixApart, Google, Facebook, Microsoft, et al). So if you care about Data Portability, throw a little support behind The DataPortability Project; they have the attention of the big guys.

Time for Visual Studio 2008

Jason — Tue, 30 Oct 2007 06:04:00 GMT

It's time to download VS2008 Beta 2. While I've done plenty of coding in .Net 2.0, for the past couple of years I've been heads-down on a project that is a little bit stuck in the past. We have millions of lines of code targeting version 1.1 of the framework, running 24x7 in our production datacenter - which means much of my day-to-day work has been in VS2003. After VS2008 releases we're going to make the big upgrade to v3.5 and VS2008.

Here's what I'm looking forward to trying out tonight:

Multi-targeting support - not having to start up a completely different toolset just because I'm maintaining an older app will save so much time.
JavaScript Intellisense and Debugging - it's about time!
LINQ - we have a great solution for generating stored-procedure wrappers, but I look forward to be able to concisely express data logic in my applications.

Let's give it a run!