We’re glad to announce the availability of IntelliJ IDEA version 7.0.3
This new release brings multiple new features, improvements and bug-fixes, including

• Improved performance and usability
• Improved Flex support
• Totally new, reworked debugger UI
• Multiple Maven integration improvements
• Numerous bug-fixes, cosmetics and exception fixes

In ancient times, Genova was a place where mighty armies frequently crossed their swords in fierce conflicts to determine who would rule the city and the surrounding area. On 10th March 2008 at the Genova university the mighty armies of Sun, Oracle and JetBrains met in a friendly battle - a battle of Java IDEs. Thanks to careful organization from the JUG Genova people the event went very smoothly and more that 120 attendees checked out all three IDEs (NetBeans, JDeveloper and IntelliJ IDEA) side by side. Events like this one certainly help developers who care about the way they create software, to make qualified decisions about choosing the best IDEs for their projects. I really enjoyed presenting here, the audience was great, as was the whole event . I’d like to thank the organizers for preparing the event and the audience for being so responsive and enthusiastic. As always, in its long history, it’s Genova who won the battle. I’m glad I could participate.

This post is by Vaclav Pech - I’m just the messenger, since he’s now at the IDE Shootout in Rome

If you’re interested, Fabrizio Giudici posted a few good pics of the Genova event here.

Just a quick blog today,

We’ve just received a message from the folks over at JavaOne allowing us to give a $100 discount to anyone who would like to visit the conference this year… We’re quite excited to be attending this year, and look forward to see you all there!

Would anyone be interested in a meetup outside of the conference with the JetBrains development teams?

For the $100 conference discount, go to: http://java.sun.com/javaone/sf/index.jsp
And enter the code: ECXH66

This link and code can be passed around as much as you’d like, so feel free to share it with your community

All the best,

Dave Booth

Raise your hats to Ted for his recent IntelliJ IDEA Tips series! Ted sheds light on the wallflower features of IntelliJ IDEA, as well as new ways of using well-known features and the most beneficial plug-ins.

• IntelliJ IDEA Tip: Change Background Color for Read-Only Files
• IntelliJ IDEA Plugin of the Week: Describe Key
• IntelliJ IDEA Tip: Goto Class Coolness
• IntelliJ IDEA Tip: Open All Files in a Changelist
• IntelliJ IDEA Tip: Quick Lists

Stay tuned for new enlightening blogposts from Ted!

Another valuable contribution comes from Cedric Champeau, who has shown how structural search in IntelliJ IDEA can help you find try/catch performance bottlenecks.

If you are looking for ways to speed up IntelliJ IDEA on your computer, some of these 10 Tips to Increase IntelliJ IDEA Performance should prove helpful.

And, last but not least – 9 more reasons to love your IDEA of choice – thanks to Messi.

It is sometimes the case, you can create plugins you want to preserve for internal use only. With
IntelliJ IDEA you can maintain your own enterprise repository to share your plugins with team members solely.

To create a repository, we need a Web server, where our plugins will reside, and a descriptor of available plugins (updatePlugins.xml), so IntelliJ IDEA could find them. This file can be located at the same Web server, for instance. By the time we decide to use plugins from the enterprise repository, we’ll only need to specify where this descriptor resides. To do so, open the Settings dialog (Ctrl + Alt + S) and go to Updates. In the Plugin Hosts section click Add and specify path to the updatePlugins.xml.

When creating updatePlugins.xml file for your repository, follow this DTD:
http://plugins.intellij.net/dtd/idea/updatePlugins1.0.dtd, so IntelliJ IDEA would be able to recognize available plugins.
Each plugin entry in this file should contain plugin identifier and URL of the plugin repository. Additionally, we can specify here plugin version. Though, if it is not pointed out in updatePlugins.xml, IntelliJ IDEA will fish it out from the plugin *.jar.

For example, we upload MyPlugin to the Web server where the repository resides. Then we open the updatePlugins.xml and add new plugin entry, like this one:

<plugins>
<plugin id="MyPlugin" url="http://unit:8080/myPlugin.jar" version="1.0"/>
</plugins>

And that’s all we need to do to add the plugin to our repository.

If the whole team uses customized IntelliJ IDEA, you can add the whole list of plugin hosts to the bin/idea.properties under IntelliJ IDEA installation folder. Just open this file and add the following line: -D idea.plugin.hosts=[URL1],[URL2],…[URLn] where [URL1],[URL2],…[URLn] is a comma-delimited list of the URLs to the enterprise repositories.

Once hosts are specified, plugins are automatically updated according to the schedule defined in the Check for updates field of the Updates dialog. Yet, you can update them manually any time you need it. Just open the Updates dialog and click Check now. Update Info dialog box opens showing the list of plugins from all the available enterprise repositories. You can unselect those of them you don’t want to update for some reason.
Don’t forget that updates will take effect after IntelliJ IDEA restart.

Since version 7.0 IntelliJ IDEA provides the complete support for creating Web Service applications, providing the full range of productivity-boosting features:

• Smart code completion
• Syntax and error highlighting
• Code analysis, inspections, quick-fixes and refactoring
• Automatic code generation, including WSDL/WADL from Java and vice versa
• Dedicated run configurations for debugging and automated deployment
• and more

If you had worked with IntelliJ IDEA for a while, you’re most likely aware of @Nullable, @NotNull annotations which allow you to formally specify method contracts and validate whether these contracts are met, and @NonNls annotation which is helpful when you want to exclude strings from the internationalization process.

However, there’re several cases when direct annotating code is not advisable: for example, project is shared between team members that use different IDEs, or you work with library classes. That does not mean you can’t make use of these annotations, though – with IntelliJ IDEA you can store annotations outside of the source code.

Let’s have a look at how it works. First, we need to open the Settings dialog (Ctrl + Alt + S) and go to Code Style (F), then check the option Use external annotations at the Code Generation tab. Now, add the annotations.jar library to either module or project. You can find it under INTELLIJ_IDEA_HOME/lib folder.


After that, open your current inspection profile and make sure Constant conditions& exceptions inspection is enabled and Suggest @Nullable annotation for methods that may possibly return null option is selected.

At this moment we can enjoy externally annotating methods, fields, parameters, etc. For example, we work on a module that contains a method that might return null.



Let’s add annotation – just click the light bulb. IntelliJ IDEA asks whether we want to add annotation in code directly, or store it externally. Select the second option and specify the external annotation root for the current module.

Note: You only select the location for external annotations once, so each next external annotation within this module will be stored in the same folder. Alternatively, you can specify annotations root at any time: open Project Settings dialog and go to the Modules page, then select the needed module and open its Paths tab. There you can find External annotations area, where you can manage external annotations attached to the module.

Now, this method is annotated without placing anything to the source code directly. You can press Ctrl + Q to view the attached annotation.



With external annotations you can even annotate methods within JDK classes.



Just like when you add external annotation on the module level, you can specify the storage location right when you add the annotation, or using Project Settings dialog. In the latter case, open Project Settings dialog, go to JDKs and specify the path in the Annotations tab.

We’ve got great news for those of you who were waiting for an easier way to create rich Internet applications with Adobe Flex using IntelliJ IDEA.

Many advanced features are supported by the upcoming version 7.0.3 that is already available throught the Early Access Program (EAP):

• Smart code completion for MXML and AS files, with cross-resolution of code symbols between them, even inside of mx:Script blocks and attribute values
• Automatic code formatting, highlighting and styling
• On-the-fly code validation with instant quick-fixes
• Code insections to hunt perfomance bottlenecks, bad code practicies and other problems
• Rich set refactorings

We’ve composed a comprehensive tutorial, for you to quickly start over.

To get your hands on IntelliJ IDEA Flex experience, you only need:

• IntelliJ IDEA Flex tutorial in PDF format
• Latest IntelliJ IDEA EAP Build
• And, optionally, sample project (it’s what you’ll anyways get after completing the tutorial)

Yesterday the results of JetBrains’ annual contest for the best plug-in to IntelliJ IDEA were announced. 7 plug-ins were selected by the jury composed of IntelliJ IDEA development team members. Their respective authors will take away great cash and software prizes. The names of the winners are listed on the dedicated Plug-ins Site. There you can even see a small photo-report from the conclusive meeting of the jury

We would like to congratulate the winners, express our appreciation to the co-sponsors for the generous prizes, and encourage new participants to take part in the next year’s contest.

Great challenge and great benefits!

Suppose you have accidentally deleted a file from your project, and want to have it back. Sure, you can restore it using the file system, but IntelliJ IDEA suggests a better way to do it, without leaving the IDE.
This is where IntelliJ IDEA’s local history on the project or folder level comes to help, preserving all modifications that affect the nested files, including the changes to the contents and to the file tree in general. Each change is marked with its time stamp, revision, and action description. Unlike version control that keeps track of the committed revisions only, the local history preserves all local changes you make as you edit, compile or test, during few days (it is up to you to define how long you want this history to be). This “personal version control” will help us restore the deleted file.
In the example below, a file Lost.txt has been deleted from the FontChooser project. Let’s try to restore it. Go to the Project tool window and right-click the project node or just a folder, where the file used to exist:

On the context menu, choose Local History, and click Show History on the submenu:

The local history view for a project or folder shows you everything that you have done during the last few days. In the Action column of the lower part of the dialog box, select the action you want to roll back. In our case, this is the “Deleting” action. So doing, the upper part of the dialog box shows the tree view of changed files.
If you want to restore the deleted file only, regardless of the other changes that have been done since then, you can select the file Lost.txt in the tree view and click the Revert button on the upper toolbar. The file will be restored silently.

A different situation occurs, if you want to restore the deleted file and the whole project or folder state as of a certain revision. In this case, place the cursor on the revision prior to the “Deleting” action, or on the action itself, and click the Revert button on the lower toolbar. If the other files have been changed since the “Deleting” action, you will be prompted that the other changes will be reverted too. Look again at the Project view – our file is here: