April, 2005:

From what I can tell, the JCP process seems very broken to me. My only involvement has been as an outsider, trying to provide feedback for JSP 2.1. My concern was that the introduction of EL support for “#{ … }” was going to break WebWork-based applications. This is because OGNL uses the notation “#{ … }” to construct maps.

I was already quite annoyed that JSP 2.0 stole (and I do mean stole) the use of “${ … }” in web applications. It forced WebWork to use the syntax “%{ … }” instead. It is my belief that specifications, especially ones that allow developers to plugin so freely as JSP, should not restrict the types of content without offering options. JSP 2.0 did not, and JSP 2.1 is on track to repeat the same mistake.

Case and point: Mark Roth and Pierre Delisle are both Sun employees are are leading the JSP 2.1 spec. They have both been gracious enough to engage in long threads with me on the public users mailing list. And while they have been generous with their time, nothing has changed and I get this distinct feeling that in this situation, the JCP has merely been a public-facing mask for Sun to force their choices upon the community.

My gripes are:

1. The introduction of #{ … } is a foolish move in the first place. While I understand the motivation (JSF uses this notation), I don’t approve of “patches” on specs to correct the mistake of other specs, namely JSF.
2. I believe JSP 2.0 made a huge mistake by stealing ${ … } and not giving tag authors the choice of not processing those JSTL expressions. JSP 2.1 is not correcting this mistake.

Interestingly enough, JSP 2.1 is giving tag authors the ability to ignore #{ … } notation, but still not allowing ${ … } notation to be ignored (as per this email). This indicates to me that Pierre and Mark understand the problem, but are either unable to explain their rationale or are just refusing to listen to the needs of tag authors such as myself.

After that thread, Pierre pointed me to this old thread between Mark and myself where Mark rationalized why they wouldn’t allow tag authors to ignore ${ … }:

It is very important, for readability purposes if nothing else, that ${foo} means the same thing in a JSP page, no matter which tag it is used in. In particular, we do not want tag authors to write their own extensions to the expression language or use a different expression language in some tags vs. other tags. Allowing this would very quickly lead to a huge mess of unreadable pages. Also, when we introduce new features to the JSP EL and tag libraries don’t keep up, page authors would have to memorize where they can use the new features and where not. I hope you can see why we want to avoid doing this. If not, I can give you some more examples.

I can understand where he is coming from, but I just don’t agree. I think if someone is using WebWork, they will know exactly what they are doing with ${} and #{}. Moreover, I think Mark gives the tag author too little credit and gives the tag user far too much credit (how many tag vendors do you use in a single page? One? Three at the most?).

What do you think? Is the JSP 2.1 spec going in the right direction by integrating closely with JSF and JSTL/EL? Is the JCP really just a false-front for large corporations like Sun to have their way? Am I totally on crack?

I’ve been meaning to write down some of the FireFox plugins I can’t live without. Please add any you think I should check out!

• Not really a plugin, but the JavaScript shell boomarklet rules.
• The Web Developer Extension is a must-have. The two best shortcut keys are Ctrl-Shift-Y (don’t actually click, just float over objects and see their DOM tree in the status bar — easier than the DOM Inspector) and Ctrl-Shift-E (edit CSS, you can tweak CSS styles on the fly, trying out things in real-time).
• Venkman is an awesome JavaScript debugger.
• JustBlogIt is a nice way to quickly blog about webpages you are browinsg.
• Bloglines Toolkit is a great way to keep track of all those blogs. If you aren’t using Bloglines, I suggest you try it out. And check out my blogs too!.
• SpellBound is a great spell checker for FireFox — a must have if you blog or write email from within web forms.
• Gmail Notifier is a great way to keep tabs on my personal email.

Obie is gushing again about how Ruby on Rails is a revolution. Give me a break.

There’s nothing special about Ruby on Rails. First of all, anything that depends on the MySQL ordering of columns (did anyone take a relational algebra class at ThoughtWorks?) or wowing people by converting “birth_date” to “Birth date” is seriously questionable (see the 10 minute getting started demo).

More importantly, however, is that besides the religious strong-typing vs. weak-typing that always comes up between Ruby and Java, Rails isn’t doing anything a Java web framework can’t. The key thing that RoR is doing right is the same thing that Spring is doing right: shipping the code with a bunch of useful components and code generation tools out of the box. They definitely either got lucky (which I doubt), or have a much better understanding of marketing than most open source developers.

You can expect that WebWork, RIFE, Tapestry, and others are already learning from this and will provide very rich UI components — even ones that make you Illustrator folks happy

Update
Ryan — you seem to have missed the point entirely. I’ve been saying that (comment about turing complete) all along:

http://www.lightbody.net/~plightbo/archives/000144.html

The point is that WebWork, Tapestry, and RIFE all have just as many users as RoR saying they don’t suck — and I can guarantee you WebWork doesn’t. What I’m pointing out is that the unique thing RoR has done is not technical at all (not even a “suck” vs. “unsuck” thing), but a major marketing victory. They identified a pain point (getting started quickly) and addressed it. That’s certainly something other frameworks haven’t done well.

I know… gasp — I’m admitting that most Java frameworks have failed at something. I’m sure the RoR fanboys are just fuming that I’m being objective and (shockingly), practical, and even admitting that RoR did something well.

Quick, the sky is falling!

(If I’m wrong, please show me where RoR’s core technology — NOT the included components or code generation on top of it — make a revolutionary leap over any of the major afformentioned frameworks)

PS: Gavin is right about my incorrect statment about static/dynamic typing. The point I am making is that on the /. threads, the only talk you see is about “I need an IDE” or “the language is the tool”, which eventually come back to typing arguments. They are religious and have nothing to do with RoR.