We will take a closer look at three programming architectures with heavy support for tag programming. We will focus on the latest offerings of these. Specifically Microsoft's ASP.NET, Macromedia's ColdFusion MX and Sun's Servlet/JSP/J2EE.

How do they differentiate themselves

If one could describe in a nutshell how each differentiates themselves - it would read as follows

Cold Fusion - Cold Fusion's basic theme still remains - make it easy for the web designer or business domain developer to create complex web applications with ease (with a language that looks like HTML) - make the common tasks easy at a slight expense to less common tasks. Cross-platform is important to Macromedia, so you will find that Cold Fusion runs on numerous Oses and web servers. Cold Fusion is still predominantly a tag-based architecture. It has tags for even doing conditional logic similar to how XSL works.

ASP.NET - Cross-language first and cross-platform last. Make web programming look like good old RAD Windows programming. Give developers different languages to choose from when developing web apps. Make it difficult to write spaghetti code. Make it easy for new program components to be deployed without fussy installations. ASP.NET marries procedural programming with tag programming. Procedural programming is still a big component of ASP.NET and ASP.NET does not come with conditional logic tags like you find with JSP and Cold Fusion, but server tags now share the lime light as a very integral part to this technology. ASP.NET sports a rich library of web form tags for doing things like rendering paging data grids, list boxes, text boxes, web form field control validator tags etc. On top of that ASP.NET shares the many of the same set of libraries with the rest of the .NET architecture and the new event-driven capabilities make it feel very similar to good old Windows form programming.

Java Servlets/JSP - Cross-platform first and cross language last. Try to do things the right way - to the book. Breakup up developers - Web designers and Business domain programmers develop with JSP and low-level API programmers and Advanced/Business domain Programmers develop using Java Servlets and Java enterprise beans. Your choice of server programming languages in JSP is still limited to Java in JSP (some variants of JSP allow Java script). Still JSP/Java Servlet relies on Java as the glue to put things together and trying to use non-java based components is a bit messy.

More about the new Features

CFCs are also just about as easy to write as your old standard CFML tag libs. In fact you will find that Cold Fusion MX does not make much of a distinction between Web Services and single application CFCs. The lines have been intentionally grayed. The new Cold Fusion MX vision seems to be to build applications using Web Services as building blocks. View each application as a loosely connected set of web services. Cold Fusion is betting very heavily on the new Web Services technology being the new standard of web programming.

• (A new VB - VB.NET (not VBScript) and complex error-handling using the Try and End Try, short-circuit logic borrowed from languages like Java and choice of other .NET languages such as C# (a favorite among those who prefer the JAVA/C programming style) .
• True page compilation - ASP.NET is not interpreted as was it's ASP predecessor, but instead - Microsoft has followed suit with Sun's JSP; code is now compiled into the .NET Common Language Run-time (CLR) - similar to Java's Virtual Machine and then further compiled into native machine code.
• Windows event model and form field properties to the web environment (this new change makes it surprisingly easy to separate html from complex business logic and in fact difficult to mingle the two (a good thing actually). Instead code is triggered in event and function nuggets in html server controls or by databinding properties of run at server controls. In fact you can set any html element to a run at server element which allows one to programmatically change an html element (e.g. hiding rows divs - server side) before rendering it or databinding it to datasets data readers etc..
• View State - ASP.NET now has the concept of View State - where each html element can remember it’s previous state from form post to form post. This is optional and can be turned off by element. This allows text boxes, listboxes etc. to remember what was selected in the previous post and automatically set these when displayed back to the user.
  
• Code Behind - This allows one to further separate business logic from page design. In simple terms though - Code Behind is really nothing more than good old object inheritance - where the complex logic is defined in one class and the visual page or visual control simply inherits it's behavior from this class but provides the design. Page design is kept in an .aspx, .ascx, or .asmx file with a line at the top that states it will inherit or use code behind (specifying the class providing the code behind) and the business logic is kept in a .vb, .cs or other .NET programming language file (there are numerous .NET languages in beta right now PERL.NET, Delphi.NET SmallTalk.NET etc.). Currently only VB.NET, C Sharp, and J++ can be used directly inside a .aspx file - other languages must use code behind.
  
• Server Tags, User Controls- similar to the CFML Tags and JSP Tags. True server tags require more complex programming while User Controls can be in .ascx files and are relatively easy to create. Once created - user controls are used like any other tag - and can have their properties set via tag attributes. Server control programming is generally done for very generic complex logic (such as the ASP.NET datagrid and datagrid subclasses and specialized kinds of form fields) - while user control programming is done for more specific logic that pertains to one particular application (e.g. a navigation menu - a detail row).
  
• A framework for creating Web services that is relatively easy to apply (.ASMX) that automatically handles the conversion from XML to object and Object to XML for you.
  
• Built-in complex web server caching capability - with just a line of code you can do things like dictate how long a web server should cache data, based on what variables and whether whole page or just particular web control caching.

VB.NET is not your old VB; it is truly VB reinvented. The new VB is more like a marriage between VB and Java. VB.NET utilizes the same rich namespace library that C Sharp and other languages can use. It now supports inheritance. The SET, LET and Variant keywords are gone so everything is now an Object. It has incorporated the complex error handling Try Catch syntax that Java and C have as well as short-circuit boolean logic using the new keywords AndAlso and OrElse. In old VB a condition would have to be completely processed which meant often writing additional conditional subloops to prevent runtime errors. With short-circuit programming - one can write statements such as If dr.Read() AndAlso dr("id") > 5 Then In old style VB - you would get a runtime error if your data reader had no records becuase it would process both parts. With this new short-circuit syntax - the second clause is not processed because the first clause evaluated to false. This also saves processing time.

The new language C Sharp (C#) - is also a bit of a morph too. It has the new foreach clause as well as the controversial goto clauses (both borrowed from VB) that Java lacks and utilizes similar event handling glue of VB (and other languages like Delphi). It's switch statement behaves more like the VB Select Case statement than it does like the Java switch in that it doesn't require each case to be an integer (can be a string like VB) . It has a rich library (shared with VB.NET) - called Namespaces. This is equivalent to Java’s J2EE packages.

You can mix and match languages within a single ASP.NET app and use other components developed in other languages (and as bad as that sounds - it works surprisingly well and is relatively transparent since all .NET languages get translated to the .NET CLI). This means that if you like a component that one set of developers creates - you don't need to worry too much about the fact that the component is not written in your preferred language - as long as the logic is well black-boxed. ASP.NET does not work on all platforms YET; this appears to be changing with 3rd parties however like Covalent with there .NET Apach Server product and the new Open source Mono project to name a few.

JSP/Servlet

Sun's JSP/Servlet technology has changed least of all. It still remains pretty much as it was a year ago - the Java Servlet 2.3 standard has added very little - except for modifications in use of Filters. J2EE and the very important JDO (Java Data Objects) has matured a bit and Java Enterprise beans have become more complicated and better integrated with JSP/Servlet. Java Enterprise beans still remain too complicated to easily implement for your standard web app unless you accomplish it via third party products such as Cold Fusion, so is hard to keep up with the "I needed it yesterday mentality of today (Internet Time)." It must be noted that J2EE/Java Enterprise Beans and Servlets do not necessarily go hand in hand. In fact most Servlet sites do not directly use Java Enterprise beans and do just quite fine.

There is one major feature that Sun has added to JSP which is probably a relief to many. This is the JavaServer PagesTM Standard Tag Library (JSTL). JSTL is a spec like all other Java specs, but defines specific tags how they will be named, their signature (what inputs and outputs they will take and return). Third parties are free to provide their own implementation of this that will work best with their servlet engine.

Why is this so good? When JSP came out, it was very limited in terms of tags provided (Cold Fusion and ASP.NET on the other hand have a rich tag library out of the box for common tasks). This meant relying on the proprietary tags provided by third-party vendors which were often integrated with the Servlet Engine they sold you and had its own non-standard set of tags each with its own non-standard set of properties etc, or going through the very time consuming process of rolling your own tags. Change your servlet engine and well you’re out of luck because the tags you used and loved could not be ported to another engine. This ruined the write once run anywhere mantra of JSP. The Apache struts library (now called Jakarta TagLib) did do a lot to provide common tags that would be useable everywhere, but still tags provided by third-parties such as Macromedia JRUN, BEA Logic etc. were still a bit easier to use because they were automatically installed and ready to use with your servlet engine, often worked better with their servlet container because they were specifically designed to work with the idiosyncracies of your servlet container and some were just more extensive in functionality. It was hard to not take the candy dangling above you even though it would give you cavities.

With the introduction of JSTL - hopefully this will change. In fact the Jakarta TagLib is a reference implementation of JSTL now. Hopefully servlet container providers will follow suit and provide tags taht are JSTL compliant. It’s still too early to say how well this will work out, but it looks promising.

Links of Interest