JetBrains IntelliJ IDEA Blog

Today we’re continuing our series of posts about new ActionScript/Flex refactorings that you can find in the latest Maia EAP, with presentation of this new aid: pull class members up the classes hierarchy.

Let’s have look at this simple example. (more…)

It finally happened! IntelliJ IDEA 9 is now publicly available in its official Beta state.

In this release you will find almost everything we have prepared for IntelliJ IDEA 9:

• Faster environment with background-enabled indexes
• Improved code understanding, including dead code detection and extended folding options
• Cleaner and more productive coding thanks to improved completion, intention actions, and more efficient UI
• Full Java EE 6 support plus GlassFish 3, EJB 3.1, JPA 2.0, Servlet 3.0, JSF 2.0
• Language polyglot arsenal extended with PHP, Scala and La Clojure, and improved Groovy
• New Web frameworks support: Tapestry, GAE, GWT 1.7 and Spring 3.0 with Spring Security
• OSGi Application Development
• Enhanced Maven support
• Android development facilities,
• Better Flex Development, and more.

You can read more about improvements, get the fresh release, try it all for yourself, and submit your feedback via YouTrack, our brand-new issue tracker: http://youtrack.jetbrains.net/issues/IDEA

Also, don’t forget that our Free Upgrade Program is still effective and you can buy IntelliJ IDEA 9 even before it’s out!

Develop with Pleasure!

Working on more than one task at once, you may run in some problems with your changes. Say, you have changed some files in a changelist, then switched to another changelist and made a massive refactoring. Oops! Some files in the first changelist are touched too. Now, committing any of these changelists without the other may lead to troubles.

Maia introduces a way to avoid such scenarios. You can protect files in inactive changelists. When you’re trying to change them (by direct editing or by applying a refactoring) you will see a dialog indicating the files to be changed:

The dialog gives you a number of options to resolve the conflict. You can shelve the changes you made in an inactive changelist and unshelve them later. You can move the previously changed files into the active changelist so that they would be committed together. If all conflicting files belong to a single changelist, you can switch to it, and the new changes will be added there. Finally, you can just ignore the notification and manage the conflict manually.

This strict protection is not enabled by default. You should go to Project Settings -> Version Control -> Changelist Conflicts and select the Show conflict resolving dialog option.

By default, IntelliJ IDEA warns you if you changed files from an inactive changelist. They are highlighted in the Project View, and have a yellow stripe in the editor.

Next Maia’s EAP will bring you new refactoring that helps to be more productive when coding ActionScript or Flex.

Now you can easily move static methods, properties, fields and constants between AS classes and Mxml components: just place caret on a member (or a reference to it) and hit F6 (Move action).

(more…)

Most of applications initially are single threaded, and IntelliJ IDEA was no different; though luckily, now it isn’t — but we had to adapt our code to use multiple threads. In this post I’m going to tell you how.

In our example we see SAXBuilder, which is too expensive to be created every time we need it, so it is stored in a static final field.

Because SAXBuilder is not thread safe, multiple calls to loadDocument from different threads cause a lot of interesting exceptions. This is why we need either to make access to this field synchronized, or to make the field ThreadLocal. In our case, we’re choosing the latter. We encapsulate the field, change its type and initializer, then fix a generated getter. Quite a lot of work, right? Luckily in Maia you can do it all in just one click. Just place caret on a field and press Alt+Enter to smoothly migrate it to ThreadLocal.

Next Maia EAP build includes new action that lets you quickly update a running JavaEE application after you changed its code. To invoke it, either press Ctrl+F10, or click this button on the Run tool window bar:

IntelliJ IDEA will allow you to select what to update in application:

Settings are saved in a current Run Configuration, so you can change them later even if you select Don’t ask again option.

In Maia, you can easily generate Flex Constructor, Getter, Setter, Event Handler, and toString() methods, and some other stuff by just pressing Alt+Insert when cursor is in *.mxml or *.as file. Let’s have a look at some examples.
(more…)

You are welcome to try new JSF 2.0 support features in upcoming Maia EAP:

1. Improved template support:

2. ActionSources and ValueHolders:

3. Targets attribute of composite components:

4. Extended support for EL in composite components implementation; and more.

I believe you’ll like this announcement — IntelliJ IDEA has just gone open-source! Check out the press release as well as the new jetbrains.org community site for the details. We all will soon get a lot of new friends and colleagues in our IntelliJ IDEA community!

Starting with the upcoming version 9.0, IntelliJ IDEA will be offered in two editions: Community Edition and Ultimate Edition. The Community Edition focuses on Java SE technologies, Groovy and Scala development. It’s free of charge and open-sourced under the Apache 2.0 license. The Ultimate edition with full Java EE technology stack remains our standard commercial offering. See the feature comparison matrix for the differences.

Briefly, in the free Community Edition you’ll get all the Java code support — various refactorings and code inspections, coding assistance; debugging, TestNG and JUnit testing; CVS, Subversion and Git support; Ant and Maven build integration; and Groovy and Scala support (through a separate plugin). To learn more and download the Public Preview of IntelliJ IDEA 9 Community Edition, please visit the IntelliJ IDEA Community Edition site.

The IntelliJ platform, the common foundation for all our IDEs (IDEA, RubyMine, WebIDE or MPS), is being open-sourced under the APL 2.0, too.

You’ll find all the relevant information on how to participate and benefit at JetBrains.org. Check out the FAQ if you have additional questions.

Maia supports Servlet 3.0 specification (JSR 315). You can now create a Web application without a web.xml descriptor:

Now, configure your servlets and filters with @WebServlet and @WebFilter annotations:

Everything is recognized by IntelliJ IDEA, as well as Web fragment descriptors and static resources packaged in libraries.

You can also use built-in Glassfish v3.0 integration to deploy your applications. Good luck!