Matisse is bad! (and not "bad" in the good way)

I found this paragraph in a recent Netbean review on eWeek a bit disturbing showing a major problem with Matisse:

"Visual convenience has to manifest itself at some point in actual
code: On both of our test platforms, we noted with foreboding that the
NetBeans 5.0 source code view does not initially display the code being
generated by the visual editor, showing instead a comment warning the
developer not to modify that code and collapsing the code itself to a
label using the source editor's outlining facilities. We've always
considered such aloofness a red flag; we saw another warning in that
this code could be expanded and read, but not modified, from within the
NetBeans editor.

Of course, we promptly opened an external editor to see what would
happen if we mulishly insisted on altering the code directly. The
answer is that the visual form designer, upon our reopening that
project element, ignored our source code changes until we used the
visual tools to make other changes affecting the same code regions�at
which point our changes were blown away by newly generated
instructions. That's not the kind of multilateral cooperation among
interacting tools that we've grown to expect from experience with
Borland Software's JBuilder and Oracle's JDeveloper 10g, to name two
examples of the current state of the art. The latter of these, we must
note, is fee-free, just like NetBeans."

So watch out, once you worked with Netbeans to edit your Swing UI,
you are doomed to be locked into Netbeans forever not able to switch to
another IDE, or modifying the code that was generated for you.

At the end of the review the author gives two option for your
evaluation shortlist one is Eclipse and the other is JDeveloper and he
has this to say:

"Oracle's JDeveloper 10g 10.1.3
Lets developers tailor technology portfolios and deployment platforms
to their needs; the platform is approachable but also second to none in
capability and responsiveness."

He also points to the review of JDeveloper they did a while back
where JDeveloper overall scored higher than Netbeans getting 5
Excellent marks compared to 3 that Netbeans got.

(and by the way on the cons in that JDeveloper review they mention
JDeveloper doesn't have a Mac version - which is no longer the case. We
have a dmg packaging for you Mac lovers out there. But on this in a
future post.)

Comments:

Many would consider this a good thing rather than a bad thing. Matisse removes from the eyes of the developer the "Place this over here, that over there and this with relation to these" kind of code. You can, of course, add whatever you want. Also, changing the Matisse code IS possible. The thing is they use an XML to regenerate the code in case someone tweaked the GUI code out-of-platform, which I find a very comfortable feature, as it only regenerates the Matisse-generated code and does not touch the user code, even though they're in the same method. I guess it's in the eye-of-the-beholder kind of thing, but I find these features better, removing the need for manual GUI tweaking as the editors get stronger and give you the options to do what you want graphically.

Posted by Aviad Ben Dov on March 02, 2006 at 03:28 PM PST #

Whoops. I didn't notice that the comments weren't passed to this blog, and there Are actually comments regarding this one. :)

Posted by Aviad Ben Dov on March 02, 2006 at 03:30 PM PST #

Aviad, I agree with you that having a visual tool that minimizes the need to code the "where is this thing going and how it will look" is good. But, this visual tool shouldn't then "lock" the code in sucg a way that prevents you from going and changing the code directly to do little UI tweaks. This is for example what we do in JDeveloper - we give you a visual way to layout your Swing UI (and your JSF/JSP) but you can always also change the code directly. And by the way, you mentioned in your blog that the thing that Netbeans is missing is data binding - one more time I'll urge you to look at JDeveloper and the built-in ADF binding - which actually does this missing thing.

Posted by Shay Shmeltzer on March 03, 2006 at 12:41 AM PST #

Shay, from my experience with a similar tool that gives you the freedom to change the generated code (i.e. Visual Studio 2005), most of the time the programmers do things they shouldn't do (like refactoring the code themselves) and usually destroy the UI code altogether, forcing a rollback and eventually manually doing it. Obviously, you could claim "not the smartest bunch". But I assure you, it's not about being smart at all. It's tweaking things that shouldn't be tweaked manually - The idea, in my opinion, is to improve the UI editor to such a degree that you don't need to tweak. UI editing should, in my opinion, be leveled down to be one of two options: Dynamic UI dialog creation (using loops and what-not, and even then it should use some pre-created panel created with the UI editor), or a totally generated UI window. Regarding data binding, I agree that JDeveloper gives the ability. I have heard a lot about it. Currently my uses of Java stick to the back-end and the algorithmic, and so I won't use neither NetBeans nor JDeveloper at a regular basis. I use IntelliJ. Sorry to disappoint. :)

Posted by Aviad Ben Dov on March 03, 2006 at 06:03 PM PST #

Looks like this blog was moved from it's previous location: http://www.orablogs.com/shay/archives/001672.html Too bad the people's comments have not been moved as well... Arseniy

Posted by Arseniy Kuznetsov on March 05, 2006 at 11:04 PM PST #

Matisse (as well as the older swing designer in pre 5.0 NetBeans) offers multiple ways to customize the code generated within the protected fragments. For any component added to the form, you can add code snippets before or after the components constructor, you can change the code snippet use to construct it, you can add snippets before and after the component's group of setXXX/event attachment calls. You can change the name, visibility and scope of the variables used to refer to each component. You can change the style of event hander (anonymous inner class, etc.) code generated. These features are predominantly available via the [code] tab on the properties panel for each component when you select it. The event handler code generation style option I think is a global option in options. As for lock in, there isn't any lock-in. Matisse generates standard java code. If you don't want to use Matisse anymore, delete the .form file, edit the java file externally to remove the protected comment tags and voila, standard Swing java code you can take anywhere java code is welcome.

Posted by Peter Williams on March 08, 2006 at 11:20 AM PST #

While I understand you have your own agenda to push (JDev), my experience with Matisse is all but bad. I migrated from JDev 10.1.3 developing a rich client in Swing as I found it to be a nightmare to wait for the UI to respond (in spite of having 4200+ X2/1024MB) and the visual editing leaves much to be desired. I would be able to use JDev to do initial prototyping but then something would fail and WUSIWUG editing became unavailable! It is not entirely JDev's fault, for some reason it took SUN 10 years to come up with a decent layout manager (arguebly borrowing a thing or two from .NET's anchoring system) but it is here now and will be part of Java 6 so I would just hope JDev will incorporate support for GroupLayout and let the original antique layout managers die. (This is unfortunately not common in Java, explaining the bloated, depricatede and inconsistant API of today.) NetBeans is simpler probably because it is not cluttered by ADF and all the other tools JDev is trying to be. It is however responsive and less buggy than JDev and even though I do miss a few things, like automatic import, I need a tool that will not frustrate me many times a day and have me curse at why I have to use alpha releases for years at a time. (JDev 10.1.3 was in early preview for far too long.)

Posted by Casper Bang on April 10, 2006 at 10:25 AM PDT #

Casper, I'm wondering if you had time to look at the JGoodies layout that we put into JDeveloper 10.1.3 and how it improves layouting Swing applicaitons. Also if you are looking for a "simpler" IDE without ADF - just pick up the Java edition or the J2EE edition of JDeveloper.

Posted by Shay Shmeltzer on April 10, 2006 at 10:35 AM PDT #

Shay, Indeed I have and still am using JGoodies and it is a lovely fresh breath of air, but FormLayout still is not as flexible and easy to use (or perhaps I just did not spend enough time) as GroupLayout in NetBeans. JDeveloper is a beautifully craftet tool but it frustrates me and I have come to not trust it very much, leading me to only use it when I do ADF or Webservice work. Naturally I constantly reevaluate these positions and look forward to each JDev release - however rare they may be.

Posted by Casper Bang on April 11, 2006 at 02:34 AM PDT #

The things that bug me about Matisse:
1) It provides fully qualified names for every variable regardless of which packages are imported. This generates very verbose code.
2) When it comes to event handler methods, you are unable to reorder these methods, so it makes your code look really unprofessional and difficult to navigate.
3) The object 'snaps' are a pain. Eventually you cannot disable a locked relationship between 2 elements, and you end up having to delete one of those elements and apply the event handling all over again.

I just like to be in full control

Posted by Steve on January 29, 2012 at 01:58 AM PST #

Post a Comment:
  • HTML Syntax: NOT allowed
About

me
I'm a Director of Product Management for the Oracle Java Development Tools.
Follow me:
Search

Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today