, and its little brother CodeGuide
, are commercial IDEs that are developed by Omnicore
and respectively sell for $499 and $399. CodeGuide includes Java support, while X-develop also supports C# and Visual Basic on .NET
. What sets them apart as IDEs is that they try to get out of your way as much as possible, while still providing innovative and unique features. (This review was written by Geert Bevin.)
The editor and language support received the most attention and the tool is designed to provide as much screen estate as possible for your code. Making the coding process as pleasant, intuitive and fast as possible is the main focus of the IDE. You will not find many wizards and support for specific toolkits and frameworks is kept to a minimum. Instead, the development went into three areas that set it apart from any of the competing tools that I've tried:
- The application has been optimized for speed and is amazingly fast in its operation as well as in its code analysis
- It sports innovative 'behind-the-scenes' features like project-wide on-the-fly error analysis and back-in-time debugging
- Many of the operations happen inside the editor instead of in additional dialogs.
I often think of it as a lean and mean coding machine without unnecessary bloat.
Project-wide on-the-fly error analysis
The project-wide on-the-fly error analysis is what got me totally hooked on X-develop. It's also one of the most difficult features to explain because other IDEs often support a part of it. However, it needs all the characteristics of what X-develop provides to be truly useful. Basically, it allows a unique style of refactoring that can be called 'free-form'. It's very similar to what you do during test driven development: you first code what you want to achieve and then fix everything until your code works. Instead of relying on tests to provide you with failures, you rely on X-develop's error analysis. It instantly provides you with all the errors that occur throughout your project. This happens without having to save any files, nor having to compile your project. You typically cycle through the list of errors (which can be easily done by using the shortcuts ctrl-up and ctrl-down) and fix the code to make them disappear. This allows you to work for extensive periods of time in 'a state of flux' while constantly being assisted by the real-time understanding that the IDE has of your entire project. I find that this development pattern is extremely satisfying since you see the errors disappear one by one, and it makes me feel a lot braver when making invasive changes since I can instantly asses what their impact is on the entire project (and even on depending projects in the same solution). This feature really makes you appreciate the static typing of the Java language and the additional information that generics provide. They are not annoyances that make your compilations fail anymore, but rather comfortable guides that help you create a more robust product during coding.
Back-in-time debugging is another feature that you will find in no other IDE. It has been around as a research project called 'Omniscient Debugging
' for years, but has never been integrated. While it might be mistaken with the 'pop last frame' functionality in JDB and other debuggers, it's totally different. When you're debugging, X-develop captures the values of all the variables and allows you to step back and step out of methods, line by line, exactly like when you're stepping forward but then in reverse. The debugger also provides you with real-time code coverage information and gives you an easy insight into all the historic values of variables by simply mousing over your them in your source code. The individual statements that have been executed are highlighted and you get a much more detailed view than the line-based information that traditional coverage tools provide. It would be nice though to be able to use this in an unassisted mode and export the coverage information so that it can be inspected without having to run the debugger, X-develop doesn't support this yet.
A good example of the attention to simplicity and power in the editor is how code hyper-linking is integrated. Most other IDEs will only allow you to jump to a relevant location, like the declaration of a member or the definition of a class when you click on a variable or a type. X-develop however also enables this for other meaningful actions. For example, clicking on class definitions, variable declarations, method names and method arguments will instantly list their usages. Also, when you hover over classes and methods with your mouse pointer while the hyperlink modifier is pressed (Command key on MacOSX), you instantly see the Javadocs. I found that X-develop's code hyper-linking provides me with a very intuitive and uniform way to perform code navigation, browsing and inspection.
Testing support is available for JUnit 3
and instead of having a separate window or panel in which the tests are executed, X-develop totally integrates it again with the editor. It detects your testing code and adds additional icons to the classes and methods. The icons are initially gray and you click on them to execute the related tests. X-develop will change the icon to reflect the success status of the tests. As soon as you change your source code, the icons are reverted back to gray and you can see which tests need to be executed again. Sadly, there's no support for other testing frameworks and since I'm moving to TestNG
this is quite frustrating. However, I was told that given enough requests, they might add this for a future release.
Version control integration
Version control integration is very good with default support for CVS
. Support for additional systems can be added through plugins. You get a 'Revisions' panel that allows you to instantly see the changes between the base revision and your current working copy. A drop-down allows you to fetch all the earlier revisions and you can browse through them. Of course versioning support is integrated with the move/rename refactorings and you can easily see which files are modified because the icons in the project tree reflect their status. Checking in your changes happens by clicking the appropriate toolbar button and you get an overview of all the modified files with the possibility to cherry-pick the changes that you want to commit or to discard. While I like the simplicity of the current system, I sometimes miss the tree layout for the files in the check-in window that IntelliJ IDEA
provides. Once in a while I'm checking in several files that have the same name, but that are located elsewhere in the project. X-develop's approach makes it very hard to see where they are located since that information is only available as tooltips.
Multiple language support
, but I constantly have to rely on the goodwill of the developers at Omnicore to help me when they have a moment to spare. I hope that they will publish the sources of a fully-featured language plugin with appropriate documentation soon. I can really see Groovy
support for X-develop become one of its most important features if that ever happens in the future.
Room for improvement
Apart from all these nice features, there are some areas where I would like X-develop to improve. It doesn't support Ant
, which is a pity since its predecessor CodeGuide 7 did. It's also not entirely integrated with MacOSX because the menus are part of the IDE window instead of the global menu bar, and features like full-screen coding and in-line HTML previewing are disabled on this operating system. Support for Javadoc writing is limited to code generation of the comments and syntax highlighting, there is no code-completion nor refactoring integration. Annotations also still seems to lack a bit of love since you can't complete on them yet either. There is no XML validation, while there is XML completion support, but this is only based on DTDs and not on schemas. I sometimes also miss the ability to simultaneously launch to same project from different starting points (both client and server parts, for instance), as X-develop only allows one to be running at any given time.
X-develop is a great IDE for people that want little overhead and consider the focus on the coding process itself important. It lacks native support for specific frameworks like EJB 3.0
, ... but it more than makes up for that with the impressive language features and well thought out, clutter-less user interface. I've been using it for many years and consider it essential to my productivity and the quality of my code.
Geert Bevin is the founder of Uwyn
, a small custom application development shop in Belgium. He is the lead developer of the RIFE framework
and is constantly looking for ways to stretch the boundaries of what is possible with Java.