> Domain-specific abstractions do that *faster* than GUI designers, not
> slower. And better, too, since every iteration tends to be fully
> functional and not just a "let's see what this looks like" prototype.
Can you show me some working, in-use example for that? I _seriously_ doubt
that the process of rearranging and tuning the layout can be done faster in
the text-world than with a good designer like qt-designer. But I'm all ears
for better solutions.
BTW, when I talk of gui designers, I _only_ have them for creating guis - no
attaching of event code or stuff like that (except from some trivial
signal-slot-connections, that is)
As a programmer, the only thing of interest to me are the certain widgets I
need my logic to bind to. The structure of the thing itself I don't care
about.
>
> Heck, switch 'em out dynamically based on what day of the week it is and
> how the user feels today. Let's see your GUI-designer do that.
>
> And if you're not used to doing it that way, you'll be *stunned* at how
> much stuff tends to factor out and get easily re-used.
Well - stun me by example :)
>
> An approach that has more data to work with (some idea of what things are
> doing and what they are for) will beat an approach with less data ("thing
> at row 4, col 2" or, worst case, "thing at 233,144") any day.
Hm. There certainly are cases where I take smaller building blocks and
rearrange them according to my current needs - all in python of course. But
that's only a comparably small part - at least to my current apps. It
could grow depending on the type of application - e.g. database driven
stuff - but so far, I'm pretty well with creating the larger
dialogs/widgets in the designer and when the functionality is working, the
rearranging of these widgets for better usability is pretty important and
certainly easier done in the designer.
To me the whole discussion is similar to generating html using python or
using templates - templates need only to conform to a certain interface for
the app writer to work. Sure, sometimes things get a little bit more
tedious compared to just printing out html fragments. But the more control
you want over the look of your results, the less powerful the generating
approach becomes - because you simply lack the features to control the
layout or you take deep steps into parameter hell - but then I see html as
a domain specific language and prefer to use that to control the layout.
I've seen such development in the java-world using struts, where people
introduced their own tags for displaying data objects - over time, some of
these grew 10 or more cryptic attributes for fine-controlling the layout.
Instead of just providing the necessary data and letting jsp do the layout.
--
Regards,
Diez B. Roggisch
--
http://mail.python.org/mailman/listinfo/python-list
