Slashdot Mirror

Scala also keeps Java's strong static typing and adds functional language features. I don't think it needs any development at all to be adapted for mainstream use.

Scala is a great thing, now what it needs is equally great tooling (i.e. IDE support, including refactoring, on the same level as we have for Java). And it's getting there - there is an Eclipse plugin, and a NetBeans one - but it definitely needs more work and polish.

The payoff would be huge, though. Right now, as far as languages go, C# is far more advanced than Java. But Scala is equally more advanced than C# (the only thing on .NET that could compare with Scala is F#, and that's less stable and mature currently... but it will stabilize once VS2010 is released, so there isn't much time). Some significant investment into Scala by one of the big players could help straighten things out a bit (it's good when there are two major competing languages in the same niche, because it forces them to evolve at a more rapid pace, steal each other's features, and learn from each other's mistakes - as Java and C# did for several years, until Java began to stagnate).

About the only thing I don't like about Scala is generic type erasure it inherited from Java to maintain class compatibility; but there are workarounds already, and if Scala becomes The Next Language for the Java platform, it may well deprecate erasure and introduce its own reified generics then.

Now, if only someone would pick it up and throw money (and marketing resources) at it. Like, say, Google...

That's interesting. I wouldn't know though. Since version 5.0 I switched to Netbeans exclusively.

Can any free Java IDE Just Work(tm) with making simple executable .jar files?

I know you're a troll but out of curiosity I just went into the dist directory of one of my projects and typed jarfile.jar at the command line and the application started.

I didn't do anything special to make that happen and since I always run it from within the IDE I never bothered to do anything special to set it up. I took a look at the manifest.mf in the archive and it automatically added the correct info.

You must have done something wrong.

The Matisse editor in Netbeans is powerful and full featured. I can tweek every little ass-hair of every little component. Wait - what's all that crap in my source editor? It dosen't look familiar, and to add insult to injury, Netbeans is telling me that I can't edit some code?

Some parts of the code are tied into the visual editor so it doesn't make sense to edit them by hand. Some of the methods, like for actions, may be confusing to people who aren't experienced with swing, but it all starts to make sense after a while.

There are a ton of great Netbeans examples on the Netbeans site.

It's a brilliant strategy to discourage inexperienced folks whose time matters(the operative phrase since we don't have 20 hours a day to roll dice trying to get things to work) from studying computer science.

A tool can't make you a programmer, it can only help you be a more effective programmer. If you don't know how to fix cars, the best tool set in the world won't teach you how to replace a timing belt.

I guess you could muddle through some easy stuff that "Just works" like the good old VB, but don't get me started on that.

Wasn't the build that was choking, it was the IDE.

And pretty sure it was because of this bug

Admittedly i havn't tried NetBeans with the latest builds of the JDK, nor tried the latest releases of NetBeans(last i tried was 5.0 and 6.0), but Eclipse works fine for us, so there is very little incentive to change at the moment.

Can you recommend any good beginner references to get started with J2EE stuff?

FWIW, you should probably start with Glassfish (aka Sun Java System Application Server) and Netbeans. That combination is extremely smooth for J2EE development and will have you up and running in no time flat. (Plus it's all open source. ;-)) Just visit Netbeans.org and grab the full version or the version with Glassfish bundled.

Once you get it setup, you can configure features like the JDBC connections through the admin console on http://localhost:4848. The default user/pass is admin/adminadmin.

You can then review the official tutorial here. It covers the concepts pretty well. Truth be told, though, you can skip most of the details for now and jump straight to servlets. Servlets are Java objects that respond to network requests. HTTPServlets thus have methods like doGet, doPost, doPut, etc. All you have to do is read in the parameters passed and write out to the output stream. Due to their relative simplicity, the JavaDocs tend to be the best reference for programming servlets:

http://java.sun.com/products/servlet/2.2/javadoc/

(Don't be fooled, though. Simple ideas are some of the most powerful.)

The one part that's not covered by the JavaDocs is the deployment. You will need to understand the web.xml file for mapping servlets to URIs. Thankfully, Netbeans has some GUI tools that can help you understand the format and how it works. Advanced servlet development can have a whole chain of cool stuff like classes that intercept requests before and after the servlet runs (filters) and event listeners on session creation and destruction.

Once you understand servlets, then you can move on to JSP pages. At their simplest, JSP pages are HTML with code that get compiled internally by the server into servlets that print out the HTML. (Take a look at the generated code sometime to understand JSPs inside and out.) Modern JSPs should be written with taglibs. Taglibs basically work off the page attributes collection. Rather than working with solid page variables, entries are created inside the hashtable used to store page attributes. (These are attributes that exist only for the period of the request.) The standard pattern for these is that you execute a tag to retrieve a collection of information, then you use tags to output and/or loop through the values.

Servlets and JSPs can be chained by using the RequestDispatcher.include and forward methods. This allows you to not only include one page inside another, but you can also use the page attributes to forward data around. e.g. Let's say you have a servlet that reads from the database in response to a user's input. It can then dump the results into an attribute and call off to a JSP for rendering of that data.

Once you get that stuff down, you can start looking into the other features of J2EE. The JNDI directory is a wonderful way to handle connection pools. Don't put your connection information in your pages! Let the J2EE server manage the pools through the directories. This will make your application more adaptable. JMX allows you to wire up all kinds of meta-data about your app in the same way that SNMP is used to manage network devices. The authentication system can be used to automatically restrict resources without having to write protection code into your application. Java messaging can be used to send messages between systems. JavaMail is obvious. Support for SOAP/XML-RPC/REST and other features are built into the server and are easy to use. EJBs are best ignored unless you're developing a compute engine. (If you don't know what that is, all the more reason to ignore EJBs.) Java Server Faces should be avoided at all costs.

While that just barely scratches the surface of J2EE power and scalability, hopefully it will be enough to get you started. :-)

what's this new python IDE you speak of ? The new netbeans implementation ?

JSF, RichFaces, Hibernate, MySQL, developed on NetBeans and served by Apache TomCat on CentOS for a state government contract.

We have to train ourselves, but that's half the fun.

The other half will be when we pull the plug on one legacy Oracle database with a per CPU cycle license the state is paying an obscene amount of money for.

The other dvcs Mercurial: Tortoise, Eclipse, Netbeans
I don't see, why the workflow has to become more complicated for server-side things like Jira and Confluence: you simply create a automatic server-side conversion from your central dvcs repository to a svn repository for those tools are done with it.

komodo edit is an extremely powerful editor that works with a slew of languages on Windows, Mac and Linux. It is free as in beer. It is packaged by ActiveState as just an editor - but really it has many features that fall more into the IDE camp - yet it is light-weight and responsive - more like an editor. This review of komodo edit may be helpful.
 
  Komodo IDE is the big brother to Komodo edit I guess. I've never used it because the cost is outside my budget. ($295 for a full single user license - there is a student version but I don't know what it costs)
 
  SPE is free/free I believe. It is multiplatform and the price is right to at least give it a try.
 
All these and more are listed on the python ide page of the python.org wiki.
 
Personally - right now I use Komodo edit while I wait for python support in netbeans.

The problem is that java is so f***ing complicated that you would need a 3D map to start with it.

With all respect to you, but I'd say this is complete BS. I am telling you, man, on the time ago when I had to start with Java thing, it took for me a week to figure out entire language and basic frameworks to start making SOA on GlassFish and Swing clients just as it is. All you have to do is to learn how to read books...

Java is very easy language in compare to C/C++...

Answering question to the author, it is like this:

• Get NetBeans IDE at http://www.netbeans.org/
• Go read tutorial on Sun Microsystems: http://java.sun.com/docs/books/tutorial/
• Get Spring framework and get understand it how it works and why it is good idea.
• Go recursively to each interesting topic and investigate it till the last bit.
• Additionally, as moral support, go read [again] "Hacker Howto" if you have doubts -- http://www.catb.org/~esr/faqs/hacker-howto.html

• Have fun!

P.S. Works for me...

try java.sun.com and click on the learning link.
also use netbean for codding it realy helps
PS. Why dose slashdot require www. at the start of urls thats realy stufed up

1. Get a copy of Head First Java .
2. Download the latest version of Java.
3. Download Netbeans or Eclipse (I prefer Netbeans, but I use Eclipse at the office, and I don't have a problem recommending either one). Make sure you get a version that includes either Glassfish (Netbeans) or Tomcat (Eclipse), so you can run some servlets.
4. Start going through the book. You'll learn the Java syntax and conventions in the first part, then learn about web development. Since you've got web development experience, you can probably skip a lot of the intro (web apps use the HTTP request/response cycle, are stateless unless you stick stuff in the session, etc.) and dig into some JSPs.
5. Once you can get data from the browser to the server, pick up JDBC and stick it in the database. If you've used ODBC with VB, then you'll have no trouble picking up JDBC.
6. Pick up a Spring book (I'll recommend Spring in Action) and learn about dependency injection. It's a pretty simple concept, but you'll be amazed what you can do with it.

That should give you enough to get started and maybe even get your first Java gig. Hibernate's good to learn, too, but on most of the projects I've been on, you don't use it in day-to-day development (that is, you don't have to reconfigure or redeploy anything, unless your data model changes). With Spring, just about everything you write will require that you modify a context file or two, so you need to know what's going on.

What's wrong with NetBeans. I know a lot of people prefer Eclipse, but personally I like Netbeans better. Netbeans definitely isn't a bad product. And if you count Forte, it's been around quite a bit longer than Eclipse.

1. collaborations tools
2. user friendly design

This article is silly and I also wonder if the author actually grasps the whole concept of UML's. IMO the article basically boils down to "UML will die because programmers hate it". But isn't this something which has been going on for the last 30 years or so? When looking at the things a programmer dislikes (generalizing:) you can be sure that documentation will score high on the list. Heck; from what I understand its even one of the key reasons why Java invented javadoc. A means to produce the maximum amount of (usefull) documentation with a minimum amount of effort on the programmer.

But even despite the disdain the need for documentation hasn't gone away... Next thing I wonder about is the fact that UML can be used by more people than merely the programmers. When looking at use case diagrams one of its basic requirements is that it will only describe the functionality of the program from a - users - point of view. It shouldn't reflect anything which has something to do with programming or programming techniques. Its solely aimed at design, not technical implementation.

But the main reason why I simply chose to disregard this article as fud is the fact that the author mentions "expensive tools" and "java" in the same article. Guess what? One of the main Java IDE's called NetBeans offers native support for UML modeling. And yes; NetBeans is free.

And well, to finish up; when looking at the bottom of the article you'll see that this story falls right into the same category of the article we had a couple of days back stating that Java was to die very soon now thanks to the likes of Ruby and Python. I sure hope /. will ignore silly articles like these for a while now. Its boring.

This article is silly and I also wonder if the author actually grasps the whole concept of UML's. IMO the article basically boils down to "UML will die because programmers hate it". But isn't this something which has been going on for the last 30 years or so? When looking at the things a programmer dislikes (generalizing:) you can be sure that documentation will score high on the list. Heck; from what I understand its even one of the key reasons why Java invented javadoc. A means to produce the maximum amount of (usefull) documentation with a minimum amount of effort on the programmer.

But even despite the disdain the need for documentation hasn't gone away... Next thing I wonder about is the fact that UML can be used by more people than merely the programmers. When looking at use case diagrams one of its basic requirements is that it will only describe the functionality of the program from a - users - point of view. It shouldn't reflect anything which has something to do with programming or programming techniques. Its solely aimed at design, not technical implementation.

But the main reason why I simply chose to disregard this article as fud is the fact that the author mentions "expensive tools" and "java" in the same article. Guess what? One of the main Java IDE's called NetBeans offers native support for UML modeling. And yes; NetBeans is free.

And well, to finish up; when looking at the bottom of the article you'll see that this story falls right into the same category of the article we had a couple of days back stating that Java was to die very soon now thanks to the likes of Ruby and Python. I sure hope /. will ignore silly articles like these for a while now. Its boring.

I think you would like to see netbeans:

http://php.netbeans.org/

Python blows Ruby away.

And I guess Sun commmitting to make the JVM into a VM and guess what the next language will be....Ruby...WRONG.....Python

On the other hand, Microsoft's IronPython is way ahead of IronRuby in terms of stability (they've actually had a 1.0 release already), so it seems that it's what Microsoft is betting on.

Judging from some of the activity here, that's probably not a serious question. But let's pretend it is. However, a lot of little Bill fans will get their feelings hurt.

Bill's toy bag is just that, a toy bag, that what little it does is on and for Windows -- only. And it's near a few decades late in coming. A comprehensive answer could go on for pages if you start to include various languages like Java, Python, Perl, C, and Ada. or Tomcat, Lenya, Swish, and many others staples. That's not even counting PHP and PHP-based kit, CPAN and others.

However the press release does not say what the MS "tools" do or, more correctly, claim to do. Students would be more employable playing WoW. For those that have been living in a cave for the last 15 years here's a recap of the main professional tools you will find in industry. There are others, but they're mostly open source, too, except a few big items like Oracle and DB2. None are MS.

IDEs

• Netbeans
• Eclipse
• Emacs - it's underrated
• Kdevelop - it's also underrated

Databases

• MySQL (now Sun)
• Postgresql

GUI toolkits

• Qt (now Nokia)
• GTK+
• wxWidgets

MS has held back computing far too long. The sooner it gets out of the way, the sooner both business and research can get back on track. Bill and his anti-American movement can go take a hike, there's no place for either MS or MS boosters in today's economy.

Let's pretend that's a serious question. Well, the press release does not say what the "tools" do. However, for those that have been living in a cave for the last 15 years here's a recap of the main professional tools you will find in industry. There are others, but they're open source, too, except a few big items like Oracle and DB2.

IDEs

• Netbeans
• Eclipse
• Emacs - it's underrated

Databases

• MySQL
• Postgresql

GUI toolkits

• Qt
• GTK+
• wxWidgets

The list could go on for pages if you start to include various languages like Java, Python, Perl, C, and Ada. or Tomcat, Lenya, Swish, and many others staples. That's not even counting PHP and PHP-based kit. Bill's toy bag is just that, a toy bag, that what little it does is on and for Windows. And it's near a few decades late in coming.

MS has held back computing far too long. The sooner it gets out of the way, the sooner both business and research can get back on track. Bill and his anti-American movement can go take a hike, there's no place for them.

For the User/Developer, among the best are ... "Open".

Apache FOP: http://freshmeat.net/projects/fop/
Apache FOP: http://xmlgraphics.apache.org/fop/download.html
    NetBeans: http://download.netbeans.org/netbeans/6.0/final/
    Alfresco: http://www.alfresco.com/

Good Guide: http://www.vrcommunications.com/PDFs/ditaotug141-03122007-pdf.pdf
Title DITA Open Toolkit User Guide: Fourth edition, December 17, 2007. Based on release 1.4.1 of DITA Open Toolkit. All files copyright 2006-2007 by VR Communications, Inc., unless otherwise indicated. Licensing Edition, release, copyright and usage of this document and related materials is regulated by a Common Public License (CPL) granted by OASIS (Organization for the Advancement of Structured Information Standards), http://www.oasis-open.org/ . DITA Open Toolkit is an open-source, reference implementation of the OASIS DITA standard (currently DITA 1.1).

JAVA: http://www.java2s.com/Open-Source/Java/CatalogJava.htm
Open Office: http://www.2008-official.com/openoffice/

I can't believe this is actually being defended.[...]How on earth can you continue to defend 'text' editing performance?

Believe what you want. I have used VB/VS, and they were nowhere near what Netbeans offer. Delphi I don't know, but is the IDE capable of all this? Running on multiple OSes? I doubt it.

The load times I give you, they are pretty atrocious, but Netbeans6 is beta, and I believe Sun is working on reducing JVM load times, and Netbeans especially.

Perhaps you could 'just' get the sourcecode printed in a book, export that and scan it like they did with PGP.

From http://www.netbeans.org/about/legal/terms-of-use.html

e. Export Compliance. Materials and Submissions may be subject to U.S. export controls or the trade laws of other countries. You agree to comply with all such laws and to obtain such licenses as may be required. Materials and Submissions containing encryption software, technology and/or technical assistance involving encryption (collectively "Encryption Technology") may be subject to U.S. Export restrictions. You agree not to submit any Encryption Technology to this Site. You warrant that you are not identified on the most current U.S. export exclusion lists or located in or a national of countries that are prohibited from participating in this Site by reason of U.S. embargo or other trade prohibitions as specified in the U.S. export laws, including but not limited to the Commerce Department's Export Administration Regulations (EAR) and the Treasury Department's Office of Foreign Asset Control regulations. You agree not to use Materials and Submissions for nuclear, missile, chemical, or biological weaponry end uses.

You know BlueJ is Netbeans, right?

Uh... No, it isn't...

Now, there *is* a variant of Netbeans called the "BlueJ Edition", but that is not the same thing as vanilla BlueJ.

At all. Believe me.

If you think NB is slow, turn off some modules you don't need.

I do better than that. I don't use it at all. :-)

You know BlueJ is Netbeans, right?

Uh... No, it isn't...

Now, there *is* a variant of Netbeans called the "BlueJ Edition", but that is not the same thing as vanilla BlueJ.

At all. Believe me.

If you think NB is slow, turn off some modules you don't need.

I do better than that. I don't use it at all. :-)

I just picked up Netbeans for the first time in about a year due to the Ruby support. I have to admit, it is quite nice. I'm not a java programmer, so anything that comes with java as a requirement sorta rubs me as wrong AND slow. It has a high hill to climb to get me excited. Ruby support in Netbeans 6+ does that.

Grab the Ruby specific Netbeans versions here: http://deadlock.netbeans.org/hudson/job/ruby/ OSX, Win32 and full versions available.

Well, if you take ten seconds to look at the download page for NetBeans, you'll notice not only have C/C++ tools been moved, but they've got convenient packages for your needs.

You should try out netbeans with the c++ add on. Eclipse is great, but I've been really impressed with the progress that's been made with netbeans. I think 6.0 is going to be phenomenal (it is in beta now).

I would just cite emacs, but since you seem to be interested in something more...graphical...I'll just list these three:

* Eclipse

* KDevelop

* Netbeans

Eclipse's visual Editor is a joke, while NetBeans one is very easy to use and complete. Of course, it is my subjective statement, but i have yet to see something nice coming out of Eclipse. And there's this nice article so you can see for youself:
http://www.netbeans.org/kb/50/quickstart-gui.html

But it doesn't matter because most people don't know how to make decent UI form if their life was depending on it.

Eclipse + Java + CVS, woohoo. Welcome to three years ago. How about instead let's try:
* Textmate / Netbeans
* Ruby (Rails or Merb for web programming)
* SVN or Git for source control

eclipse

netbeans (recently revamped, much better than before)

codeblocks

http://www.netbeans.org/products/cplusplus/

http://www.ibm.com/developerworks/opensource/libra ry/os-ecc/

Use the Netbeans GUI builder tools and the Visual Web Builder. Throw jMaki into the mix and you can start having fun again.

IIRC netbeans runs on linux platform fine and has addon for c/c++.
http://netbeans.org/

Code::Blocks, The open source, cross platform Free C++ IDE

http://www.widestudio.org/
http://www.netbeans.org/
http://www.netcomputing.de/html/main.html

was: how about...(Score:1)

http://www.netbeans.org/products/cplusplus/

To all users of:
  -vi(m)
  -emacs
  -kdevelop
  -anjuta
  -eclypse

Shove your IDEs deep into your asses. They are shit and that's where they belong. Tx.

The one good thing about c, that is also true for assembler *and* python, is simplicity. You don't *need* an IDE to get from idea to working program. Programming java with notepad and javac very quickly becomes difficult to manage, due to classpath-issues. But with c and assembly you'll still need linking for anything but the most trivial programs -- another win for python (or perl, ruby tcl, lisp etc).

The other advantage is that Java and C++ can be had for free with nice helpful IDEs. The Eclipse CDT (http://www.eclipse.org/ ) with cygwin (http://www.cygwin.com/) provides a fairly full IDE (and you can tailor it's key interface to EMACS :-) ). Eclipse also looks to be a fair Java IDE and there is also netbeans (http://www.netbeans.org/).

As a book I would suggest one I have enjoyed using in its online form, Thinking in C++ by Bruce Eckel (http://www.mindview.net/Books/TICPP/ThinkingInCPP 2e.html). It has the advantage that there is also a second volume that takes you into using more advanced features (fancy templating, STL, and some more complicated patterns) that they can look into or you could use as a follow on.

Take a look at the videos that demonstrate Netbeans 'Matisse' GUI builder. I use it all the time, and find it quite handy:
http://www.netbeans.org/kb/articles/matisse.html

There's Netbeans which has a GUI builder. (Which, IMHO, sucks. Or at least did the last time I used it.)

Eclipse also has plugins (the Visual Editor) to allow creating GUIs graphically. (Which is, IMHO, worse than Netbeans's.)

So, there are GUI building tools. They just suck. (IMHO, of course.)

Personally I'd like to see something like XUL where the GUI is specified using a markup language. Which is why I started writing one and then never released it.

NetBeans (available as a Free download) has a very nice built-in GUI builder.

Java developers though are left with either hand coding of GUIs or potentially messy and brittle code generators.

Whenever it comes to Java it always amazes me how many people have very outspoken opinions about it while its almost immediatly obvious that they hardly know what they're talking about. Then again, when reading the article its becoming obvious that when he's talking about GUI's (since when do you code in a GUI? I use an IDE for that) he actually means to say Eclipse. Don't get me wrong: I'm not dissing Eclipse here, but do question his bias.

When it comes to building GUI's Java really allows itself to be used by code generators IMO simply because Java is very modulair build. The only problem you might face here are the somewhat limited layout managers. For the non-Java people amongst us: these basicly define the "interface" between the GUI you're building and the way it behaves. For example; when it comes to resizing or placing of the objects then you're dealing with a layout manager.

Now... When it comes to Java IDE's two names immediatly spring out: NetBeans (my personal favorite) and Eclipse. Now that he has commented on the latter let me comment on the first. From NetBeans 5.0 and up it comes with a fancy GUI builder codenamed "Project Matisse". Its official name is now NetBeans Swing GUI builder. After taking a closer look at that I wonder if he still thinks that there are no decent GUI builders available for Java.

The real problem here isn't so much the GUI builder but the underlying layout manager which needs to keep things in check. I think that also explains why there isn't much of this available as it looks to me as if there aren't many people about who manage to come up with decent Java coded tools which can be used and adopted by many other coders. NetBeans has solved all this by introducing a layout manager of their own, the so called Absolute Layout. Pro's are its extreme extensiveness, the con's are that if you wish to use it you'll have to ship it with your software because its not part of the standard Java Runtime Environment (JRE).

If you wish to see a demo of Matisse in action then check out the NetBeans flash demos, especially the first part of "Why NetBeans?". Personally I'd recommend another approach, namely simply downloading NetBeans and trying it out for yourself. Its available for Linux, Solaris, Windows and I think even OS X.

Java developers though are left with either hand coding of GUIs or potentially messy and brittle code generators.

Whenever it comes to Java it always amazes me how many people have very outspoken opinions about it while its almost immediatly obvious that they hardly know what they're talking about. Then again, when reading the article its becoming obvious that when he's talking about GUI's (since when do you code in a GUI? I use an IDE for that) he actually means to say Eclipse. Don't get me wrong: I'm not dissing Eclipse here, but do question his bias.

When it comes to building GUI's Java really allows itself to be used by code generators IMO simply because Java is very modulair build. The only problem you might face here are the somewhat limited layout managers. For the non-Java people amongst us: these basicly define the "interface" between the GUI you're building and the way it behaves. For example; when it comes to resizing or placing of the objects then you're dealing with a layout manager.

Now... When it comes to Java IDE's two names immediatly spring out: NetBeans (my personal favorite) and Eclipse. Now that he has commented on the latter let me comment on the first. From NetBeans 5.0 and up it comes with a fancy GUI builder codenamed "Project Matisse". Its official name is now NetBeans Swing GUI builder. After taking a closer look at that I wonder if he still thinks that there are no decent GUI builders available for Java.

The real problem here isn't so much the GUI builder but the underlying layout manager which needs to keep things in check. I think that also explains why there isn't much of this available as it looks to me as if there aren't many people about who manage to come up with decent Java coded tools which can be used and adopted by many other coders. NetBeans has solved all this by introducing a layout manager of their own, the so called Absolute Layout. Pro's are its extreme extensiveness, the con's are that if you wish to use it you'll have to ship it with your software because its not part of the standard Java Runtime Environment (JRE).

If you wish to see a demo of Matisse in action then check out the NetBeans flash demos, especially the first part of "Why NetBeans?". Personally I'd recommend another approach, namely simply downloading NetBeans and trying it out for yourself. Its available for Linux, Solaris, Windows and I think even OS X.

Java developers though are left with either hand coding of GUIs or potentially messy and brittle code generators.

Whenever it comes to Java it always amazes me how many people have very outspoken opinions about it while its almost immediatly obvious that they hardly know what they're talking about. Then again, when reading the article its becoming obvious that when he's talking about GUI's (since when do you code in a GUI? I use an IDE for that) he actually means to say Eclipse. Don't get me wrong: I'm not dissing Eclipse here, but do question his bias.

When it comes to building GUI's Java really allows itself to be used by code generators IMO simply because Java is very modulair build. The only problem you might face here are the somewhat limited layout managers. For the non-Java people amongst us: these basicly define the "interface" between the GUI you're building and the way it behaves. For example; when it comes to resizing or placing of the objects then you're dealing with a layout manager.

Now... When it comes to Java IDE's two names immediatly spring out: NetBeans (my personal favorite) and Eclipse. Now that he has commented on the latter let me comment on the first. From NetBeans 5.0 and up it comes with a fancy GUI builder codenamed "Project Matisse". Its official name is now NetBeans Swing GUI builder. After taking a closer look at that I wonder if he still thinks that there are no decent GUI builders available for Java.

The real problem here isn't so much the GUI builder but the underlying layout manager which needs to keep things in check. I think that also explains why there isn't much of this available as it looks to me as if there aren't many people about who manage to come up with decent Java coded tools which can be used and adopted by many other coders. NetBeans has solved all this by introducing a layout manager of their own, the so called Absolute Layout. Pro's are its extreme extensiveness, the con's are that if you wish to use it you'll have to ship it with your software because its not part of the standard Java Runtime Environment (JRE).

If you wish to see a demo of Matisse in action then check out the NetBeans flash demos, especially the first part of "Why NetBeans?". Personally I'd recommend another approach, namely simply downloading NetBeans and trying it out for yourself. Its available for Linux, Solaris, Windows and I think even OS X.

Alright, I'm a little busy right now so I won't go into as much detail as I'd like, but here are the basics as far as I understand them.

1) Design patterns still apply. More than ever, actually. If you've not read the GoF, it features a pretty advanced example centered on the design of a rich text editor. You will probably want to dive deeply into the workings of the Model-View-Controller pattern and the related design constructs. The MVC pattern is not the be all and end all of GUI design, and there are many cases where the articulation between View and Controller

2) You may not now it yet, but you want loose coupling. Loose coupling means that, essentially, when a widget's state change, it will report on that change, and some interested party will be notified about it, and neither will have to know anything about the other. Many toolkit nowadays come with good signal and slot mechanisms to implement loose coupling. Understand them, and use them. If you find the sender of a signal and the receiving slot need to know about each other, you may want to go back to the drawing board as suggested in point #1 above; it is usually not necessary.

Conceiving GUIs is not all about the underlying software architecture, though; a good chunk of the work of making great interfaces is in the designing of the GUIs themselves (which is why you want loose coupling -- you WILL have to be flexible against changes as you experiment). I will let others fill you in about that. Quickly: read usability guidelines and get a feel for why they suggest what they suggest. Align your widgets! NetBeans is good for this, IIRC. Use GUI designer tools, experiment more.

That's all I can think of off the top of my head, but there's already a lot for you to chew in there. :) Hopefully other people will have more details to give you.

All in all, it boils down to the usual rules of engineering: the second rule is to know what works, and the first rule is to know why it works.

I want to be able to develop applications in both Windows and Linux.

Haven't you heard of Java and Netbeans?

I was never big on IDE's always used vim, until recently I started using NetBeans for Java apps at work. NetBeans also has support for C/C++ using the GCC compiler on Linux. It has CVS support with subversion support on the way. Has a class browser, debugger and can use existing makefiles . Its written in Java so its easy to get up and running. Download it play around see if its for you. Screenshots::http://www.netbeans.org/products/cplu splus/screenshots.html