Peter Van Dijck asks:

I’ve only worked twice with companies using .NET for web interfaces, and in both cases the UI was a disaster and the usability problems guaranteed lots of consulting hours.. Why is that? Or was that a fluke? (2 cases is hardly proof of anything) I know it’s possible to make usable and elegant web UI with any technology, but does .NET somehow encourage bad UI?

This is a great question and in my opinion – the answer is yes. (Assuming that Peter really means WebForms.)  

This is demonstrated in so many small ways by framework defaults which are totally brain dead (__doPostBack anyone?). Rather than lead dev’s into the pit of success – the framework leads devs to the spiky elephant trap of death. 

 
What’s that – an example? How about the <customErrors> defaults. When an error occurs during processing an ASP.NET request – the default behavior of a new web.config is to redirect the user to another URL. This is what a new web.config looks like in VS2k5. 

        <customErrors mode=”RemoteOnly” defaultRedirect=”GenericErrorPage.htm”>

            <error statusCode=”403″ redirect=”NoAccess.htm” />

            <error statusCode=”404″ redirect=”FileNotFound.htm” />

        </customErrors>

 

The URL in the browsers address bar is: 

http://devlicio.us/error.htm?aspxerrorpath=/themes/blogs/default/post.aspx

Another example? Linkbutton? Anyone who’s tried to open a link in a new tab/window and got a blank window with a URL like: javascript:__doPostBack(‘ctl00$Masthead1$LocaleManagement$ctl00$ctl05′,”) – knows the pain I’m talking about. 

Go on – right now – go try and open a MSDN library page in different language in a new tab. (It’s the little menu up the top right where it says (e.g.): United States – English). 

In my apps – I fix this by disabling customErrors and writing new error handling code which both maintains the url and returns the correct HTTP statuses – but this is code which I should not have to write. This is code which all web servers/apps need to implement correctly – it should be automatic. We shouldn’t have to write custom code to get a HTTP/404 returned when an app encounters a missing file!

At the time – the best web architecture I knew of was the ArsDigita Community System (still available and maintained as OpenACS). What Oren is describing sounds similar in many ways.

The ACS architecture is based on the days when Oracle and TCL were good options for building web based systems…. but the underlying design is still very very good (e.g. it was the first place I every saw the Party pattern). They were focused on designing good data models and separating concerns.

They have the following available in their kernel:

• Parties, Users and (nestable) groups
• A permissions system which supports per “object” (think row) permissions.
• A package manager which allows you to install (and remove) modules of functionality into an existing system (including schema changes, new routes etc). e.g. adding a e-commerce, blogging or threaded discussion module is a matter of clicking in a web ui.
• Scheduled tasks

This thing was and is pretty scalable (it runs the photo.net community).

It’s over 10 years old still a source of good ideas. I recommend taking a poke around their documentation and seeing what you can learn.

(I remember reading once that Philip Greenspun – the original ACS designer was asked by Microsoft to build a new version while the .net framework 1.0 was in development as a showpiece. For some reason he didn’t but I always felt that it was a shame this never happened).

“How can you run multiple instances of memcached on a single machine?”

There’s a couple of reasons why you’d want to do this. The most obvious is that you’ve got multiple clients being serviced on a single machine and you want to absolutely ensure that data is not leaking from one client to another.

If you want to setup multiple instances the once you’ve got the win32 port downloaded and unziped somewhere you need to use the following magic incantation:

sc create memcached2 binPath= “c:\memcached\memcached.exe -p 11111 -d runservice”

You can pass any other params you wish (e.g. amount of memory to use). To run multiple instances just install multiple services with different names/ports.

Note: “sc” is the command line tool for working with the win32 service control manager. It allows you to stop/start/create/delete and more – windows services. Check out it’s command line help by typing “sc” at the command line.

1. In views ScottGu shows how to write views using <%= %> style code. Now that was all good when asp classic was a new and good idea. These days some (lots?) of people think that HtmlEncode’ing by default is a good idea. It makes attacks like XSS and CSRF more difficult and is the default for much of the WebForms controls. It’d be nice to see support for this integrated into the WebForms compiler or maybe a rails like <%h= %> option.
2. Scott demos a new extension method: .UpdateFrom(NameValueCollection) which allows you to update a class from a NameValueCollection. This is super sweet – especially with the built in reflection caching he mentions. I’d like to know if this extension methos has support for whitelist/blacklist of incoming property names/values? (Like the MonoRail DataBindAttribute.Exclude/Allow properties). IMO – this is an important security consideration.
3. Can you configure the routing rules based on HostHeader+Url or is it just Url?)
4. In the example he uses – the Layout is specified by the View (i.e. MasterPage=”") – this is an improper separation of concerns – it should be upto the Controller to specify the “layout” (masterpage).

Anyway – it’s really just a list of things I’ve thought of and am curious about. Overall I’m amazingly excited and really looking forward to getting my hands on some bits.

Another classic example of WebForms being too complicated for it’s own good.

In other news: Oren and Mats are having a dustup over webforms. I have this remarkible experence when I work with WebForms. Sometimes I get the entire model/life-cycle/event flow etc in my head and fix or work around quite complex scenarios to get some piece of functionality working.

e.g. Writing a control which/removes adds instances of other controls to itself when buttons are presses.

When this happens I experience this strange sense of achievement and even pride. The feeling that I have really done some “hardcore” programming today. Then I remember that I just managed to inject a string into the middle of another string and write the result to a stream.

Then I feel sad.

• Who’s using what features?
• Where are the users coming from?
• How long does it take subset X of users to perform action Y?

Some of these are closely related to traditional web analytics, but many of them cannot be answered without application level event logging. Ron’s papers describe how Blue Martini did this within their e-commerce framework and what a huge advantage this gave them when doing BI. One of the insights of the paper above is that having a meta-model for your application is really important for later analysis. You need to know:

• When you changed the default answer for question X on the registration form?
• When did you add question Y to the checkout process?

If you keep a metamodel and use that for updating your live DB¹) then you can capture these changes as you change the data store. Ron’s team went further and built a data warehouse²) and ETL process automatically from the meta model – that was automatically updated as the live DB evolved.

I’ve been using some of these ideas independently for a long time (e.g. Event logging is a good idea) – but it’s the combination of of a meta model – including change history – and event logging that really provides the power here.

Short version. How I’m thinking about building business apps is changing. As I think about the business requirements, data model etc.. I’m now considering how we are going to capture/store/analyse the meta model and the business event stream. This seems like a significant evolution in my thinking.

1. (Blue Martini used a highly optimised/denormalised datastore for it’s e-commerce front end because of the performance requirements.
2. (Including slowly changing – aka type 2 – and hierarchical dimensions

ASP .NET templated controls did almost nothing to encourage separation of orthogonal concerns. It simply ended up separating concerns that aren’t separate concerns.

Pure Genius – this summarises an entire field of criticism (e.g. [1][2]). The whole issue with the OnRowDataBound/FindControl() style of programming is that things which are fundamentally simple (iteration and string concatenation) are impossibly complex because concerns have been separated which are not orthogonal.

There’s an important caveat to this – which is that WebForms is actually trying to solve a different problem from the one that I and many other developers build web apps are trying to solve. WebForms was intended to allow VB6 windows programmers to build web based apps – without having to understand HTTP, HTML, CSS, Javascript, GET/POST/HEAD etc.

This has actually proven to work pretty well in specific circumstances. e.g. A team of developers building an inhouse (intranet) line of business app. A good friend of mine was tasked to lead a team of 20 or so Oracle Designer developer in building a next gen version of the product they had been working on in ASP.NET 1.1. They were able to pick it up and get productive remarkably quickly because they could continue to work with a Control based, form based model that was familar to them.

Where it’s made life immeasurably harder is for developers who are building public facing web apps. Apps the HTML they’re actually emitting matters, where cross browser compat is something that needs to be deeply understood – not abstracted away (thats a whole ‘nother post).

The reason this is even an issue is because of the Microsoft DevDiv monoculture. If it’s a Microsoft solution then it’s obviously the best. In the Java world – there’s JSP (classic asp using Java) and JSF (roughly webforms) – but there’s a whole boatload of other solutions to problems.

I don’t see anyone arguing that the only right way to build web apps using java is to use JSF. People are free to examine the problems they face, look at the solutions proposed by various other people who have published their work (e.g. Tapestry, Grails, RIFE, Struts, WebWork, Struts 2 etc…) and either use an existing solution or roll their own. Same in the Python (Django, Web.py, Zope), PHP (Zend Framework, Cake, various PEAR libraries), Perl and pretty much any other community you care to examine.

Which tool is right for you depends entirely on your context (the problem, your experience, your team, their experience etc). If Webforms is working for you – then fantastic but it’s not the right solution for everyone.

I finally made some time today to sit down and browse through the source code for BackgroundMotion. For those of you who haven’t come across this project – it’s kind of a best practices sample built by the great guys at Mindscape. Background motion is a Web2.0, AJAXified, community driven site for submitting videos for use with Windows Vista Dreamscene (the use a video as your background rather than just an image thingy). It’s pretty buzzword compliant – it’s got tags, AJAX and user generated content. On the backend it uses ASP.NET AJAX, LINQ to SQL, the Web Client Software factory, MVP, Unit testing and all sorts of other goodies.

Unlike lots of the samples and guidance coming from the P&P team – this one is also a real functioning LIVE application. Rather than just completing something to the degree necessary to show the main concepts – this is a pretty finished piece of work. Well – production ready at least – what software is ever “finished”?

It’s also a great resource for looking at structuring a real world application using the full Microsoft .NET 3.5 stack. There are heaps of great ideas in there including:

• Echoes of discussions in Jimmy Nilsson’s book Applying Domain-Driven Design and Patterns: Using .Net
• Implementations of UnitOfWork , Repository<T> + Repository Specialization very similar to Oren’s Exesto sample + Rhino Tools
• A declarative .net DataBinding Extender control similar to the ones in Spring.Net, the MonoRail WebForms View Engine and Rick Strahl’s wwDataBinder

There are also short videos from the guys giving an overview of some of the technology/patterns and choices that they’ve used. I particularly liked the great discussion of MVP with WebForms.

One minor criticism: I remember chatting with Jeremy about the Composite Web Application Block when it was released and complaining that after downloading it, reading the docs and source – I couldn’t figure out how to use it. His answer at the time was: Wait until we release the BackgroundMotion source – then you’ll have a real example. Well – I’ve looked through the code – and I still have no idea how the CWAB really adds value. Even after watching the video and reading the Web Client Software Factory page – I’m clueless. Maybe I’m just not smart enough to get it.

1. Giles Bowkett made an interesting post on his blog:
   

   “[T]his has always been my fear for Rails; that in five to ten years, the worst jobs you could get will be Rails jobs where you’re maintaining stuff built by non-programmers who figured Rails made programming so easy that they didn’t really need to understand what they were doing.”

2. In Avi Bryant‘s ETech presentation Applied Web Heresies (slides) he makes the following statement:
   

   “Meaningful URLs don’t carry enough meaning
   Names make me think too much
   DRY (not everything is an API)”

This is reminiscent of Visual Basic (and VBA, Access etc..). I know I’ve done maintenance on some scary code which was written by someone who didn’t understand enough about what they were doing.

Not Everything is an API

The obsession of Rails dudes with making every object a REST endpoint is a particularly scary form of religion. In VB6 every “class” was exposed as a COM object. For those of you who are not familiar with COM – this means that every public class in your application was exposed as an API. Weather you wanted it available to other applications or not. As you can imagine – this resulted in some truly monstrous misuse of parts of applications by other applications and lead to the worst kind of spaghetti dependencies imaginable (circular build dependencies etc).

In general API’s should be carefully thought through, designed and exposed as a separate development exercise from building a web application. For example:

1. Google maps was released
2. People started hacking mashups using it.
3. The GMaps team went away and designed a JavaScript api which is:
   • versioned
   • licenced
   • secure
   • supportable