Ever hear the phrase "the interface IS the system?" It implies that what people perceive a software system to be is largely determined by how the system looks and how they rate their experiences interacting with it. Is the system aesthetically pleasing? Were simple operations simple and were complex commands easy? Was information organized logically? Was the system well behaved and helpful with tips, prompts, and feedback?

Users today expect a lot of functionality out of graphical desktop applications and they expect a level of "good practices" compliance as well. The Java platform is a wonderful developer environment, providing many basic necessities that let you build the application of your dreams. Java includes support for a logging framework, a print framework, an undo framework, a menu framework, a preferences framework, and a graphical interface framework.

Using all these frameworks, you can build very creative pieces of software. But words are very important here: "can build" and "frameworks." While this approach lets a developer toss together the systems he wants and the way he wants them used, it doesn't solve the problem developers face producing robust Java apps with all the trimmings quickly and consistently. Imagine that Java apps were recognized by their simplicity, power, and sexiness rather than their scalable, modular design.

So what's my beef you ask? Simply this: Every line of code, no matter how simple it is to write is still a line of code that has to be thought about, written, tested, and maintained. Java developers today still struggle with features that most users consider basic to a rich application. A great example is layouts, borders, and resizing. Does anyone take for granted that their layout will look great the first time and every time under every situation?

So what kind of advanced features do I think should be included - and this is key - without developer intervention - to leverage them? Below is my list. Some are component enhancements, while others are complete subsystems.

• Default application hierarchy like Studio, SDI Application, MDI Application, all with a well-defined "plug-in" architecture for future extensions.
• Default command architecture to simplify display and control of menu, toolbar, and context menu options and their associated actions.

  It allows these commands (and their associated metadata like images, accelerator keys, etc.) to be read from disk so it's easier for developers to add new commands without recompiling.

• Default menus and layout (file open, close, save, save as; recently opened files; edit undo, redo, cut, copy, paste, paste special, find, find again; dynamic window menu with the current window indicated and an ordered list of the windows opened by the time they were opened; preferences; about...). Configuring these menus should still be possible for different platforms (Mac OS X versus Windows/Linux, multiple icon sets, multiple color depths, multiple button sizes).
• Built-in ability for the user to record macros, play them back, add a toolbar button, attach an accelerator key, etc.
• Component sizes... How many times do I have to wrestle with "appropriate" size issues versus a more complete feature set in my application?
  - Fast, live resizing of the contents of JFrames, JInternal Frames, JToolbars, JSplitPanes, JDialogs, JTable columns/rows, etc.
  - Auto-computed initial sizes on JTable columns and rows based on their data and policies on when to recompute them (when new data added, but not if the user has modified the column or row, etc.). Sorting and filtering support on JTables is scheduled for Mustang.
  - Auto-computed initial JSplitPane sizes based on the left- and right-panels contents. Toss a scrollpane into one of these and the story is even more complicated. These complications should simply not exist for developers.
  - Automatic storing of any JTable dimensions, SplitPane dimensions, window/dialog locations in application specific preferences (registry for windows, .plist for Mac OS X).
• Exact Windows look-and-feel, complete with support for themes! Java's emulation of Windows is consistently incorrect for every version of Java ever released. Do it right the first time!
• User-driven PDF creation from any component.
• Default dialog for toolbar customization via drag-and-drop commands.
• Auto-logging of events to assist developers in deployment debugging.
• Automatic undo-redo where possible, e.g., text components, preference panels, canvases
• Smart bindings layers to help tie multiple UI elements together with data models. For example, if I want to show what's selected in a table in an associated JLabel as well I don't want to write the error-handling code around "nothing is selected" for the JLabel to remain consistent and the application robust. This is tedious and requires more coding to insulate data models adding to application memory and processing bloat.
• Spell checker and text highlighting on JTextAreas, JTextComponents, and JEditorPanes with user-modifiable dictionaries (so the application becomes smarter as the user uses it)
• Automatic "document has been modified" detection and visual feedback. Automatic "do you want to save changes" if the user closes the document window when the modified indicator is true.

• JGoodies Looks includes ClearLook technology to help developers remove redundant borders at design time.
• WinLAF fixes many errors in Sun's default Windows XP look-and-feel implementation.
• The SwingX project includes Open Source advanced functionality widgets like a standard find dialog or an improved JScrollpane.
• SwingLabs, a community whose mission is to "significantly reduce the effort and expertise required to build rich data-centric Java desktop applications."