"GUI Builders: Data vs. Code"

[Lars Sonchocky-Helldorf]

Hi Gregory,

I read your blog entry about executable code generating interface tools 
( 
http://heronsperch.blogspot.com/2005/11/gui-builders-data-vs-code.html 
). It is a nice reading, here are some things that came to my mind on 
that regard:

I think the main reason that most Java GUI Builders are creating code 
is that such a beast is easier to implement at first hand: The 
generated GUI "executes" itself and doesn't need some kind of framework 
to do that for you. Nevertheless I consider it the "wrong way to go" 
(TM) since it is

at first the inherently wrong way to describe an interface. An 
interface description is about where the interface elements are located 
and what actions they might invoke. Executable code just isn't 
descriptive enough here, since it mixes things up which is

point two: Interfaces which are executable code mix up an interface 
description with the API that those interface elements have. This way 
the interface is not separated from the GUI framework that is used. In 
result the interface is not portable and

point three: The interface also not easy to maintain since it is much 
harder to parse executable code than some other interface description 
(might it be some flavor of XML or just in the plist format): You can 
easily validate and parse some XML description against your DTD, in 
contrast if the user manually added some code to the generated 
interface code the interface code parser might fall flat on it's face: 
While the code might be syntactically and logically correct, the 
interface code parser /can/ not be ready to parse any kind of code 
(let's say the user uses a self made subclass of some interface element 
which has special methods that the interface code parser can not know 
or he has put some other unrelated code there). So if you use some 
generated code for your interface you won't be able to edit it freely 
by hand and then switch back to your interface builder tool.

point four: If the interface API changes you'll have to redo your 
interface code.

That are the points that come to my mind instantly, I think I would 
find more shortcomings if I would dig for a while.

I think that executable code generating interface builders are just a 
result of laziness and missing thought which won't pay off in the long 
run.

regards, Lars