The issue with the lenient development phase is that you will not know
when you are in trouble until it's too late. That's the age long
discussion of quick'n'dirty vs thorough. An example - what do you
think is more efficient - developing with type-checking and excepions
off and then turning them back on when finalizing the functions, OR
have them on from day 1 ? In my experience the former will give you a
quicker prototype but will take more overall time to the end product
and you'll be in for a couple nasty surprises, compared to the latter
approach which is slower *in the beginning*, sometimes a bit
frustrating, but much safer and quicker on more complex projects and
the long run.

Prototyping tool idea: it might be interesting to make a REVERSE
template generator (this is the place where genshi/kid/django/etc
people laugh their bottoms off). If you have a rough HTML prototype
(made either by hand or by a fancy UI/JS toolkit) you can have that
translated BACK into html helper functions which you can then use for
quick prototyping. A bit on the dark side, but not completely non-
web2py-ish - the important thing is NOT to have three forms. While you
have helpers and html (views) you should be able to convert among them
without much trouble. If you introduce another template step, then the
whole thing becomes meaningless. But this is a discussion worthy of
it's own thread.

PS. Lot's of nice ideas in this thread, keep up the good work ! :)

On Oct 30, 2:19 pm, Timothy Farrell <[EMAIL PROTECTED]> wrote:
> See my comments below...
>
> noobpythoncoder wrote:
> > <snip />
>
> > I Iike the tight MVC paradigm, security, and other good practices
> > built into web2py, but sometimes I wish there was a way to more
> > quickly prototype the front-end, eg test the functionality of SQLFORMS
> > in different views from a user experience perspective, without
> > worrying about this matching the controller side so much at that early
> > development stage.
>
> This is precisely why there isn't "tight MVC" in web2py.  It's loose
> because of the "passing Python objects that make HTML" thing.  Even the
> idea of HTML-helpers is not MVC friendly.  This builds the argument for
> using XML-based templates (such as Genshi/Kid/ZPT/SimpleTAL).  One of
> the ideas is that you should be able to view these templates in a normal
> HTML editor/browser and get a good feel for what they look like.  That
> would be a truly independent View.  While Genshi doesn't adhere to this
> completely (it uses <xi:include ... />), I can still open my templates
> in a browser and get a general idea of what I'm looking at (compare with
> any text-based template language viewed in a browser).  Unless you have
> really good editing/viewing software that can parse templates (I haven't
> seen it), then you're on to Yarko's idea about a minimal application to
> render your templates for viewing/testing.> If anyone knows a way of doing 
> this that I have overlooked, and doesnt
> > involve simply copy n pasting html forms, please write. But if this is
> > a bad idea in web2py - even at prototyping phase - please offer a
> > constructive alternative.
>
> This may be obvious to others but it wasn't to me at first (since I
> didn't start out working on a team).  I work with more old databases
> than new ones so the fieldnames are often cryptic and don't describe the
> data they contain.  Whenever making a template, it's bad to pass in the
> resulting object directly from a query because you end up referencing
> database fields with cryptic names and it makes your templates less
> readable and less reusable.  Instead, define a clear interface for your
> templates with human-readable names for the fields and use the
> controller to map the database results to what the template requires.> Though 
> my teams first web2py app is nearly fully prototyped, with
> > about a third of the backend done, I would like to hear how others are
> > rapidly prototyping in web2py while retaining a good balance at
> > allowing for the development of the backend controllers etc as their
> > apps near production standard.
>
> > Perhaps if it were possible in web2py to switch between a security
> > lenient development phase and secure production phase, a quicker front
> > end development may be possible? Ok, this is probably a stupid idea,
> > but I was thinking back to my php.ini days. ;-)
>
> How about a trunk and branches/tags in subversion?  That's what I do.  
> Wait are you talking about for your projects or web2py?
>
> <snip />
>
>  tfarrell.vcf
> < 1KViewDownload
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"web2py Web Framework" group.
To post to this group, send email to web2py@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at 
http://groups.google.com/group/web2py?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to