Finally – ASP.NET AJAX Control Toolkit Released

...finally catching my breath...

This time I have a bon-a-fide excuse for not blogging in a little while.  Why?  Well I'm glad you asked...take a little journey with me.

From the early days of the Toolkit, I've been having converation with the AJAX (Atlas) guys about upcoming changes to their platform.  I've been working with them to drive as much context and Toolkit learnings as possible into the final product design.  This is good because driving deep feedback earlier in the cycle was one of my teams major raison d'etre.    Anyway, this was a bit of a dilemma for me; as more stuff got added to the Toolkit, the bigger this migration job was going to be.  But, their schedule was their schedule, so not much to be done there.

A month or so ago, I sat in on the final round of the design meetings, gave some feedback, and we started talking about executing on this migration.   I had a pretty good understanding of how the server-side changes were going to go, and I knew that they migrated the client side Javascript to something called "prototypes" instead of closures.  So we're changing JS syntax, how bad can that be?

Three weeks ago, we talked about timing.  The AJAX team would have their first "integrated" builds ready in the first week in October, and we could pick it up and do a dry run of converting our stuff.  We started that on Thursday the 5th.  My plan was to take my team fully off-line for a week to do this conversion, and my intention was to convert our Contributor code as well.  One week.  Yeeahhhhh, riiiiiight.

The conversion of the server-side code (ExtenderBase and friends) was fairly straight forward and was only about a day or day-and-a-half's work.  I got that cranked out pretty quickly, and converted one of our smaller components (ConfirmButton) as a proof-of-concept so the other guys could start working as well.  David got on the ball doing some renames, creating a branch for us, etc. 

It was quickly appearent that this was going to be a little more difficult than I'd expected.  There were three areas that proved difficult:

1) Finding all the syntax changes that were a result of closure -> prototype (e.g. all the variables need to be now prepended with "this", as do the method calls, etc)

2) Finding all the pattern deltas between the old and new bits (e.g. this.control.element becomes this.get_element()) and semantic changes (e.g. the move from properties -> extenders means you create object at different times, or eventing works a little differently, etc)

3) Dealing with stuff that wasn't in the Core, or wasn't there yet (e.g. globalization support, some helper functions, etc.)

So it took us several days to work through all the different cases of each of these things, and how to handle them.  After that, doing the conversion (1) to the new syntax got fairly straight-forward, but that turned out to be the easy part.  The development experience for script is still pretty primative.  There's no compiler, so you end up doing this: 

  1. Launch browser

  2. see Script error

  3. figure out line number

  4. look at line in code

  5. figure out what's wrong with it

  6. fix it

  7. goto (1)

So for longer files, that can take quite a bit of time.  Then, once you're done with that, you need to work through functionality issues, which is often even more difficult since it requires "real" debugging.  Oh, then you have to check the various browsers. All-in-all, it's doable with one or two controls, much tougher when you've got almost 30!  The big plus for you folks is that we kept track of as many of these steps as we could and I'll be posting those shortly. 

Note, however, that if you're not writing components (e.g. you're a page-developer), this transition is easy, and you can get the steps for migrating on the Toolkit Website.

Anyway, lucky for us, our contributors really helped out here, especially Ron Buckton and Garbin, without whom I'd have another late Friday and Weekend 'O Work ahead of me.  Instead I get to go through my email backlog and maybe even make it to happy hour.

The AJAX team really wanted to get shipped earlier this week.  However, the Toolkit has become such an important part of the overall story, they decided it was key to wait for us (the Toolkit) to be ready to ship at the same time.  How cool is that?  Anyway, they were chomping at the bit by yesterday and really wanted to get this thing done.  Their whole team and my whole team were here until about midnight lastnight when we finally got it wrapped.  Phew!

Okay, so what's in there?

We've got some new controls:

1) DropDown - mimics the inline-dropdowns as seen in Windows Sharepoint Server

2) MutuallyExculsiveCheckbox - something you an use for pick lists

3) ValidatorCallout - a nice AJAX'y way to do your validators.  Works with the standard ASP.NET Validators, etc.

The performance of things like the Animation package seem faster on the new Core.  The Core is much smaller so less code has to come down to get the page up and running. 

We added some small helper features...

ElementReferenceAttribute - allows you to tag an ID-Property so that you can take an ID on the server side, but get an element-reference on the client side.  Saves you the work (and wierd OM) of doing "$get" on the client side.

BehaviorID - a first-class way to put an ID on your client side behavior so you can reference it from script.

And one thing we couldn't get to work on this release but hope to re-enable soon: Profile support.

Most other things are pretty similar.  We've got some more controls that we weren't able to convert as well, so look for those in our next release.



Comments (2)

  1. Delay's Blog says:

    It wasn’t as easy as anybody claimed it would be, but my team just published the 61020 release of the

  2. Glavs Blog says:

    I have been very quiet in the blogosphere lately. Lots of things have been keeping me busy, particularly

Skip to main content