David Findley's Blog : AJAX

ASP.NET AJAX 1.0 (excitement builds)

findleyd — Sat, 21 Oct 2006 03:38:14 GMT

I just downloaded beta 1 of ASP.NET AJAX today. Wow! Lots and lots of changes. The type system has been greatly simplified. I like this. The move to prototypes over closures was a good decision. The core scripts are much easier to read and comprehend as well. The CTP download has been a 404 for me this evening so I haven't had a chance to dive into it.

Looking through the core scripts there seem to many improvements. There used to be a bunch of prototype extensions to the Function object that were really only applicable to ctor functions. This seemed like it was pretty inefficient. That doesn't seem to be the case anymore.

All in all the script library feels less like a hodge podge of techniques from around the web and has more of a cohesive feel to it. Maybe that'll change once I get into the CTP add-ons. Overall I'm impressed with what I've seen so far. This definitely seems like a big step forward.

We used the CTPs for some back-end admin functionality on http://www.learnvisualstudio.net/ so as soon as I can lay my hands on the new CTP bits I'll have to see what the migration process is like.

Ok, time to get back to playing... :)

Update: looks like the CTP download is working now. I think its going to be a long weekend. ;)

A great article on functional programming...

findleyd — Wed, 21 Jun 2006 04:39:45 GMT

http://www.defmacro.org/ramblings/fp.html

This article was a great overview of many of the aspects of functional programming. With what Micosoft is doing to the CLR and C# and VB it would seem that functional programming is making advances into the main stream. His article has imaginary Java samples and if you squint your eyes when he creates a class to hold a function you can see delegates.

I studied functional languages such as LISP and ML in college but quickly lost track of them after years of programming in corporate IT. To catch back up I've been spending the better part of a year studying functional programming concepts. While its been challenging at times, there have been alot of aha and oh yeah moments.

Since I have a great comfort level with C syntax I started my ride on the functional wagon with COmega. This is where I really began to "get" things like closures. I even found myself purposfully writing my own code to mimic a closure in good ol C# 1.0 for certain situations like Regex match evaluators. Once you see the "patterns" that higher order functions exhibit you can write them in plain imperative code. This will make you hunger for language constructs to do this work for you. Its like writing OO code in assembly language.

C# 2.0 Added true closures to the language with anonymous delegates. Woo hoo no more private nested classes to hold lexical context! (at least not that I write).

At PDC I got to see the preview of C# 3. This takes anonymous delegates a step further with "lambdas". There's lazy evaluation galore with LINQ. It would seem that MS has been bitten by the functional bug. Even the Atlas client APIs make good use of the functional elements of JavaScript.

I've also ventured out into IronPython and Ruby. These are great places to practice functional programming techniques.

The real challenge moving forward is finding the right balance. Theres no doubt in my mind that functional programming techniques are headed to the main stream. With the populatrity of Ruby and Rails and Microsoft adding functional capabilites into C# and VB the winds of change are blowing.

Link dump so I can keep track of what I'm researching:
COmega: http://research.microsoft.com/Comega/
LINQ: http://msdn.microsoft.com/data/ref/linq/
F#: http://research.microsoft.com/fsharp/fsharp.aspx
IronPython: http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython
Ruby: http://www.ruby-lang.org/en/
Ruby.NET: http://www.plas.fit.qut.edu.au/rubynet/
IronRuby: http://wilcoding.xs4all.nl/Wilco/IronRuby.aspx
RubyCLR: http://www.iunknown.com/articles/2006/06/19/rubyclr-drop-4
Atlas: http://atlas.asp.net/Default.aspx?tabid=47
#Smalltalk: http://www.refactory.com/Software/SharpSmalltalk/index.html
brianbec's blog:
http://weblogs.asp.net/brianbec/default.aspx
http://weblogs.asp.net/brianbec/archive/2006/06/01/Lambdas_2C00_-Closures_2C00_-Currying_2C00_-and-All-That.aspx

Microsoft Product Name Generator

findleyd — Tue, 20 Jun 2006 23:13:00 GMT

Lance and I were musing over some of the recent product renamings and it gave me the idea to throw together a product name generator. Here's my first stab at it:

Get Product Name:

Feel free to customize your own. Here's the srcipt source:

   1:  <script>

   2:  var pfx = new Array("", "Visual ", "Compact ", "Embedded ", "Expression ");

   3:  var prd = new Array("", "Windows ", "Office ", "SQL ", "FoxPro ", "BizTalk ");

   4:  var trm = new Array("Web ", "Robotics ", "Network ", "Testing ", "Project ", "Small Business ", "Team ", "Management ", "Graphic ", "Presentation ", "Communication ", "Workflow ", "Ajax ", "XML ", "Content ", "Source Control ");

   5:  var typ = new Array("", "Client ", "Workstation ", "Server ", "System ", "Console ", "Shell ", "Designer ");

   6:  var sfx = new Array("", "Express ", "Standard ", "Professional ", "Enterprise ", "Ultimate ", "Foundation ", ".NET ", "Framework ");

7:

   8:  function pick(ar) { return ar[Math.round((ar.length-1)*Math.random())]; }

   9:  function getProductName()

  10:  {

  11:      var name = "";

12:

  13:      name += pick(pfx);

  14:      name += pick(prd);

  15:      name += pick(trm);

  16:      name += pick(typ);

  17:      name += pick(sfx);

18:

  19:      var p = document.getElementById("p");

  20:      p.innerHTML = name;

  21:  }

  22:  </script>

  23:  <A href="#" onclick="getProductName()">Get Product Name</a>: <b><span id="p"></span></b>

Atlas declarative blocks

findleyd — Tue, 04 Apr 2006 04:51:00 GMT

The text/xml-script declarative model is great. I'd just like to see it declared outside of the .aspx file. Semething like an "ajax" behind file.

Imagine:
Default.aspx
Default.aspx.cs
Default.aspx.ajax <-- declarative text/xml-script

Most of the Atlas markup I've seen in demo apps is just control bindings and web service proxy declarations. The contents of the tex/xml-script blocks seem to more resemble a mapping file than ui component instantiation.

This should be possible to do by just setting src attribute on the <SCRIPT> element. e.g.:

<script type="text/xml-script" src="Default.aspx.ajax"></script>

This currently doesnt seem to work. I'm sure its because the content type is mixed up. I know this is nit picky but having the atlas declarative block in the HTML markup feels like putting css or script inline.

This also leads to the possiblity of using a "js" behind where you can do all of your client side declarations with simple javascript calls to the atlas script library. This seems on par with everything else coming out of Microsft. If you like to just write code you can do that. If you like to "declare" things with angle brackets your good to go there as well.

For now its back to experimenting...

P.S. The documentation for the March CTP is soooooo much better.

AJAX thoughts

findleyd — Mon, 03 Apr 2006 22:55:00 GMT

I was just reading through this post: http://weblogs.asp.net/mschwarz/archive/2006/04/03/441767.aspx and it reminded me of some of the worries that I have about the various AJAX libraries.

We have some devs here that are prototyping some AJAX features. They are mainly using the controls from Component Art (which are great btw). The Component Art controls have alot in common with the things that ATLAS is doing. The idea here is to enable "ASP.NET" developers to come in and AJAXify their web apps. The thing is they end up getting completely thrown for a loop when the ASP.NET postback model starts getting in their way (viewstate issues etc.). For simple little autocomplete boxes and such this is no problem. But once you go off and try to do anything complex it just confuses the developers. The notion that you can remain AJAX ignorant and just sling controls is seeming farther and farther away from reality each day. Maybe theres an 80/20 rule here but so far it sure seems to be more like 20/80.

This also smacks of the orginal goals of the Web Forms design time: let the VB windows programmers come on over and play in the web sandbox. While this sounds great on paper and works for demos and one off sites, it leads to piles of spaghetti code for large web sites.

If your serious about doing AJAX then make sure you understand JavaScript. It will be the most important thing you learn when you go to code and debug an AJAX app.

I've been looking forward to ATLAS so I havnt really looked at AJAX.Net that closely. I know more about it through the posts here on weblogs than I do from actually diving into it. Looks like I will be correcting that very soon now. :)

I've been looking at Ruby on Rails recently to see what all the noise has been about. I have to say I'm pretty impressed. The front controller design has enabled them to graft on AJAX features pretty cleanly. The prototype javascript library has the same feel as ruby does which is great for keeping the programming model as consistant as possible.

ATLAS is trying to do the same thing for ASP.NET but fitting it into the page controller model may be a bit more challenging.

The official I spoke too soon post.

findleyd — Wed, 17 Aug 2005 01:13:00 GMT

It seems that I was taken in by the "Releasing 8/8/2005" line that was on the TIBET home page. This definite release date was replaced with the most indefinite "Coming Soon" early the morning of 8/8. Hopefully the TIBET project is not total vapor ware. Oh well, I'm back to pinning my hopes on MS's Atlas project. I too will be going to PDC this year and look forward to getting my hands on the first preview of Atlas.

The most complete AJAX library I've ever seen!

findleyd — Sat, 06 Aug 2005 05:08:00 GMT

WOW! Check out TIBET

This has to be the most advanced JS library I've seen. I'll have to pick my jaw off the floor before I can write any more about it. Just click the link and be amazed.