Reinhard Poetz wrote:
Derek Hohls wrote:
Grzegorz
Do you think this a valid criticism - are "WebObjects" (whatever
those are) or Struts (Java coded framework) really that more
productive and easy to use than Cocoon??
no, but they come with better documentation.
I have been following this discussion from the sideline, and I have not
worked with Cocoon 2.2 yet, but as someone who regularly trains and
guides other developers in working with Cocoon (2.1), I'd like to add
some thoughts about this.
It is true that Cocoon's documentation is not good enough, and this
*must* improve for Cocoon ever to achieve wide acceptance, but in my
opinion a bigger problem is that Cocoon itself is not good enough. Don't
get me wrong, I think Cocoon is a great framework and I do "believe" in
it. But I just have a strong feeling that for someone without years of
Cocoon experience it is too easy to screw up. Something essential is
missing in Cocoon.
Making the mental transition from "traditional thinking" to the Cocoon
way of thinking (you know what I mean) will always be a requirement for
a developer to be able to write sensible Cocoon applications, and this
is what I focus on in my introductory Cocoon trainings. Some people get
it, some need a little longer to understand, others possibly never will.
This is OK I guess. But once they "see it", the difficulties really
start. Where to go from here? How to develop a real, complex application
with Cocoon?
Of course all the software engineering principles apply as much to
Cocoon applications as to any other, but most people find it difficult
to abstract away from the "traditional" frameworks for which they
learned their patterns, and apply their knowledge to Cocoon. And that's
no surprise, because Cocoon is so big, you can do so much with it, and
you can do it in so many ways. There are some best practices that are
known in the community, about which we speak at the GetTogether, but
that's pretty much it. You really have to learn everything about Cocoon
from the bottom up to find out how a particular type of application is
best set up in Cocoon. Getting up and running with your first Cocoon
project, and this is why this discussion started, is therefor really
difficult. Even the best documentation about how sitemaps and pipelines
work will not solve this!
What really works in my experience is turning the learning curve upside
down and providing people with patterns and components that simply work,
and work transparently, so that at first they don't have to think about
it. For example, Ard put a lot of work in making a website skeleton
generator, which basically does that whole first step of deciding how to
set up the application for you. The generated skeleton is preconfigured
with subsitemaps, caching and everything, and it contains many little
components that do things like paging of lists, mounting subsitemaps
based on our specific navigation concept, etc. This skeleton generator
meant a giant leap in productivity for our implementation partners.
Getting up and running is no longer a problem, and through the pre set
up skeleton the developers seem to get better at working with the Cocoon
concepts much faster. At some point they might even discover that things
could be done in a better way than in the skeleton!
Of course we have our very specific use case of a web site presenting
content from a certain CMS/Repository and our patterns may not work for
other situations, but what I am trying to say is that in my opinion the
missing link between Cocoon as a brilliant framework and Cocoon as a
widely accepted framework is the lack of a mapping between the bare
concepts and actual real-life application development.
Filling this gap is of course more difficult for Cocoon than for web
sites based on a specific CMS, but a first step could be describing how
some common use cases (there's a user list out there == use cases!)
could be implemented with Cocoon, or even better, providing reference
implementations that go much further than the current samples. In my
dream I even see a wizard through which one can generate a preconfigured
application skeleton for a number of different cases. These things exist
for other frameworks you know!
(Blocks and Maven 2 archetypes might be a small first step towards this
dream, I don't know, I haven't been able to check it out yet.)
Anyway, these are just my 2 cents (needed a lot of words for those 2
cents though), I hope it is a useful contribution to this discussion. :-)
Regards,
Niels
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
