> I might be missing some of the context and previous
> discussion, but thought I'd chime in anyway...
>
> I think this is a *terrible* idea. Great for crud
> apps, but as a very heavy user of webwork 1 (and 2,
> increasingly) purely as a *user*, commands (the !
> stuff) are very very useful.
To be clear, this is orthogonal to the "!" notation. It's not about which
action get's executed, but how to configure what happens when that action is
executed.
>
> What's nasty about this proposal is the implication
> that commands are only used for CRUD stuff, which is
> untrue in pretty much any real world app. If all we
> wanted to do was CRUD, we'd all switch to RoR. There
> are often other things that need to be done,
> surprisingly.
Again, this is orthogonal to CRUD or anything else. If you have patterns of
similar things you do often or that need similar configuration, you can define
an archetype for them. That's it. It's not saying you can't have other more
explicit configuration too.
>
> Sure, it should be easy to do crud stuff, as long as
> you all keep in mind that that's the very basics, and
> usually the meat of the app is in non-crud work.
>
Depends on the app. Many times the meat is the CRUD stuff.
> Furthermore, everyone right now 'gets' the pattern,
> and knows how to handle crud stuff using actions.
> Some people might want to define a superclass that
> does the listing, and a subclass that does the
> editing. Some might choose to use different actions
> entirely, some might just go with one class and many
> commands. All these solutions are sensible some of
> the time, at worst. So that's my plea for keeping the
> command syntax.
I think you'd be surprised. People who have already been building with WebWork
for a while know how they like to do CRUD stuff, but I think new users don't
have a clue and want a best practice laid out for them. There were always tons
of questions about it in the mailing lists, and we tried to distill the best
practices we could at the time into the WWiA book.
>
> The idea of archetypes, while nice in theory, doesn't
> work in practice. Objects don't live in an isolated
> happy land where each one maps to an action. They
> interact with one another, they impact one another,
> and many actions exist that manage these
> relationships. What's the archetype, for example, for
> 'asynchronously send an email'?
>
Maybe it's the "standard" archetype which maps to the standard parameter
setting, validating, default workflow interceptor stack and maybe a result
mapping for "${actionName}-success.jsp" for success.
> So to sum up:
>
> CRUD is a useful problem to try and solve, just don't
> get too hung on it being *the* problem.
>
And don't get too hung up on it being the example, either.
> Simplicity (even if it involves some inelegance, eg,
> url's with ! in them) makes users Happy.
Some users yes, some get squeamish about any method being invokeable via URL
manipulation.
>
> Every single snippet you posted looks ugly to me, and
> this project isn't going to impress anyone if it ends
> up with anything vaguely similar.
Ugly, maybe, but functional and easy. To me "!" in a URL is ugly, to you it's
functional and easy. We've been worrying about getting things done instead of
making our configuration pretty. Now it's time to look at making things simpler
and prettier.
---------------------------------------------------------------------
Posted via Jive Forums
http://forums.opensymphony.com/thread.jspa?threadID=41559&messageID=82966#82966
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
