IntelliJ IDEA – subscription renewed

It has been over 16 months now since JetBrains presented their IntelliJ IDEA Personal Licensing Changes. The discussion under the post speaks for itself – there was hardly anybody who really liked it. Before you paid 100% when you bought it the first time (not to mention sales they offered ;-)) and 50% anytime you bought an upgrade. That means, you skipped major version or two (roughly a year each) and then bought the one you liked/needed for an upgrade price of 50%.

Now you buy it the first time for 100% and every next year you pay 50% without worrying anymore. Or you don’t renew your subscription and buy next year for 75% as a returning customer. That is like 50% + 50% of it. Long story short – version skipping is now more expensive, whatever your reasons for skipping are.

New model is not all bad…

One good point is that nobody can now complain that they bought version X and the next day you can get X and upcoming major version X+1 for the same price. What can still happen is that the next major version will be released the day after your subscription ran out. Which is more or less the same problem actually, except that now you can make decision that costs you with more information (before you had to be an oracle).

Again – long story short – if all customers stayed and all subscribed, JetBrains will have more money for their (and our favourite!) IDE. I guess there are ever more features, broader scope of problems, and whatnot. Price difference for every version skipping would be 50€ here in Slovakia. Nothing terrible actually.

JetBrains defence of this step was based also on possibility to release more often, even major versions. With IDEA 13 coming on Dec 3rd, 2013 and IDEA 14 on Nov 5th, 2014, we can’t say they lied, but it’s far from radical. And the question is whether it shows in reality, not just on the splash-screen.

…but I can’t see any big change

So that’s how I feel. I more or less (rather less actually) agreed to continuing partnership with the producer of my favourite IDE. It costs a little bit more, obviously there are no sales you can speculate on, etc. Business. But then, it’s not really anything that would ruin me and it’s worth the productivity you get, especially when you’re used to it. There is still Community Edition, if that’s all you need. And man, if you need just Java, version control and build tool support, it’s just incredible.

I wasn’t sure what to imagine regarding potentially faster release cycle and we’ve got just that – nothing radical, no harm done. Some versions are better, some worse, fresh 14.1 definitely needs some refinement as sometimes it stops checking files and finding usages altogether, but it restarts quickly and I hope it will be fixed soon.

What I miss

If I could channel IDEA developer’s energy into any particular area it would be fixing already existing Youtrack issues in general. I was rather a vigorous reporter – sometimes even successful. (Did you know you can copy the error message from status bar clicking on it with right mouse button? How handy is that when you want to paste it into a bug report!) But there are open issues that are probably obsolete already, some cleanup would be great. “Forgotten” issues are no good.

I remember how long it took to bring reasonable javadoc formatting into IDEA – and it still lacks here and there, although it was postponed one or two major versions. These are the things were I’d like to see more effort. But I understand there are customers waiting for support of their favourite framework as well.

Final words

So that’s it. Not a big change in the price, especially if IDEA is your primary axe, or whatever you like as a metaphor for a sharp tool (of course we can talk about tens of percent, but really…). Perceived quality is good, although varying – like anytime before. No tens of percent change there. 🙂 But anytime I see my colleagues struggling with something in Netbeans (“you can’t run normal main method from test sources?!”) or Eclipse (SVN and Maven working normally already?) I know that IDEA is still worth it. Although some people should learn their IDEs in the first place, whatever they use. Sometimes what I see is like a woodcutter beating the tree with the axe instead of cutting it – when we used that metaphor before. But that’s beyond the scope of this post.

From IntelliJ IDEA to Eclipse (5)

It has been some time since I wrote last installment of this series – and much happened in the meantime. IDEA 10.5 was released (with full support of JDK 7) – and the whole beast is again a bit faster and better – though not without bugs. I’ll probably write a dedicated monologue about things I don’t like in IDEA and why. Then, very recently, Eclipse Indigo was released as well (without Java SE 7 language level support, not that it is make/break feature). One thing I’m very interested in about it is Xtext 2.0, which now seems to be the most driven DSL solution if you want to write text based grammars, models, whatever. (Aside from Xtext, I’m even more interested in MPS by JetBrains, but MPS as of now is a bit rugged if you expect the same fluency as with IDEA.)

This gives me opportunity to recheck some features I collected in previous months and haven’t published yet, though I don’t expect some big improvements in Eclipse core features (not sure why, but when I think about it like this, big blue logo always appears somewhere in my mind – I’m not sure how much IBM is to be blamed, really).

One big thing I don’t like about Eclipse is SVN integration – and I honestly don’t know how can anyone compare and criticize SVN in IDEA. While I don’t know about Synchronization feature in IDEA, truth is I never needed it! IDEA’s workflow is more in line with SVN – especially when it comes to adding files to the repository (before you actually commit them).

Another and probably more important thing is merging. In IDEA I’ve never been afraid of version conflicts – at least not technically. Conflict should be about decision making, but with Eclipse it’s a real nightmare instead. Most Eclipse users don’t know what 3-way diff is, there is no way how I can see my version, after-merge version (the result) and incoming version on one screen. This way you can always compare your code with the resulting code, you can move changes from your code to the result, etc. In Eclipse you can only change your code directly – and hardly see the differences in the end. I often close Eclipse and start Idea on the same project just to resolve conflicts and do commits.

Also files that can be merged perfectly are reported as in-conflict, because two (or more) people were working on them – this is ridiculous! Eclipse is confusing reporting conflicts, it’s also confusing about files added locally to repository. You have little control over it as new file is again and again suggested as an outgoing change (so you are forced to use SVN ignore, information that is stored in repository, to solve Eclipse’s own problems) – instead of you being in control and deciding whether the file is in revision control or not. You can add it, but there is no difference.

Let’s compare some refactorings, completion and shortcuts again!

You can easily do basic refactorings on classes in IDEA – shortcuts are familiar from Norton/TotalCommander (F5 copy, Shift+F5 clone, F6 move, Shift+F6 rename). This works consistently whether you are in editor with cursor on the class name or in the project tree. In Eclipse you have to go to the project tree and do it there. Clone/copy is Ctrl+C and Ctrl+V, not sure if that is refactoring. 🙂 F2 in Eclipse works in project tree, on the class name in the editor you have to use Alt+Shift+R.

Ctrl+Space is the same, but in Eclipse many other features are bound to the same “completion” functionality while in IDEA you have the following: Ctrl+O (override), Ctrl+I (implements), Alt+Insert (toString, setters/getters – but if you want more than just one of them use Alt+S, R in Eclipse rather than Ctrl+Space – or bind it to your key somehow) – and of course also IDEA’s smart completion Ctrl+Shift+Space. Here – while it may seem stupid to have so many keys in IDEA for every different thing I never had problem with that (because you always know what to do). Also the lists are more focused for various functions while in Eclipse it’s all in one list. The rest is probably just the matter of taste. However, smart completion (Ctrl+Shift+Space) from Idea works much better for me than Eclipse’s all-embracing completion. Not to mention Eclipse doesn’t offer enum value completion in method parameters or equals as IDEA naturally does.

Class name completion in non-java files – IDEA is far superior compared to virtually no completion in (for instance) XML files in Eclipse (may vary in Java EE version).

God/Devil is in the details when it comes to how to accept the completion. In Idea you can press Tab or Enter. The difference is when you “overwrite” some existing code, identifier, value, whatever. Tab is natural for us, Idea crowd, and it replaces the previous stuff. I made the test, check this animated GIF – funny that Enter behavior differs with and without smart completion (Ctrl+Space vs. Ctrl+Shift+Space) – but as it’s mostly not what you want, it doesn’t really matter, right? Eclipse behavior is different when finishing enum and the class (animated GIF, in 3rd case it does what it should, ignore the syntax error) – to simplify things one can say that Ctrl+Enter is always what you want (probably). Many users may not know about the difference or haven’t thought about it, but it indeed is a difference. Here “know your IDE” is the most important thing – then you can get what you want quickly in both.

Eclipse’s Ctrl+Space has one additional feature – when you press it repeatedly it cycles through a few filtered views (Template Proposals, SWT Template Proposals, JPA Proposals) – this can be further customized in Preferences/Java/Editor/Content Assist/Advanced.

Finally – here are two IDEA-positive resources – about IDEA knowing what you want (there are more articles in the same month) and one quite an active blog.

Don’t miss other posts on this topic:
Eclipse vs IntelliJ IDEA
From IntelliJ IDEA to Eclipse (2)
Why to synchronize with SVN in Eclipse?
From IntelliJ IDEA to Eclipse (3)
From IntelliJ IDEA to Eclipse (4)

From IntelliJ IDEA to Eclipse (4)

Today I’ll try to focus on key shortcuts more. And also the way you can customize them. In all cases when comparing shortcuts, the first one mentioned is Idea’s, the second is from Eclipse.

While Idea has static Default Keymap Reference in its Help menu, Eclipse has Key Assist (Ctrl+Shift+L) – which is more handy if you don’t know what you’re looking for (name of the features are not always the same between both products). Idea’s Search Action (Ctrl+Shift+A) can compensate for this. Talking about Help menu – you can check some JetBrains TV videos about IDEA to get better idea how to be productive or just for some tips.

There is Idea keymap for Eclipse (plugin), but I wasn’t satisfied with it’s completeness, plus I wasn’t happy with Idea shortcut acting the Eclipse way – and you can’t change that. 🙂 And I also want to be able use Eclipse on colleague’s computers too – so why not to learn it with its shortcuts? Well…

One recommendation actually – duplicate (called copy line in Eclipse) and delete line – you may want to change those. You can mostly live with rest (yes even with Enter vs Tab to confirm completion) but Ctrl+D will soon kill you, especially if you are forced to work in Eclipse more than you can in Idea. I changed it in the Default scheme, because when I wanted to create a new one, I found out it’s not possible in any simple way.

Shortcut Schemes cannot be copied inside of Eclipse. If you’re wondering how to create a new one, wonder no more – you have to do it this way (not that I understand that page too much). I’m also not sure how you can add more binds to one action (not a sequence, but two different combinations). Long way to catch Idea on this one.

OK, and now some “Idea-Eclipse remapping” right?

  • Alt+Enter is Ctrl+1 – called quick fix
  • Ctrl+H is F4 – view type hierarchy
  • Ctrl+B or F4 is F3 (Ctrl+left click works the same, though a bit lazily – you have to wait till Eclipse underlines the stuff – maybe even move the cursor a bit, sometimes I can’t force Eclipse to understand this) – you’ll probably mess F3 with F4 a bit
  • F3, Shift+F3 is Ctrl+K and Ctrl+Shift+K – next/previous search, in Eclipse you can just select stuff and press Ctrl+K, in Idea you have to Ctrl+F it or highlight it with Ctrl+Shift+F7, then F3
  • F2, Shift+F2 is Ctrl+. and Ctrl+, – next/previous error/warning, in both IDEs you can set to focus on errors first instead of mixing warnings in too – in Eclipse go to Preferences, General, Editors, Text Editors, Annotations and there you can include many things into this kind of search
  • Ctrl+Y is Ctrl+D – what a shock for delete a line 🙂
  • Ctrl+D is Ctrl+Alt+Down/Up (but only for whole lines) – now you see why I recommend to switch at least this, Eclipse’s option to copy up or down is quite nice, though minor feature
  • Ctrl+W/Ctrl+Shift+W is Alt+Shift+Up/Down – but the selection jumps differently than in Idea and you will probably not like it at all, in Idea it really starts with word – even inside of strings, but not in Eclipse; funny enough, while word selection is way too eager in Eclipse, Ctrl+Left/Right jumps to camel humps inside words (which in most cases is too slow for me, but YMMV of course, you can switch it in Preferences); you will also probably hate selection expansion on property names, where I want to start with one word again, not the whole property
  • Eclipse has Ctrl+J for incremental search – this is mostly similar to Ctrl+F in Idea, though Idea’s Enter/Escape workflow in the search bar could be better for smoother feel (but maybe nobody feels the same)
  • Ctrl+G is Ctrl+L – go to line
  • Ctrl+Alt+V (as variable) is Alt+Shift+L (as local)
  • Ctrl+Alt+C (constant) is only in menu – Alt-T (T as refactor :-)) and there press A (as … well, constant). This leads us to menu mnemonics. Maybe in Eclipse they are problematic because of some history (that is shorter than Idea, BTW), I don’t know. But however you look at it, refactor is not so important, so intuitive, you have to remember strange shortcuts or add your own (which means changes to the Default key scheme for most normal users)
  • Instead of File Structure View (Ctrl+F12) you have Outline (Ctrl+O) in Eclipse. While in outline you can lookup any member from nested classes (something I suggested for Idea a few days back) you can’t use camel humps lookup (gF for getFilter for instance)
  • Ctrl+N is Ctrl+Shift+T to find class quickly – camel humps work nicely in both
  • Ctrl+Shift+N is Ctrl+Shift+R to find any resource (file)

Find in path (Idea’s Ctrl+Shift+F) is quite a pain really. There is no item for this in context menu on the project tree, you have to select the directory, go to menu Search and select File… I don’t feel like searching for file, I take it more like searching for occurrences, but whatever. After this you have to switch radio button to “Selected resources” (I honestly wouldn’t understand that without help, though directory is kinda resource too, right?) and there you go finally. Many Eclipse users don’t know what that radio button means and they rather go with working sets or just change pattern for files if possible. Very, very non-intuitive.

Find usages (Alt+F7) is here (Ctrl+H) but funny enough my Eclipse mates wondered why I ask if I can see the actual lines with occurrence in the search results. Maybe just to know how the same method was used without going to the source! 🙂 I’m sure we (Idea users) miss some funny features from Eclipse too and we don’t know about them yet. Sometimes I’m in doubt if we all code in Java really – so many mindset differences. Also be aware that Eclipse might open all your search results in a single tab – you can change this in Preferences. Also the behavior of this find is very annoying. In non-java files it mostly offers File Search (text search) tab as default, but in Java it offers Java Search with File Search tab missing altogether. That’s the famous “context-awareness” of Eclipse in its worst moments, if you ask me.

Comment the line (Ctrl+/ in both IDEs) works in Java but not in XML/HTML/CSS [EDIT: reportedly it does for JavaEE version]. (CSS doesn’t work in Idea Community Edition either, but then – CSS syntax is officially not supported there.)

Alt+Shift+Insert for column selection mode is Alt+Shift+A. No problem with selection behavior either.

Open recently closed editors with Ctrl+E? Depends… there is no list of files recently closed (quite a shame if you ask me), but you can quickly reopen the last one using Ctrl+Q (last edit location) or hope that your recently closed tab was one of those recently open and then you can use Alt+F and some number (default last 4 can be changed to 9, I strongly recommend that if you need it in your workflow). This is feature I really miss in Eclipse – and from what I asked, many Eclipse users too.

Finally two more links:

I have a bunch of other things prepared, completion comparison mostly with some animated gifs, so stay tuned!

Don’t miss other posts on this topic:
Eclipse vs IntelliJ IDEA
From IntelliJ IDEA to Eclipse (2)
Why to synchronize with SVN in Eclipse?
From IntelliJ IDEA to Eclipse (3)
From IntelliJ IDEA to Eclipse (5)

From IntelliJ IDEA to Eclipse (2)

This is hardly a guide, but it may still be useful – or just please random Idea users – whatever. 🙂 This is sort of continuation of my previous rant and I expect more to come when I find out how to do some stuff in Eclipse. All my pros about Eclipse still applies (EMF, plugins, all these corporation doing their own plugins for easier development – there are reasons for this), let’s now see what I really miss or what is different.

If you want to try IntelliJ IDEA (just out of curiosity, if you’re Eclipse users) you can read migration article here. IBM offers their thorough guide for migration to Eclipse here. The biggest terminology mismatch is about workspace, projects and modules – it’s explained in both guides. I didn’t open our Java Simon project in Eclipse yet – maybe then I’d understand it better. Right now I have one workspace with more projects in the “project” sense of the word. In Idea I open one project in one window – as always. So for me project is project. But then I didn’t try to force Eclipse to compile part of the project with one JDK and other with different – maybe then I’d need to break modules to Eclipse projects. However, while it is terminology mess obviously, it’s not the most important thing.

After spending some time with Eclipse you might wanna change editor colours and syntax highlighting. Shame is that there is no obvious way how to save the colour scheme but you should be OK with changing just a few things so it’s less blue/grey only. Quick Diff colours are the first candidates, then maybe comments and Java syntax. Then you may feel more like home and also I just simply see better. Exploration of the Preferences is one of those recommended things to learn about what you can tweak. IF you find it in the first place though – I google a lot regarding how to set this and that in Eclipse. This surely applies for the migration to Idea too.

Formatter in Eclipse may be better configurable (I don’t know, but it seems so from the flood of options) but the overall results are often worse (because of all those options). Ultimately you’ll get what you want though – but settings for XML doesn’t seem to be part of the formatter after all (correct me if I’m wrong). In Idea you have Code Style, you can use global settings or settings for a project and all file types are under Code Style (no formatter bits scattered in the settings tree). While there seems to be no export from GUI in Idea (like in Eclipse) it’s easy to locate code style profile XML files on disk (Idea’s config/codestyles directory somewhere in your homedir) and share them.

There are many concept differences between both IDEs but I don’t care about them that much – as I can hardly do something about them. I can compare editors though. There are some conceptual differences between editors itself too, but in the end it’s about what this one completes and that one doesn’t, etc. As I work more and more with Eclipse, I’m surprised it doesn’t have some (basic?) things. Of course you can always tell him “do this and this”, but Idea often just knows. Now this is not the same as “my Ctrl+Space does it all while you have tons of shortcuts for it”. Yes, sometimes you have to tell Idea “do this” with proper shortcut. But I don’t have to suggest enum type name to complete for instance!

Eclipse doesn’t skip over closing braces/parenthesis if you move the cursor there, but skips nicely right after they are autoinserted. This might be better than Idea’s way actually. I like that Idea gets me out of parentheses, but in many cases I could figure this myself – and often I have real problem to insert new end parenthesis before you open it (so what! I do it from back to start sometimes! :-)). Little note to parentheses highlighting – Idea shows the pair when you’re out, Eclipse when you’re in. Whatever. Idea is better visible – as nearly always.

Recently I discovered Idea’s “Complete Statement” feature (Ctrl+Shift+Enter) – see video here. Not only I found it’s something I missed for years (but just don’t check every missing feature, right?) but it’s also the best way how to emulate “o” command from vi editor (add next line and go to insert mode). These features are missing in Eclipse – at least out of the box.

I mentioned automatic symbol highlighting (or none at all) in my first post – if Eclipse has highlighing on demand it’s not easy to find because none of my colleagues doesn’t know about it. I checked some introduction video for IDEA Community Edition (must see – because every time I learn something new – or forgotten) and I was shocked by automatic highlighting there. I had to open Idea and check how they screwed it, broke it or whatever. Feature is described here. But Idea didn’t let me down. Even with automatic highlighting on you can still stick it with Ctrl+Shift+F7. So you can have best of both worlds – of course on Idea. (At least when we’re talking about highlighting.)

I’ll focus more on keyboard shortcuts in the next episode – how they relate in Idea and Eclipse, what you can and can not expect, etc. Today it’s time to slowly wrap up the article – but we can’t not to mention perspectives, right? 😉

First go about debugging (more to come later!). When you have a warning on a line (light bulb in the gutter), try toggle the breakpoint on that line. Can you see it? I can’t. Luckily I have good colleagues. “You have to go to Debug perspective…” “Ah, different perspective! Of course…” “…and then switch that tab there to Breakpoints and… see? Now you don’t have it on that line. And now you have it there. Easy.” (But yeah, even they were chuckling a bit.)

Eclipse isn’t bad at all of course, I still recall my colleague’s (kinda ironic): “What do you want? It’s for free!” But then, even “smaller” Idea is – and while it lacks a lot of Java EE support, it’s still “Develop with pleasure”. As a final note – when you find yourself stuck with maximized code window (Ctrl+M in Eclipse – and I use it a lot) fighting the Project Explorer that is not docked properly and you don’t know why… just switch from Team Synchronizing to Java perspective. Maybe you’ll get used to it sooner than me.

You can actually say: If something is wrong, it’s probably your (Eclipse) perspective. 🙂

Don’t miss other posts on this topic:
Eclipse vs IntelliJ IDEA
Why to synchronize with SVN in Eclipse?
From IntelliJ IDEA to Eclipse (3)
From IntelliJ IDEA to Eclipse (4)
From IntelliJ IDEA to Eclipse (5)

Eclipse vs IntelliJ IDEA

It’s official. This is just a rant. It always is, because even the most serious comparisons of these tools are always clear win for the one used originally and total dismiss of the newly adopted one. I’m Idea user – for almost 9 years or so. I remember a few let downs with Idea – the biggest one for me is clearly introduction of Modules and lack of some good Project view as a result. And also the need to reorganize your project because to get support for web you had to move sources out of the standalone java part of the application (for instance). And application.xml must go to another (module) directory too. And if you add module “All” with the real project root, you can’t see anything in module subdirectories. This was more or less fixed somehow after Idea 4, but still… However – most IDEs somehow forces you to do something with your project anyway. And if you start follow patterns like Maven (not a bad idea either) than you should be safe.

Another issue I have with Idea (and I reported it – but it’s probably not good idea for creators) is a new search bar (since 7? 8? not sure now). Thing is, Ctrl+F is ok, but Enter should work differently. When you write your search string, Enter works like F3 and arrow down – but focus stays in the bar. Not only too many keys do the same thing – but you’re also not in the code after Enter. You have to Enter and Escape to get there. Hell, you can even Ctrl+F, write the search string and Escape – that’s does what I want (and expect from Enter). However, highlighting is gone. So what you really need to do is Ctrl+F, write and click to the code – you have to touch the mouse! 🙂 Not to mention that if you press Ctrl+F, write, Enter, Enter… you go through your searches and then you need to do another search, Ctrl+F pulls down previous searches instead of giving you the fastest way how to start another search. Firefox selects all and you can search something else – great! Idea’s solution is just so silly that probably previous dialog using way worked better for me. But maybe I’m the only one here.

But that’s it – otherwise I just love Idea. When I’m in code I can just feel it.

And then Eclipse. I’ve read someone complaining about how contextual (hence smart) Eclipse is and how difficult Idea shortcuts are. I can just say, that I’m going crazy when Eclipse offers different search depending on the file I’m in (is there EASY way how to full-text search the whole project – Ctrl+Shift+F in Idea?). Idea’s three different completions might be a bit problematic at the start, but much faster when you know what they do. And then – comparing Ctrl+N with Ctrl+Shift+T… well, I think it’s clear what is easier. I can always get faster to editor in Idea (and that’s actually what I do a lot) while in Eclipse it’s a real finger exercise.

Or Mark Occurrences – they are not sticky! I can’t choose and highlight this… and that… and go somewhere else. It just blinks like disco music all over the screen – or you can turn it off. There are so many features that were copied in much better fashion from Idea do Eclipse, but this one is just ridiculous. Sure I have to click Ctrl+Shift+F7 in Idea – but then – I can highlight any text, not just a type. And more of them. And obviously – I don’t need this Christmas lights turned on all the time (not to mention that the default colour is hardly highlighting – I was rather confused whether I selected something or what).

I also found that in many cases where Idea happily completes, Eclipse wants me to fix some braces first (took me some time to realize that) before he is capable to do so. And Idea goes to the next line after (un)commenting one, Eclipse not (by default at least).

Or SVN support – how can anyone compare SVN support in Idea and Eclipse? In Idea it just works out of the box (even in community edition). And Quick diff (that’s how it’s called in Eclipse, never needed to know the name in Idea) – it’s just far superior (and working right away) in Idea. Also colours are much more distinct (by default!), items in the outline on the right are easier to recognize, etc. In Eclipse all these things are rather greyish, often coloured with pattern instead of solid colour and always outlined instead of being nice thin (yet thick enough) line like in Idea. Deleted stuff in Idea’s diff shows as a triangle, not line nearly impossible to hit with a cursor.

And then commit! Lately I had to do my first “synchronization” and I was shocked how inferior the commit is in terms of my control over the process. Files that are not yet added can’t be told from those that are added to SVN – you have to right click them and check if Add option is available. Not to mention I don’t want to add them by default at all! It was also not that easy to find option to ignore white-spaces in diff view, not to mention I like three options offered by Idea more.

Rename refactoring in Idea selects the whole identifier and I can just write a new one – in Eclipse you have this feature if you switch to rename dialog, not in editor, you have to remember to select the stuff. On the other hand, sometimes it indeed is useful to have cursor on a specific place of the identifier. In Idea I actually miss easy way how to deselect the word without moving the caret – so let’s call it a draw here. Ad selecting – with Idea I can select a word in a string or part of dot separated property name – and then go on to the whole string, line, and on. In Eclipse I can’t select word from its middle in an easy way.

Eclipse is just like this. I don’t see things there, I need more perspectives to use it (never needed that in Idea), Console contains too many… well actually consoles – and there is yet another mechanism to switch between them (funny drop-down button instead of more tabs for instance). I just like Changes window and Run window separate! And that’s probably the point. We all love different things. And while both Idea and Eclipse are customizable to some extent, they can’t satisfy all developers. Even when both do the job (unless you want to sticky highlight thingies ;-)).

What I can’t deny to Eclipse – their plugin ecosystem is just absolutely awesome. And all these things like EMF or Xtext… many companies use their own plugins built on Eclipse. For a reason. Whether it’s because Idea wasn’t for free (as is Community Edition now) or not – it’s hard to say. But that probably helped a lot.

I’m now stuck with Eclipse and will probably learn to overcome some of the problems. But I can smell it right now, it will hardly grow on me as Idea did.

Don’t miss other posts on this topic:
From IntelliJ IDEA to Eclipse (2)
Why to synchronize with SVN in Eclipse?
From IntelliJ IDEA to Eclipse (3)
From IntelliJ IDEA to Eclipse (4)
From IntelliJ IDEA to Eclipse (5)