Jake Opines

Beauty is only Skin-Deep: Skinning your WinForms Application

2008-05-09T15:00:00Z

We all want our Windows applications to stand out, and I think most people would like to believe that there are a few distinct approaches to achieving this. You can either have an app that does great things, one that does things great, or one that does things while looking great. The ideal approach is to combine all three and make great applications that do things very well while looking amazing. The first impression is everything, right? So this post is all about how to skin your application. While I can't turn you into Monet, I can show you what a paint brush looks like.

Eat Your Cake Without Having to Wait for Your Oven to Preheat

There are toolkits out there that allow you to skin your apps very easily like DotNetSkin or Sunisoft's IrisSkin, but most of them cost money and all you might want to do is change a few things without overhauling everything that is Windows UI.

Replacing Your Lamp Because Your Light Bulb Burnt Out

Alek Trebec - "Answer: All the things that make windows behave like windows."

Contestant - "What are 'things I took for granted'?"

Just a forewarning: you are opening somewhat of a can of worms here; albeit a small one. When you skin an app, there will be many things that you got for free before but will now have to do yourself. Window-close, -minimize, and -maximize are gone but easy enough to correct.

Window dragging requires a little bit of finesse and window resizing requires a bit more. I'll explain all that with sample code below, but first, let's talk about getting rid of that awful XP-blue menu-bar.

Removing the Menu-Bar

After you have your project set up and are looking at your form in design-time. Open the Properties pane form the main form object. Here, you need to find the Appearance labeled "FormBorderStyle". Change it from "Sizable" to "None". You will notice that in the design, your top menu bar and the border of the window are now gone! Excellent, a clean slate.

Readding Basic Window Controls

You can add all or none of these, but I suggest (for the sake of your users) that you at least add a close button. Here's what you do.

Create a button in the upper right hand corner of your form; the location is by convention, you can put it anywhere you'd like of course. Change the name of the button to closeButton and double-click it so that Visual Studio brings you to the code view and creates you a OnClick event handler. Add the following code to it:

private void closeButton_Click(object sender, EventArgs e) { Application.Exit(); }

Very simple.

Minimize

Create another button on your form and change its name to minButton. Double click it to open code view to its OnClick event handler. Add the following code to that one:

private void minButton_Click(object sender, EventArgs e) { WindowState = FormWindowState.Minimized; }

Maximized / Normal

There are two ways to do a "Maximize" button because you either have to change the button after it is maximized to a "Normal" button or you have to make the button's label generic enough that the one button can be used for both tasks. To keep things simple, we will do the latter.

Create a button and change its name to maxNormButton and double click it like the last two examples. Add the following code to your event handler:

private void maxNormButton_Click(object sender, EventArgs e) {

if (WindowState == FormWindowState.Maximized) { WindowState = FormWindowState.Normal; } else { WindowState = FormWindowState.Maximized; } }

I will leave creating that generic-enough label up to you because I can't really think of anything right now. How about a ~ (tilde). That's never used enough.

Moving that Window Around

To move your window around, you will need to handle the mouse down event as well as the mouse move event. We'll have to do some simple math to determine the offset from where the mouse was clicked to where it is after it has moved. But before we can do anything with that, we need to add something to the form to grab on to.

You can either add a PictureBox or a Panel to your form. If you're looking to put something other than a solid color in the area, you'll want to go with the PictureBox, otherwise just drop a simple Panel up there and change it's BackColor property to something other than Control-gray. I will be using the Panel in this example.

Add a Panel to your form and stretch it the length of your form placing it along your top edge. You can even Dock it on the top if you'd like, but if you want to add rounded corners, you wont want to do that. Change the name of the panel windowbarPanel.

Right click on your form and choose View Code. We need to capture when the user mouses down on your menu bar. Add a MouseDown event handler to the constructor of your form.

windowbarPanel.MouseDown += new MouseEventHandler(CaptureMouseDown);

The function that will handle the event, void CaptureMouseDown, needs to save the mouse's position relative to your form's upper left hand corner. And it should only do this if the left mouse button is pressed. Create a private member variable _OffsetPoint of type Point to store your mouse position in. In the end, it should look like this:

void CaptureMouseDown(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) _OffsetPoint = new Point(e.X, e.Y); }

Next we need to handle when the mouse is moved. Add a MouseMove event handler to the constructor of your form.

windowbarPanel.MouseMove += new MouseEventHandler(MoveWindow);

The function that will be handling this event, void MoveWindow, needs to offset the mouse's new position against it's MouseDown one and set the location of the window to that point. Again, only if the left mouse button is being pressed. Here it is:

void MoveWindow(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) { Point mousePos = Control.MousePosition; mousePos.Offset(-_OffsetPoint.X, -_OffsetPoint.Y); Location = mousePos; } }

Save it and build it and you've got yourself a form that doesn't have traditional Windows form borders but behaves a lot like one! Now, if only we could resize this thing...

Resizing It

In traditional WinForms, you can grab any edge of a window and resize it. That's more than I want to get into in this post, so I'll only go over resizing your form from the lower left hand corner of the screen.

In design-view, create a Panel in the lower left making it the size of your desired click area. Mine is about the size of an eraser head. Name it resizePanel.

In code-view, you need to capture the position of the mouse relative to the screen with a mouse down event handler and save the current size of the window. You'll have to create new member variables for the window's width and height (they're of type int) but we can reuse the _OffsetPoint from before since you can't resize and move a window at the same time. In the constructor of the form, add the following:

resizePanel.MouseDown += new MouseEventHandler(CaptureMousePosition);

The CaptureMousePosition method should look like this:

int _Width; int _Height; void CaptureMousePosition(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) { _Width = Width; _Height = Height; _OffsetPoint = new Point(Control.MousePosition.X, Control.MousePosition.Y); } }

Next, we need to set the width and height of the window every time the MouseMove event is fired. Add the following line to your form's constructor:

resizePanel.MouseMove += new MouseEventHandler(ResizeWindow);

The ResizeWindow method needs to figure out how far the mouse has moved and apply that to the width and height of the form. It should end up looking like this:

void ResizeWindow(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) { Point mousePos = new Point(Control.MousePosition.X, Control.MousePosition.Y); mousePos.Offset(-_OffsetPoint.X, -_OffsetPoint.Y); Width = _Width + mousePos.X; Height = _Height + mousePos.Y; } }

That's about it. It could definitely use some work, but it's a great start.

Just to Recap

With the information above, you can now create applications that have custom border elements. We had to rewrite the most basic window functions, but that's OK. It wasn't that painful. I hope to see better-looking WinForm applications from all of you. The only piece that's up to you is embedding beautiful Photoshopped graphics for all of your buttons and borders.

Update

I've added some pictures that go along with the process. Also, here are a few notes about anchoring your new elements correctly. If you don't correctly anchor, your resizing will not work correctly.

Your close, minimize, and maximize buttons should be anchored to the upper right. Your windowBarPanel should be anchored to the left-top-right so it stretches accordingly. Lastly, your resizePanel should be anchored to the bottom right so that it moves with your mouse as you resize.

Here's a sample project that does everything we've talked about in this blog:

SkinFormsBlog.zip

Writing Custom NAnt Tasks

2008-05-07T17:23:00Z

Working as a Build Engineer for about 9 months, I've had the opportunity to push NAnt build scripting to the limits. Our DotImage product is made up of both managed and unmanaged code, third party libraries with .NET wrappers, code that sometimes differs from .NET 1.1 to .NET 2.0 (both x86 and x64) and a slew of other complications. In addition to that and the multiple systems it takes to put it all together, there comes a time where a custom solution might be the best way to do things. In the world of NAnt scripts, this can come in many forms, but personally I prefer to stay away from batch files and calls to the command-line. In my mind, the most elegant option is to write a NAnt task.

For most things, NAnt tasks already exist and can be found at either their official website or at the NAntContrib sourceforge project, but it may surprise you that one of my first projects at Atalasoft was to create a NAnt task for integrating with Team Foundation Server.

We had been using Visual Source Safe so the vssget task served us well for a long time. When we migrated to TFS, we were essentially left hanging and had nothing to go on but settle for a few batch scripts that handled the task pretty well. Needless-to-say, five or so calls to tf.exe (the Team Foundation command-line utility) is not as easy to maintain as one task in a NAnt script.

In this post, I will walk you through creating a custom NAnt task with some more "advanced" features, such as adding nested elements and setting a return value. Then, in the near future, I will post my code for the tasks that I've written including tfsGet, tfsCheckOut, tfsCheckIn, removeSourceControlBindings, and others. You'll then be able to add them to your build systems and get all of the same TFS goodness that we do. I might even add them to NAntContrib as well.

Design your Task

Before I start writing a task, I like to have a good idea of what it will look like and how it will behave in a NAnt script. In the case of TFSGet, I decided to model it after the VSSGet task which is in NAntContrib.

This is what the VSSGet task looks like:

<vssget verbose="true" username="user" password="pass" localpath="." recursive="false" replace="true" writable="true" dbpath="\\path\to\srcsave.ini" path="$/path/to/project/location" />

and this is what my TFSGet task looks like:

<tfsget server="servername" ssl="false" port="8080" projectPath="$/path/to/project/location" localPath="." recursionType="None" getOptions="Force"> <source path="*" /> </tfsget>

Since I wrote it last year, Dave Terrell, our Build Engineer has made a few important additions such as non-default network credentials as well as the ability to return a changeset number back to the NAnt script. With these new changes, the task looks like this:

<tfsget server="servername" username="user" password="pass" ssl="false" port="8080" projectPath="$/path/to/project/location" localPath="." recursionType="None" getOptions="Force" changeset="changeset"> <source path="*" /> </tfsget>

Let's Get Started

Open Visual Studio and create a new project. NAnt tasks start their lives as Class Libraries, so that's the template that we'll choose. For this example, I'm going to create a project called TFS since it will hold all the tasks related to TFS. I might want to add more tasks in the future that aren't related to TFS so my overarching solution will be called Tasks.

After your project and solution appear in the Solution Explorer, we need to rename the Class1.cs file to TFSGet.cs. Visual Studio may ask you if would like Visual studio to rename all references to Class1 in the project to TFSGet. Say Yes, otherwise do it manually.

Before we get started writing any code, we need to reference NAnt.Core.dll. That assembly is located in the directory structure of your NAnt install right next to NAnt.exe. Once you've done that, add the appropriate using statements to the top of your TFSGet.cs file.

Five Steps to Success

To define a NAnt task, there are five things we need to do:

Define the name of the task using the TaskName class decorator.
Extend NAnt.Core.Task.
Create any attributes and label them with the TaskAttribute property decorator.
Override the ExecuteTask method.
Make sure you're output assembly ends in Tasks.dll.

The Basic Layout

Here's the skeleton for our TFSGet task:

// using ... using NAnt.Core; using NAnt.Core.Attributes; // ... namespace TFS { public class TFSGet : Task { #region Task Attributes

private string _server; [TaskAttribute("server", Required = true)] [StringValidator(AllowEmpty = false)] public string Server { get { return _server; } set { _server = value; } }

// ... other attributes ...

#endregion

#region Execute

protected override void ExecuteTask() { // The Leg Work }

#endregion } }

With this basic model, you can write almost any task you can think of. There are two other important concepts that this particular task employs and you should know about them and how to use them. One is returning values and the other is nested attributes. I'll explain return values shortly, but nested attributes are a bit more complicated and deserve a dedicated post. I will leave that to Dave to explain further. He's written about writing NAnt tasks with nested types as well as extending NAnt with your own types.

Using "Project"

Project gives you access to the currently running NAnt script. This is essentially the parent of your NAnt task. With it, you can log events, warnings, or errors. You also have access to properties within the project allowing you to return values from your task to the outer build script.

In the case of this example, it is incredibly useful for the build script to know the changeset of the code we got from TFS. In the script, we can then use that number to ... maybe set the version number of our assemblies for quick debugging if a customer has a question. If they give us that, we can instantly see the code that their running without having to think about it. Currently, our assembly version numbers at Atalasoft are:

6.0.<randomish number bigger than the last build>.<randomish number>

For future versions of our product we are working toward version numbers like:

x.0.<number representing the letter of the build>.<changeset number>

For example, if you called our office with a question about your 6.0.0001.38983 assemblies, we would instantly know that you are running 6.0a and we can get changeset 38983 from source control and read exactly what you've got.

Setting project properties is very simple. To set a property, you simply set the value of item indexed by the property you are setting. That was a mouthful... If you are trying to set the "changeset" property, this is what you would do:

Project.Properties["changeset"] = value;

That's it!

Logging is just as easy. To log you simply call:

Project.Log(Level.Info, "Your logged message goes here");

That message will now appear in the console if you're running your NAnt script via command line. It will also appear in your CruiseControl logs if you're using that to manage your Continuous Integration process.

Deploying a Custom Built NAnt Task

To deploy a custom NAnt task, you simply need to put it in the NAnt directory next to the nant.exe and NAnt.Core.dll that you will be running it from. The next time you call nant.exe, your newly built task will be loaded and available to be scripted against.

The Code

Here's the code for this task in full and here's a link to a prebuilt assembly. You will need to download and install NAnt and you may or may not have to download and install Visual Studio TeamFoundation Server SDK for access to the Microsoft.TeamFoundation namespace items.

Check back in the future for more NAnt tasks and be sure to read Dave's articles on using nested types as well as creating your own.

Presenting at the Western Mass.NET Users Group

2008-05-05T12:59:00Z

I will be doing a presentation on build automation using CruiseControl and NAnt at the Western Mass .NET Users Group meeting on May 6th at 6pm.

The presentation will cover the basics of CruiseControl and NAnt as well as developing custom tasks to stretch this already flexible framework even further.

Writing Custom Web Services for SharePoint Products and Technologies - Microsoft Typo...

2008-04-26T17:22:00Z

Writing a custom web service for SharePoint, I ran into these two great articles which walked me through the process, but it still wasn't enough to tame the beast. Check out Writing Custom Web Services for SharePoint Products and Services on MSDN and Creating a Custom Web Service for SharePoint on ITToolbox, but take heed; there are typos that will burn you. I'm contacting the authors of these articles and will post here again once they are fixed. For now, here is what I did to get past them. Join me in a journey of pain followed by triumph.

I started off my webservice-writing extravaganza by modeling it directly after the example at MSDN. I was able to get pretty far. I had my disco, wsdl, dll, and asmx files, and placed them in the mapped _vti_bin directory like a good doobie. I registered the assembly as a safe control and added it to the spsdisco.aspx file as the tutorial said, but no luck. I kept getting the vanilla error page produced by SharePoint. I looked through my Error log to find nothing and went back to staring at the seemingly useless error page. Then, ah yes, look at the url. It ain't pretty, but the URL in the address bar had some useful information. What a convenient place to put that!

This is what I had to go on: http://localhost/_layouts/error.aspx?ErrorText=File%20Not%20Found%2E

I ran Procmon and found out that SharePoint wasn't looking for the assembly where I thought it would. To prove that right, I assumed... put it in the GAC. I know, not the best practice, but I wanted to get it working and then fix it for real later.

I dragged my assembly into %WINDOWS%\assembly only to find out that my assembly was not signed. This is a necessary step to getting your stuff to work with SharePoint. So after signing it, I put it in the GAC, only to get the same error...

I ran Procmon again and found out that SharePoint wasn't looking in the GAC either! Interesting... I then did some Googling and found the article on ITToolbox. It was basically a revamped version of the article on MSDN. This article gave a few options of where you could/should put the assembly and I settled on the bin of the virtual directory I was deploying to. The asmx file loaded in IE! I was in the clear! Right? ... Wrong.

I opened the project that would be using the service, attempted to add it as a Web Reference and it errored out. I tried to load Service1wsdl.aspx up in IE and I got another URL based error saying, "the given assembly name or codebase was invalid exception from hresult 80131047 sharepoint web service". Ok, something with more substance at least. There must be something wrong in the wsdl file.

The best thing I felt I could do in this situation is examine every line of the wsdl (there are only 4, heh). I compared it directly to one I knew was working; the Microsoft-provided Listswsdl.aspx file for the Lists web service.

Here's the first line of my file:

<%@ Page Language="C#" Inherits="System.Web.UI.Page" %> <%@ Assembly Name="Microsoft.SharePoint, Microsoft.SharePoint, Version=11.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Import Namespace="Microsoft.SharePoint.Utilities" %> <%@ Import Namespace="Microsoft.SharePoint" %> <% Response.ContentType = "text/xml"; %>

And here's the first line of the Listswsdl.aspx file:

<%@ Page Language="C#" Inherits="System.Web.UI.Page" %> <%@ Assembly Name="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Import Namespace="Microsoft.SharePoint.Utilities" %> <%@ Import Namespace="Microsoft.SharePoint" %> <% Response.ContentType = "text/xml"; %>

There are two differences here. The version number in the first snippet is 11.0.0.0 while it is 12.0.0.0 in Microsoft's (this actually doesn't matter because there are version redirects in the SharePoint web.configs) and the assembly name incorrectly includes the namespace when it is already mentioned in the later Import statements.

...Name="Microsoft.SharePoint, Microsoft.SharePoint, Version...

should read

...Name="Microsoft.SharePoint, Version...

Thanks Microsoft, that was your bad. Maybe that flew with Version 11.0.0.0, but 12.0.0.0 no likey.

Excellent. The wsdl loaded! Before I got too excited, I opened the disco file in Notepad to make sure that Microsoft didn't burn me there too with the bad Assembly Name tag. They did, I fixed that and moved on.

I tried to load the disco in IE and ugh, another error: httpresponse.output cannot be assigned to it is read only. With this new tidbit, I decided to look for all the references to response.output in the disco file and compare it to the same references in the Listsdisco.aspx file that Microsoft wrote.

This was my disco file:

<contactRef ref=<% SPHttpUtility.AddQuote(SPHttpUtility.HtmlEncode(SPWeb.OriginalBaseUrl(Request) + "?wsdl"),Response.Output=""); %> docRef=<% SPHttpUtility.AddQuote(SPHttpUtility.HtmlEncode(SPWeb.OriginalBaseUrl(Request)),Response.Output); %> xmlns="http://schemas.xmlsoap.org/disco/scl/" /> xmlns:q1="http://tempuri.org" binding="q1:FilesSoap" xmlns="http://schemas.xmlsoap.org/disco/soap/" /> xmlns:q2="http://tempuri.org" binding="q2:FilesSoap12" xmlns="http://schemas.xmlsoap.org/disco/soap/" />

and this is the fixed copy after comparing it to the Listsdisco.aspx

<contactRef ref=<% SPHttpUtility.AddQuote(SPHttpUtility.HtmlEncode(SPWeb.OriginalBaseUrl(Request) + "?wsdl"),Response.Output); %> docRef=<% SPHttpUtility.AddQuote(SPHttpUtility.HtmlEncode(SPWeb.OriginalBaseUrl(Request)),Response.Output); %> xmlns="http://schemas.xmlsoap.org/disco/scl/" /> xmlns:q1="http://tempuri.org" binding="q1:FilesSoap" xmlns="http://schemas.xmlsoap.org/disco/soap/" /> xmlns:q2="http://tempuri.org" binding="q2:FilesSoap12" xmlns="http://schemas.xmlsoap.org/disco/soap/" />

Notice anything?

...Response.Output=""...

should read

...Response.Output...

This was in the example provided by the ITToolbox site. I'm not sure when I decided to go with their example for that line, but I did... and got burned.

After that last fix, the disco loaded in IE without a problem and I was able to add the service to my project as a Web Reference without a problem.

Code Camp 9: Thoughts and Impressions

2008-04-07T12:25:00Z

This weekend, along with 4 other Atalasoftians, I went attended Code Camp 9 at the Microsoft offices in Waltham, MA. The content was diverse and the presenters were very knowledgeable. The coolest part is that the idea of Code Camp is that all the presenters are regular people like you and me (albeit very good at what they do). For the most part, they aren't Microsoft employees loyally spewing their Corporate Kool-Ade, not that that is always a bad thing. They are experts in their fields, showing what they do with Microsoft's technology and other .NET-ish related techs.

Here's a list of all the sessions I attended with a brief summary of what they were about and what I took away from them:

Extending Powershell
Presented by Lou Franco

Before this presentation, I can say I knew nothing about Powershell. Because of it, I'm in the process of downloading and installing it as I type this. It's pretty darn powerful. Here's Lou's blog with notes from his presentation and all of the code that he used.

Real World httpModules and httpHandlers
Presented by Chris Love

I have an unrealistic burning desire to personally make Comet efficient in IIS, and I have an inkling that a custom httpModule will do the trick with maybe a Windows service running in the background as well... but isn't that something like rewriting IIS? Possibly, but that isn't what this presentation was about. Chris went over the basics of putting together custom httpModules and handlers to do things such as url rewriting and building and serving out vCards and PDFs on the fly. Very cool stuff.

"Shall We Play a Game?" - An Introduction to Game Development with XNA
Presented by Chris Bowen

Anyone who can write Pong in 20 minutes deserves some serious kudoz. Using the XNA toolkit, he was able to walk us through the process of setting up the logic and display for the entire game with sound and "AI". Ok, no AI, but still very cool.

Wpf Means Business II
Presented by Michael Hennessy

One benefit, to me, of using WPF is it's extreme similarities to web development. I don't have much (if any) experience in writing applications that leverage WPF, so this presentation was mostly an introduction for me.

Object Relational Mapping, an Introduction to NHibernate
Presented by Rik Bardrof

NHibernate is a .NET port of Java's Hibernate that maps an object-oriented data model to relational data structures. This presentation was filled with great information about how to set up your projects to basically build the data structures for you, however, a lot of the work seems to be translated away from writing DB create statements into writing xml descriptions of those data structures. Seems like the same amount of work for a similar result, but maybe I am missing something. Products like Django do a lot of this work for you already, so why can't NHibernate?

Extending Your Applications Using Dynamic Languages
Presented by Michael Cummings

Michael talked about how IronPython and IronRuby and how they can be used to extend current applications. He used an example of a capture the flag game where you could update the intelligence of the players (all AI) using IronPython and see the results right away. These scripting languages can allow your customers to leverage your product in ways you couldn't have imagined, extending their usefulness.

Introduction to Design: The Power and Glory of the User Experience
Presented by Michael de la Maza

This was a pretty cool presentation. He's at Code Camp, not design camp, so his take-away message was that there are people out there who are actually good at design and that they should be hired. Just like engineering your code and engineering your data structures, you must engineer your users' interaction with it. Users don't care that your database is fully normalized, they just care that the information is there and is accurate. They don't care that you're using WPF and that the interface is vector-based, they just want it to be able to scale to their brand new 30 inch HD display. Michael broke the session-goers into two groups whose jobs were to develop the user experience for a computerized version of Tic-Tac-Toe. This was a very successful way to get people who probably don't think about what users want very often to do just that. I think the only flaw was that our group didn't realize the target audience was the other team and instead decided to talk about two separate designs instead: one for kids and one for adults with 3 minutes to kill.

Test Driven Development w/TestDriven.net and nUnit
Presented by John Baird

I'm a fan of crude humor, and John didn't fail to deliver. His great talk on a test driven development process and how to use nUnit was sprinkled with boisterous yelling and possibly inappropriate jokes that I found hilarious. Atalasoft is an agile shop so John was preaching to the choir on this one (well, only if the choir was made up of the three Atalasoft employees there, because the rest of the crowd was still living in dark ages of simple bench testing). He walked through the benefits of the agile process and how you can cut programming time down from 7 days to 4 while adding in 3 days of test implementation. It's a hard concept to wrap your head around, but it's the truth. Those 3 days you're implementing tests, you're actually writing the actual code in your head, making the job of actually putting it into Visual Studio wicked crazy easy.

"Bad, IIS. Bad!" - Forcing IIS to run your site in .NET 2.0

2008-04-03T14:43:00Z

I was working in IIS, today, and came across an issue where it was attempting to load my site in ASP.NET 1.1.xxx. I, for one, know that the site I was deploying was built as a precompiled web from VS2005, which, as far as I know, means that it's .NET 2.0 for sure. I also knew that all of the assemblies I was referencing were .NET 2.0 and the web config had all the appropriate .NET 2.0 love.

The first thing I did was search around IIS to see if there was a way to beat it into submission and force it to run the site in ASP.NET 2.0. No luck... I believe the newer versions of IIS have this functionality, because I swear I've used it before, but I wanted to deploy now!

After a bit of searching, I came across this great little utility called ASP.NET Version Switcher that saved me a boatload of time by Denis Bauer. It shows all of the sites in IIS and easily lets you switch the .NET Framework version for any one. Granted, it just runs the command line utility that I'm sure is easy enough to figure out, but GUIs are nice too.

AJAXWorld '08: Thoughts and Impressions

2008-03-26T11:52:00Z

This was my second conference as an Atalasoft employee and I must say, 'I have terrible luck.' Back in September, I went with my coworker Rick to ReMix in Boston and, while I can't speak for the both of us, I was largely unimpressed. The content was definitely geared towards a different audience: the sessions progressed very slowly and the demos were more than basic, not showing much at all. To its credit there were excellent keynotes by Microsoft about Photosynth and Miguel de Icaza about Mono (a near-complete .NET implementation for the Linux platform). They both entertained and gave me a lot to take away. Also of note, MLB was there as well showing off their new digs. And it's always good to throw in a plug for the caterers which provided amazing food. Simply amazing.

When I heard that I would be attending AJAXWorld a few months ago, I was pretty excited. I thought it would be bigger than ReMix and attract even larger contributors, like Google-Microsoft-Yahoo-Adobe. It was in NYC, so that's always a plus if you like being in the city (which I do), and its title gave the impression that there was more focus on AJAX and advanced zero-footprint technologies and not just web development. Boy, as I wrong. There seemed to be a similar number of attendees (but all of the small conference rooms were overflowing), the only large companies were Microsoft and Yahoo (Adobe was a sponsor but was never seen and Google must have had better things to do). Vague presentations on Bayeux (a Comet protocol implementation) and an iPhone SDK session (yep, no AJAX here) failed to impress. Apple's NDA certainly didn't help the latter.

Ok, that was my rant, now I'll go over all the sessions I was able to attend and give credit where it's due. I attended the conference with Dave Cilley, who posted his blog the other day about the event and what he thought about it. He attended a few different sessions than I did, so it's definitely a good read.

Tuesday, March 18th

Session 1: Comet - The Web That's Instantly On and Always On
Presented by Jonas Jacobi

The concept is simple. Using a few different techniques, you simply make a request from the client to the server and the server doesn't respond until they have the answer. Because they respond at the moment they have the answer, the client receives feedback the moment it is available and not 5 seconds too late in the case of polling. It gives you a way to build truly event-driven applications using a publish-subscribe pattern instead of being based on Request-Response like almost all current-day AJAX applications.

This presentation on Comet became a talk about server load and faux-multicasting data back to clients. While this is definitely a crucial part of Comet, since you are keeping persistent connections open to each of your clients instead of dropping them every time you answer a request, I don't feel it should have been the focus of this session.

Session 2: ASP.NET AJAX Design & Development Patterns
Presented by Joe Stagner

Joe is a very good presenter, and he brings good demos to the table as well. This presentation put focus on the ASP.NET AJAX Toolkit provided by Microsoft and some best practices when using it. I'm glad he took some time to point out that while it's really easy (and maybe tempting) to use Update Panel, you should do it in very few situations. Because the Update Panel is a do-it-all control, it just posts back the entire page and all of it's data in the background. The server is smart enough to only respond with what is necessary, but there is a lot of overhead in using it. Once the data gets back to the client, Update Panel does its job in shoving the changed content back where it belongs.

He also showed us a text editor called ConTEXT which I will have to look into more.

Session 4: Improving ASP.NET User Interfaces with the AJAX Control Toolkit
Presented by Robert Boedigheimer

I've played with this toolkit before, so it was a nice overview, but there wasn't really anything new for me to see here. ASP.NET AJAX is a great way to create web apps with some AJAXy goodness without having to learn Javascript. One thing Robert pointed out that I wasn't aware of is that you can actually download the source for the toolkit and edit it. Microsoft even provides customers with an snk file so they can sign the assembly for deployment! Granted, whenever you make a change, just know that you're going to either have to support it every time you upgrade to a new version of the toolkit, or you'll have to convince the writers to add in your fix later.

Wednesday, March 19th

Session 1: Can We Fix the Web?
Presented by Douglas Crockford

Douglas created JSON so he obviously knows what he's talking about. This opening keynote (at 7:30am!, ouch) proposed that we need to completely start over on the internet. It was written for static sites with static content that did nothing but bring text to the web. Today, we are trying to build highly dynamic applications that allow us to use the web in ways it was certainly not intended to be used. Sure, he makes a good point. Web development is hard, and Javascript is insecure, and its potential successor is seriously flawed by being entirely backwards compatible, but do we have a choice? When Microsoft releases a new operating system, they risk destroying every application that was every written for it. We have to take this in steps, but Douglas understands that. His presentation was bold for a purpose, to get us thinking about the urgency of the issue and take the steps toward fixing the problem. Here are some of his suggestions in how we might move forward:

Advertisers should conform to a subset of Javascript called AdSafe. Currently, ads have full access to the DOM and can potentially wreak havoc on any site hosting them. When asked why Yahoo doesn't lead this front, he explained that it will require support from all major online advertisers (Yahoo, Microsoft, and Google) to adopt this standard before it is a viable solution. If any one adopted it first, not only would the standard fail, but that company would see incredible drops in its advertiser base.
Firefox needs to stop doing evil things with Javascript.
Google Gears and Adobe AIR (and others) should and use create a common communication protocol.
IFrames must be eliminated entirely.

Web development is like Turducken.

Session 3: Developing AJAX Applications for iPhone and iPod Touch
Presented by Kevin Hakman

Kevin works for a company, Aptana, which develops an IDE for AJAX development. It's offered in two forms: a plugin to Eclipse as well as a standalone application, and it has support for Mac OS X, Windows, and Linux which is nice.

For iPhone development, Aptana offers an iPhone emulator and also works directly with the iPhone simulator provided by the iPhone SDK offered for the Mac platform. It provides code completion and some pretty solid debugging features for javascript development.

In addition to the IDE, Kevin talked about a javascript web server called Jaxer. He didn't mention its performance, but it basically allows you to write all of your code (client and server) in the HTML file and use runat attributes in your script tag to specify which end it's destined to run on. You can easily create server-proxy functions (AJAX calls) inline with your javascript without knowing anything about XmlHttpRequest or other AJAX techniques. Very slick.

Session 4: Real-Time, Real-Time, or Real-Time Web 2.0?
Presented by Jonas Jacobi

This was essentially a condensed version of the first session we went to on day 1.

Session 5: jMaki as an AJAX Mashup Framework
Presented by Arun Gupta

This was very interesting. In addition to providing a framework for developing AJAX Mashups, they allow you to abstract away objects from different libraries and allow them to interact with one another "seamlessly". The "j" in jMaki stands for Java, I'm assuming, so I'm not sure how much use I'll get out of it in ASP.NET-land.

Session 7: HTTP Multicast Routing, Scalling the Real-Time Web
Presented by Ric Smith

This went deeper into the way HTTP "Multicasting" works and how it could be implemented. I don't think he needed to go into Comet at all, since it was just another overview with no code, but at least in this presentation, we learned that there was a reason for why it was so vague... Bayeux is in private beta and they couldn't show us any code. I'm a big fan of demos, so this was definitely a disappointment.

Session 9: RIAs with Comet and Critical Updates in Enterprise Environments
Presented by Emil Ong

The only reason why I went to this session is because the presenter was not from Kaazing (the other three Comet prezos were). I have nothing against Kaazing or their products, they just wouldn't show me any cool code because they're in Private Beta. Emil showed off some neat stuff and with his diagrams of how their SDK worked, I was able to better understand how I might implement a Comet solution. Again, the only problem I see here from my perspective is that it's for Java and I work in a .NET shop.

Thursday, March 20th

Session 2: Introduction to the iPhone SDK
Presented by Kevin Hoffman

As I mentioned in my rant, the lack of content in this presentation is not Kevin's fault. He's just honoring the NDA he signed (like the rest of us that downloaded the iPhone SDK) stating he could say nothing about it. Most of his presentation went over the limitations of the SDK and focused on re-showing us what happened at the event where Apple launched the public beta program. One thing that threw me for a loop was hearing that to debug your application, you either need to rely completely on the iPhone simulator, buy an iPod touch, or sacrifice your iPhone! That's right, in order to test your application, you need to install a special version of iPhone software that removes the phone functionality and Edge connectivity, presumably making AT&T happy. According to Kevin, the License Agreement states that there's no guarantee that your iPhone will ever be the same again...

Session 3: Now Playing - Desktop Apps in the Browser!
Presented by Coach Wei & Bob Buffone

This was purely entertaining at the expense of the presenters. They went back and forth in a "tightly orchestrated" dialog that was so corny it made me laugh. I would tell you more about what they had to offer, but I stopped listening when they posted the text "That's Retarded" on the big projector. It was in response to something scriptedly-stupid that his fellow presenter said. While, in context, this could be seen as funny, but my girlfriend is a special needs teacher in a middle school and I have certain feelings about using these words out of the realm of diagnosing a person with mental disabilities.

Session 4: DreamFace - The Ultimate Framework for Creating Personalized Web 2.0 Mashups
Presented by Oliver Poupeney

This was, by far, the most visually-interesting presentation of the entire conference. Through the web interface, he put together a demo workflow right in front of us. It was very impressive to see how a user could tie a web service to a functioning widget and serve it into a mashup.

Session: The Digital Black Belt's Guide to Building Secure ASP.NET AJAX Applications
Presented by Joe Stagner

Both of the presentations he gave that I went to, he started things off with a quote from Einstein: "The problems that exist in the world today cannot be solved by the level of thinking that created them." I found a few versions of that quote online and just picked that one... so if it's not the real Einstein quote then, "I'm sorry, Albert."

But isn't that why we're at this conference? So that we can all put our heads together and become smarter than our past-selves who created these problems in the first place?

Joe showed us some cool tools like WebScarab and put some good examples on the projector that can get people thinking. The big ones were about injecting javascript into SQL making that code run at a later time for someone else that visits the site. Very cool, but easy to defend if you go through the process of never trusting anything that comes into your site like Joe suggests. That's a good rule to live by.

Putting the Post on a Pedestal

2008-03-25T19:04:00Z

I’ve wanted to start a blog for a long time now, but whenever I have time to do it, I always convince myself to put it off until next time. Being my first post, I’d like to tell you all a little about myself and what I’d like to bring to the Blogosphere.

My name is Jacob Lauzier and I am a Software Engineer, here, at Atalasoft in Easthampton, MA.

My previous title was Software Systems Engineer, dealing with build issues and making sure software releases went out on time and in tact. During my transition into the world of AJAX development I’m sure I’ll keep my hands in builds for at least a while. You’ll even see that transition unfold here as I talk about my work toward contributing to the NAnt community as well as my experiences at AJAX World '08.

I hope to be writing again very soon.