Friday, March 24, 2006

AJAX and ATLAS are two hot topics in the arena of web application development.

In this blog entry, RickSP covers a talk he presented at Mix'06 on how to "Design a Better User Experience with AJAX and ATLAS", and in particular, six "lessons from the trenches". My take is that these should really be "Six pillars of AJAX application design".

Whilst mostly related to the configuration of EntLib (but including a package that integrates the config tool with VS2005), one of the comments provides a link to a Data Teir Generator for EntLib.

I think that this could be a really simple way of getting started with the EntLib - bringing it closer to the data teir functionality of Castle ActiveRecord (and its associated generator) or IdeaBlade DevForce.

Thursday, March 23, 2006

There's been a lot of excitement recently in the Open Source community about Ruby on Rails. This web development framework makes developing web applications much easier by providing a well structured Model/View/Controller framework in which to develop.

Of course, having this kind of framework available to ASP.Net would be even more exciting, the MonoRail project was a great find. Part of the wider Castle Project, it provides a true separation of presentation from business logic and persistance of data.

There's a nice database persistance layer as part of the project, too - ActiveRecord. Great for .Net 1.1, but possibly with some issues under .Net 2.0 as it relies on untyped collections. But I've found that there's a good article on implementing nicely typed collections for related objects tho, here, so I'm now less worried about using ActiveRecord as the persistance layer.

I'm going to try implementing a test with this later today, but it looks good from the documentation. There's even a stud for documentation about implementing the Inversion of Control pattern using the Windsor Container within the framework - all very interesting stuff.

Whether I manage to integrate MonoRail with AJAX (maybe using ATLAS) will be the real kicker, of course, but if it can be done, I think this could be an extremely powerful development framework.

Friday, March 10, 2006

In this first article, Rob Howard describes how the Provider model is implemented in .Net 2.0, along with a worked example.

Providers are, to my mind, absolutely central in developing flexible software architectures - being able to "unplug" a default provider and/or "plug-in" your own replacement/extension is central to role management in .Net 2.0. But it's also a very useful pattern in it's own right. The Search engine I wrote as part of the Mando Common Platform uses exactly this pattern (although partly configured via a database as well as via the web.config) to allow "pluggable" search handlers to operate across a variety of data sources.

But what's more interesting is that in the second article, Rob provides a parallel implementation of the provider pattern in .Net 1.1 - in the process clearly explaining how the pattern can be implemented in .Net 1.1.

This pair of articles really should be required reading at Mando for the programming team!

That means pretty much EVERYTHING! I'm still trying to get my head around it all, but Anders' demo of iterating the instance methods of the string type using the syntax was the epiphany moment for me - a simple, elegant way of accessing complex real-world data. Wow!

I've not tried this myself yet, but given the grief I've had with managing namespaces in XSLT 1.1, I'm hoping that Saxon might make using XSLT for the generation of dynamic content rather easier. Certainly, it would provide a stop-gap implementation until full XSLT 2.0 support is provided out of the box in .Net.

Saxon is available as a basic (non schema aware) version as OpenSource from SourceForge, or as a schema-aware version from Saxonica. Priced at £250 / workstation or server, it's reasonably cheap too.

The Web Services Contract First methodology is really a return to the original spirit of web services - that of an interface driven service oriented architecture. By providing all the tools to let you generate the WSDL contact first, this toolset makes you think about the interface between services, rather than the traditional VS driven way of just exposing your existing classes through a webservice.

I blogged about this before after going to a presentation on this by Christian, and am still as impressed - I just can't believe I missed the 0.6 release until now!

Whilst the article is unashamedly a plug for their book, it does highlight deficiencies that seem to be prevalent in the corporate world, where commercial constraints often put pressure on a project team to deliver "the product", causing other deliverables - in particular things like documentation, testing, architecture, etc - to be given less weight than they perhaps otherwise should. The practices and patterns that should be applied across the project getting subverted by the commercial "realities".

In the article, they detail five principles for successfully delivering a project, namely:

Tell the truth all the time

Trust the team

Review everything, test everything

All developers are created equal

The fastest way through the project is to do it right

In my opinion, as an Architect and Developer, the two that get least weight are the "Review everything, test everything" and "The fastest way through the project is to do it right".

These, particularly the latter, should be championed much more. Time and again, I've found I've had to argue in favour of a bit more complexity and cost for a feature in order to future proof it or provide a foundation for future work, against the drive to deliver "just what's needed as soon as possible and as cheaply as possible".

Inevitably, if the product in question is going to have a future beyond its first release, then thinking about that future, and the possible changes or extensions to its functionality, and putting foundations in place to support that future give long-term cost benefits that far outweigh the short-term savings that a "sub-optimal" solution would bring.

In this article on MSDN, Pat Helland provides an interesting metaphor "for the evolution of information technology into the world of service-oriented architectures".

In it he compares the evolution of cities and the real-world systems that exist within them (transport, manufacturing, etc) with that of SOA, in the process providing a pretty good introduction to the subject. From the summary:

Explores the idea that information technology is evolving in a fashion similar to how American cities have evolved over the last two centuries. The opportunities and pressures of the technological revolution have driven our metropolises to adopt new frameworks, models, and patterns for commerce and communication. Recent developments in IT are analogous. What can we learn about the present and future directions of IT by studying the recent history of our urban centers.

Paul Ballard and Gregory Hoyt give a good account of each of the three days (1, 2, 3), including relevant resource links. The Enterprise Library 2.0 powerpoint is well worth a look, particularly if, as I do, you think that a community-driven best-practice library can significantly reduce development effort.

Would I want to go to an event like this? Certainly. Should there be something like this in the UK? Definitely.