|
From: | Lars Sonchocky-Helldorf |
Subject: | "GUI Builders: Data vs. Code" |
Date: | Sun, 22 Jan 2006 02:31:24 +0100 |
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
[Prev in Thread] | Current Thread | [Next in Thread] |