[Dojo-interest] AJAX Toolkits

[Frank W. Zammetti]

On Mon, December 17, 2007 2:21 pm, Daniel wrote:
> Frank W. Zammetti wrote:
>> I'm using Dojo in a large production app, although we've slowly been
>> migrating away from it piece by piece.
>
> May I ask why you are migrating away from it?

Well, let me preface the answer by saying that we started with version
0.3.0 and never upgraded for a couple of reasons, including the fact that
we had to make quite a few mods to get it where we wanted that would have
to be dealt with, and of course the usual thing: too much other work that
didn't leave time for an upgrade that wasn't necessarily required.  Also,
by the time we decided that an upgrade might make sense (because Dojo had
evolved enough to make it worth finding the time), there was no good
upgrade path (we spent some time investigating simply upgrading to an
0.4.x version, and when we tried we found that a great many things broke,
and sorting it all out wasn't something we felt we had the time for). 
Note that I'm not criticizing Dojo for not providing an upgrade path or
anything, just stating the facts.

The first issue is that we had (and still have) a lot of junior developers
that weren't all that well-versed in client-side development, which
becomes an issue when there isn't enough solid documentation/examples for
them to go to (which I think it's fair to say was a problem with Dojo
around that timeframe, regardless of what the situation may be today). 
The few of us that are senior-level leads can't afford the time to do all
the work that might be required, so we need our junior developers to be
able to handle things.  Even today, while the documentation is *clearly*
better (and kudos to all that played a role in that), when compared to
many other libraries it still doesn't stack up very well.

(I don't want to go off on too much of a tangent here, but examples are
one area I see Dojo as still being very weak... for example, when I go to
the web site and click the demos link up top, I see two examples... now, I
actually just realized there's a *little* more if I click the Quick Start
link, which I'd never seen before... so maybe this is partially a case of
the web site not being organized as well as it could be.  But be that as
it may, I'd love to see *a lot* more examples, and not just of widgets)

Second, for a while we had quite a few performance issues.  Now, I think
we've got them all sorted out now, most of it was just tuning and fiddling
with our own architecture a little bit.  In truth, Dojo was probably only
responsible for a very small percentage of the performance issues, but it
was enough to put a bad taste in our mouths (maybe not fairly so).

Third, we found that there were better alternatives for the things we
wanted to do.  For example, we switched menu and toolbar widgets to dhtmlx
components because we found them to be superior to what Dojo offered. 
This can of course happen no matter how good Dojo is, which is why it's
not a criticism of Dojo from my point of view.

The final reason is one of philosophy.  There are two facets to this. 
First, we all agreed internally that the code in Dojo is pretty complex
and difficult to follow.  Now, again, I remind you we are still using
0.3.0, and I can't make any comment about the current code because I
haven't looked at it in some time.  But, our feeling was that any time you
had to muck around with Dojo's internals (which was more than we liked at
the time), it was a pain to do, and only a few of us could frankly handle
it.

The second facet to the philosophy point is that we decided, because Dojo
wasn't the clear winner in terms of "do it all" libraries, it was
therefore better to go "best of breed".  Now, it would be fair to say that
it Dojo was clearly good enough in every regard we cared about, a single
library would be preferable.  But, because it's not (nor is any other
library that we're aware of by the way), better to not tie our hands in
some areas, which is what we'd have to do to stick with the philosophy of
one library.

> And what are you migrating to?

Well, as you can tell from the above, it's no single entity.  We're still
using Dojo in some places, and will continue to do so for some time, if
not forever.  For example, while we essentially now have our own
application framework in place, under the covers all the AJAX work is done
with Dojo.  In this area, Dojo is more than sufficient, and we're not
going to migrate that existing code.  All new development however is using
DWR, but not because there's any problem with Dojo's AJAX functionality,
it's just that using DWR leads to an underlying architecture that we
greatly prefer.

We're still also using one or two widgets, and may continue to use at
least one of those.  I'm not sure we'd use any new Dojo widgets though
with the version we're on now... I think in an ironic way, if we migrate
away from all Dojo widgets, we could then pretty easily I suspect upgrade
to the latest version, and might wind up using more of Dojo, including
widgets!  Sounds kind of backwards, but it's not out of the realm of
possibility.

Like I said, dhtmlx has been a good inclusion.  We're also using
ActiveWidgets for some other things (I still find it to be the best grid
implementation around).  There's a chance we'll use some of Ext JS shortly
as well, I'm not sure yet.

> In the context of your mostly-positive review, it seems odd.

Yeah, that's because my experience with Dojo has been mixed.  I still love
the idea of a single library that does everything we need, and Dojo is to
this day the closest I've found.  It's also clear to me that the folks
working on Dojo are very talented and know what they're doing, and that
continues to make me very hopeful that some day we'll look at Dojo and say
"yeah, there's not even a debate, that's what we should be using".  So, I
lean a bit to the positive side for sure, but that doesn't change the fact
that I have some less positive feelings about it too.  The most common
complaint I hear about Dojo is documentation, and that would be my primary
complaint as well.

It's also because if you look at the reasons I've stated, probably half,
or more even, isn't anything Dojo as a project is doing wrong.  The point
I made earlier is that Dojo has been steadily improving since I've been
aware of it, and I think that's the key point for people to remember. 
Believe me, if I didn't see that happening I wouldn't be even remotely
positive.

I clearly have to cut the project a lot of slack because my experience
has, by and large, been with earlier versions (I've been playing with 1.0
a bit lately, considering writing a book on Dojo).  But, I've also been
keeping an eye on things the whole time, and while progress has and is
being made, it's taken a little longer than I would have liked.  Clearly
it's better to take your time and get things right, but when you're
involved in a number of active projects that have needs you have to
fulfill, even the speed of development has to be taken into account.

Bottom line, because I don't want the message to be lost: Dojo is on the
right track, as far as I'm concerned.  There's things to be dealt with to
be sure, some I wish had already been dealt with (or dealt with better
than maybe they were), but if a year from now everyone is using Dojo
without a second thought, I won't be at all surprised by that.

> Best,
> Daniel.

Frank