Something that people already mentioned, but still. There is great Visual Studio for Windows and for cross-platform development there is Qt Creator. The latter also comes with a full-fledged development framework that allows you do GUI, threading, networking, databases: it is effectively what a standard library should be. It also really fast and has a slick interface allowing to do code navigation really fast. I don't have to tell you what I use for C++ development. So it will be very hard for them to compete with existing options.
I find QT Creator underwhelming, especially compared to intellij. You have to stick to a single window, the interface to gdb causes me to pull my hair out most of the time under OSX, the refactoring support is almost absent, the keyboard shortcuts are a pain to manage (to make it emacsy, at least a bit).
I currently use eclipse for my embedded C++ project, and QT creator for QT apps (QT is wonderful!), but intellij for pretty much everything else. Looking forward to this.
There's also KDevelop, cross-platform C/C++ IDE. I've only used it for C, and only on Linux but it was a great experience. It's supposed to support other languages as well, and I've tried python, but had no luck with it.
Except for the fact that Qt is not as cross-platform as the standard C++ library. Qt also uses non-C++ features such as signals/slots which require usage of their own Meta Object Compiler.
Qt's moc is a preprocessor/code-generator which compiles to standard C++.
Do you also tell people that they shouldn't use flex/lex/bison/yacc/antlr/etc.? Why are those code generators/DSLs acceptable but the moc is not? It's not as if the Qt authors added it because they don't understand C++, they added it because it solves a vexing problem in C++ GUI design.
I would have agreed with you if Qt used something like the #pragma directive. Alas, they decided to inject keywords inside of the standard language which breaks every C++ compiler.
I'm guessing it's aimed more at the embedded/system programming crowd. Visual Studio is a PITA when you aren't targetting Win32. Right now we use eclipse which has pretty substandard C++ support.
I love IntelliJ for java development but I never got why I might need a big IDE for c/C++. I just use Vim for that. I mean it does omnicompletion and code correction with clang, has snippets, support for switching between header and source code files.
It works pretty well for me. Even sublime text would do the job since it has all of those features too.
What do IDEs have over Vim in terms of features that I may be missing out on? For java, I would definitely use IntelliJ because of the debugging features alone but I think it's overkill for something like C/C++/Python
What about smart refactoring? Being able to rename just about anything (methods, classes, variables, etc...) and knowing that your IDE will do all the right stuff.
What about instantly knowing who calls that method or uses that class or that variable, with much more flexibility than just grepping through the code?
Why does it have to be lumped into IDE? Both could be written as standalone utilities that your favorite editor can call.
I think IDEs hurt innovation in development tools more than almost anything else. They are like crack for your workflow - easy to get started with, but once you're on them you're stuck. Plugging in better tools into existing IDE is a big PIA if possible at all, and rewriting the whole IDE is a huge undertaking for any company who wants to make your life better.
The core of JetBrains tech is a well built, performant, pluggable foundation that makes them incredibly responsive when it comes to new tools, languages, features, fixes, etc
I rarely refactor across entire projects, but I'm fairly certain vim has plugins that can do that.
As for finding what calling methods there are, as other have stated, you can use ctags, or go full throttle with Cscope - http://cscope.sourceforge.net/ it will do textual searches along with displaying all callers for a method across all the files you tell it to search (in setup).
With the vim gui and a cscope backend, I'm pretty sure vim is just as much an IDE as any of the other editors. It just happens to work fine in a terminal, too.
"With the vim gui and a cscope backend, I'm pretty sure vim is just as much an IDE as any of the other editors."
<guy never having run more than a mile> 'Yeah I'm pretty sure that these 7.95$ Walmart sneakers are just fine for running the NY marathon, why would I need those Nike's or Asics?'
You're assuming I don't ever use one of the other IDE's. I've used Eclipse on occasion (currently using it somewhat on Android development as a debugger) and I have to open up Visual Studio at work on occasion.
Neither is better for me than vim and unix tools, even if I have to run under cygwin. It's cool that jetbrains is making something new, I just wanted to point out there are few (if any)features vim and/or emacs do not have.
I'm not really sure what you mean but vim does refactoring just fine with ack/vimgrep with bufdo (applies any vim commands to the current list of buffers)
It also has ctags support so you can navigate your code, go to a method/variable/class name and instantly find out where it was defined and such.
A full-featured refactoring tool should be smart enough to only rename functions/methods that belong to the same class for example. This is generally possible only when the tool "understands" the language. A search and replaceable can't do this correctly.
This. Vim is great for simple scripts and small projects, but once a project grows beyond a certain size I really prefer an environment with more robust refactoring like Intellij.
It seems to me that IDEs such as Eclipse, VS etc. are much better suited to large scale development than vim.
For example, recently I worked on the HotSpot JVM, beginning by analysing the codebase. I started with vim and got cscope and related tools working, but they didn't seem to always work, and were much less useful than those I'd used in IDEs. In the end I switched to Eclipse, and was able to carry out the analysis very easily.
One of the Oracle JVM engineers told a friend - they generally use emacs for development, but when someone is trying to get their head around the code, they use an IDE.
So it seems to me that this guy and others "internalize" the way they codebase works, and then subsequently switch back to editors.
Thing is, this all seems rather baffling to me. Surely IDEs are designed to remove a lot of the burden of memorizing syntax, APIs, and the way the codebase works. Intuitively, this sounds like a step forward.
But - lots of experienced and smart programmers still use vim and emacs rather than VS, Eclipse, Qt creator, IntelliJ. Those people know a lot more than me about coding. So there must be a rationale for sticking to text editors.
Can anyone enlighten me please? Should I invest more time in emacs/vim? If yes, why?
I've found that the biggest problem with IDEs is that they let you get away with a sloppy architecture/modularization and having tightly coupled code.
Why bother thinking about a clean separation of concerns, isolated modules and good interfaces? The IDE will let me change any method or class name at any time, so I can just use everything everywhere as much as I please. Why bother making minimal well documented interfaces that make sense? I can just make sloppy, huge interfaces with 100s of little functions and use my refactoring and completion tools to find out which ones to call.
I call systems built this way "boogeymen". They are really scary to work on. You're changing some method in some class and you have no idea what will be affected by that method (until you run the system or the tests). You have no idea if that public method is part of an interface to the larger module, or its just public because another class from the same module is using it. Come to think of it, there is no "real" modularity and isolation.
I strongly believe that "necessarily complex system" meme is a myth and complex systems are the result of sloppy work on architecture, modularization and tiny interfaces that make sense. IDEs help perpetuate this sloppiness by helping mitigate the consequences, not by solving the underlying problem
On the other hand, IDEs, when used correctly do help with getting better architecture. Refactoring tools and dependency analysis are there for some reason. How often do you get the right architecture the first time? Seriously, I almost always get it wrong and I have to refactor. If there were no easy way to do it, it would just stay like that and technical debt would accumulate up to the point where you'd have sloppy, huge interfaces with 100s of little functions (little functions are in fact OK; huge functions are the real pain).
one aspect is speed. every ide i've tried is orders of magnitude slower at startup, and switching from 1 big codebase to another quickly is something I can't do without.
"For java, I would definitely use IntelliJ because of the debugging features alone but I think it's overkill for something like C/C++/Python"
Not sure if you're trolling, but how much C++ do you write? If you have to ask what the difference is between VS and Vim, and are suggesting that writing C++ is more like Python than Java, you haven't used C++ and/or VS much.
(context: I have 10+ years of experience with VS and 15+ with Vim, which is my everyday editor for everything except non-trivial C++ code)
Have you ever used the debugger in Visual Studio? That is THE thing I miss in vim and the likes (yes there's vimgdb ect but that's peanuts in comparision). Combined with the features mentioned by others, that is why poeple want a set of tools that integrate with each other, hence the name, instead of a bunch of standalone tools that also work but don't know enough about each other to seamlessly play together.
because other people imply that using vim/emacs with plugin/tools to fill in the gaps is equivelent to using a fullblown IDE, but one that runs faster.
To me, it seems like a lot of these light-weight Non-IDE text editors, are basically IDEs anyway. You just said sublime and Vim have most of the features of an IDE.
I personally use RubyMine, and while I don't use the debugging a whole lot, it comes in handy with some really confusing issues. Other than that, it is just a fancy text editor that I have become used to for Ruby work.
For ruby stuff, Vim really shines, mainly because of tpope's contribution and his excellent ruby plugins. Along with his Fugitive (https://github.com/tpope/vim-fugitive) plugin, it's actually fun to use Vim for ruby. It's just fantastic. Check out his vim-rails and vim-ruby plugins: https://github.com/tpope
100% this is my opinion, I learnt C++ using VS and eclipse; I can't remember when or why but I fairly quickly picked up Vim + compiler and it just felt better suited to native development.
Further more the skills feel more real, I can apply my usage of vim and how the tool chain works to other languages.
I love IntelliJ, I sound like I work for them. I don't.... If you do Python web development, specifically Django you can debug your application with that. Never tried straight Python, but probably that too.
I wish all the best to them. Eclipse with CDT is OK but often just blows up in my face. The last time I tried to use it I ended up switching to Emacs completely :/. But I love IntelliJ for Java, Ruby, and Python, would love to see them build a nice C++ IDE along those lines.
Not having used AppCode I don't know how good the support is for C++ already. I wonder if they will be using clang/llvm for static analysis? Though I don't know much about that area, I've noticed that all C++ IDEs that I've tried (including MSVC++) are much poorer than Java IDEs in that aspect.
"I wonder if they will be using clang/llvm for static analysis?"
From the page:
"The IDE will be integrated with Clang Analyzer, so that more than 2000 code inspections and error diagnostics results from Clang compiler would be shown right in the editor. Of course, you also would be able to review them in a bulk mode"
A lot. It has been a year since I last used Qt, but given the frequency with which I hit bumps in their integration with OSX, I'm quite sure that they haven't all been fixed by now.
Keyboard shortcuts, drawers, and focus passing would randomly fail to work, since Qt was welded into the Cocoa event system and sometimes missed rather important edge cases. For instance, pressing the Esc key was programatically indistinguishable from clicking the 'Ok' button in custom drawers. More often, power-user shortcuts were overridden, didn't respect configuration changes, or entirely absent. Some views (table view IIRC) didn't even try to exactly mimic the native look and feel. Menus worked in fundamentally different ways on different platforms: if somebody designed an app to work on Windows, which does menus on a per-window basis rather than globally, menus would randomly appear/disappear on OSX. Oviously this wouldn't be a problem if all your users knew about it, but they won't. Integration with launch services was absent or crippled. Docking windows required tons of theming if you didn't want them to look like crap. Sometimes constraints or conventions imposed by cocoa were overridden, leading to subtle differences in the positioning of button text and so on. I spent 2 person-days hunting down the cause of a 2-pixel border between the edge of one view and the window backing; the hunt ended in failure when I realized that I would have to monkeypatch or completely replace Qt's layout system in order to get the view snug against the edge. Sometimes Qt's abstraction layer led to unacceptable performance tradeoffs that would be easy to solve on any given platform but were simply not addressed in the Qt API. In general, the UI design tools didn't enforce platform-specific conventions and were miles behind XCode in terms of ease-of-use.
I had a few problems that weren't specific to integration, but they were just as frustrating. The documentation, while great for an open source project, was still far behind the status quo for native libraries. I found their documentation on coordinate systems very difficult to understand (in comparison with the Cocoa documentation) and sometimes it was just plain wrong, e.g. about mouse event propagation within graphics views (and you would think that would be a fairly heavily trafficked page, no?).
If you want your Qt app to seem native, you had better be prepared to dig through Qt itself and patch its deficiencies. This often means being intimately familiar with the native libraries, since the bugs reside at edge-cases the Qt devs weren't thinking about when they wrote the code.
Honestly, if I had to do it all over again, I think I would have just insisted coding the front end twice using native libraries and development libraries each time.
...a cross-platform UI toolkit will never be usable by just recompiling and having you GUI work just fine on another platform. Especially MacOS, which was always somewhat special about everything! It's good to learn just one GUI toolkit, but you'll need to split your codebase and even if you have the same base UI for different platforms, accept that lots of windows and dialogs and menus will have one MacOS version and one Windows version (usually you can skip the Linux one because Windows-style apps play well with Linux except for when abominations like Unity fuck things up...).
I never expected the UI to translate perfectly and effortlessly from one platform to another, since (as you mention) that's clearly impossible due to divergent design decisions in the platforms themselves.
However, it is not inconceivable that one could maintain a unified codebase and use a few platform-specific hacks to ensure that your app "philosophically matched" each OS. Quite possibly, one could still save net effort by implementing these patches vs maintaining a split codebase. If this were the case, I would be happy with Qt and I would sing its praise.
My difficulty with Qt stemmed mostly from the bugs. It simply lacked the polish of Cocoa and .NET in a way which noticeably and negatively impacted productivity. "Platforms are different" is no excuse for incorrect documentation, layout engines that are 1-2 pixels off at the edges, broken/incomplete keybindings, missing integration with launch services, and so on. I have the utmost respect for the Qt team -- I wouldn't have guessed that anyone could come so close to unifying the major UI kits -- but Qt still fell short of where it needed to be if it wanted to compete with the native toolkits.
I was mainly referring to objectively missing features rather than subjective design differences, though Qt has made a lot of progress over the past few years in terms of feature support. However, a quick scan of the applications on my Mac only turned up one Qt application that I hadn't already recognized as non-native, and that app was the Kindle application (which had an obviously non-native text rendering system, but excusably so).
Qt applications have at least made it to the point where the scroll bars are correct and the menus usually include the standard structure and emacs keybindings work in text boxes, but I've yet to find a Qt application that has a properly integrated help system, and almost every one quits the application when the last window is closed, native toolbars are rare, combo boxes seem to be used frequently where pop-up buttons would be more appropriate, and nobody seems to add any options to the dock icon's context menu. I've seen enough to know that Qt can be a very close approximation if the effort is put forth to make the app act native (probably better than any other cross-platform toolkit), but it's far from free, requires a ton of platform-specific code, and apps that try hard are few and far between.
This is the reason I don't use jetbrains products, I use linux and the Java font rendering is absolutely awful, I've tried all the fixes and I can't find any of them pleasing enough to use.
@martinced: You've been hellbanned for the past 5 days. Which is a shame - your comments are long and informative.
> I'm using IntelliJ IDEA on Linux since version 4 or so (we're now at version 12).
> And I agree with you but...
> The trick is to use a pixel perfect font with no anti-aliasing at all and to set the correct vertical spacing between lines and then IntelliJ is just going to look fine (for a Java app).*
> So first you go download a real font (a font made especially for programming, like the Proggy fonts which you can get at proggyfonts) (I take the .ttf version)
> You relaunch IntelliJ and then go to:
> Settings / IDE Settings / Appearance / Editor / Colors & Fonts / Font and then you set your pixel perfect font, say :
> ProggySquareTT (Size: 16, Line spacing: 1.3)*
> (oh and btw IntelliJ is so stupid that if you have "Show only monospaced fonts" checked it won't understand that Proggy is monospaced and hence not show it into your fonts choice list)
> I'm 40 years old and still have 10/10 eye vision, which I attribute to two things: avoid dark characters on light background scheme anytime it's possible and never ever using anti-aliased fonts (which are blurry)
> "Pixel perfect" is the way to go here. And anyway anti-aliased fonts under Linux are so fugly compared to OS X / Windows that you're really not missing much by going pixel perfect.
> Regarding the other IntelliJ IDEA fonts (the ones which are not the editor / console), I'm stealing a Tahoma.ttf from Windows and settings everything to be Tahoma.
> Same for my Emacs but for whatever reason under Emacs I'm using Terminus and not Proggy at the moment ; )
> Now of course it's really sad that the only "ok" desktop UI ever made with Swing is the one made by JetBrains: it took people who wrote the fscking most advanced Java IDE to come up with a reasonably looking Java Swing app : (
> The Eclipse guys didn't even bother and created their own UI (SWT) which kinda speaks volume about the nameless mediocrity that Swing is : (
Simple. Switch to VIM. Or, just write GTK code from scratch directly in the IDE.
It's not too hard. I currently use Swing in Java, all written from scratch - no IDEs to be found. I've also dabbled around with simple GTK+ apps. They aren't as easy, nor as efficient, to work with as the standard Java toolkit, but you get used to it.
I switched back to Swing because I wanted as few dependencies as possible.
So--I'm still missing something. Are you saying that the way to get good font rendering in IntelliJ is to write GTK+ apps? It sounds like you misread the OP.
Ah, I see. I'm sorry about that, but I don't think that there's a solution to fix Swing font rendering in IntelliJ itself. Unless, of course, you dive into the source code.
IntelliJ was almost perfect for Java (last used it 3 years ago), other than the ridiculous memory usage and the constant freezing which I'm pretty sure the JVM's GC was responsible for.
I've been using Qt Creator for C++ code for the past 3 years, and it's so much faster and non-laggy it's lovely - even when having some serious things missing (multiple monitor support).
IntelliJ Idea does not use more than 1/30 of my laptop memory with a huge project open. Constant freezing? This must have been a bug, because I'm using it for 2 years now, and no freezing at all, and autocomplete / navigation / find-usages are crazy fast. It gets a little sluggish only when I switch branches and it has to reindex hundred megabytes of jars. Well, but how often you do it...
BTW: Comparing it to Qt creator is very unfair, because Qt creator does not have half of the features included in IntelliJ. E.g. refactoring / inspections / full type-aware error highlighting (not just syntax checking).
True. I have somehow never liked how desktop applications written in Java turn out. I don't know whether it is because they don't use a native windowing toolkit or something else.
Most Java apps nowadays use the native windowing toolkit. SWT for example (the major gui framework for Java) uses GTK on Linux, Cocoa on OSX and Win32 API on Windows
Usually the blame is on the developers that don't make use of what Java offers.
There used to be a blog series explaining developers how to take advantage of Swing to make nice UIs. The problem is that most don't care and use whatever is the default.
My experience with IntelliJ on Linux is that after a short time spent in the IDE, the software maxes out the OS open files limit (even if you've bumped it up to, say, 4096) and crash horribly (usually blowing away some percentage of the IDE's own configuration each time). Fonts are the least of their problems.
This is excellent news. PyCharm has been great to work with, along with every other JetBrains product barring AppCode. I attempted to try to replace Xcode with AppCore for C++ development as I was put off by some of characteristics of Xcode and had many positive experiences with JetBrains. AppCode ended up modifying my preexisting Xcode project that I had opened, changing several settings that silently broke my build. I don't really recall what settings it broke in particular, but I just reverted so it wasn't that big of a deal. It didn't end up suiting my purposes very well as the C++ support just wasn't that great at the time. It seemed like a decent IDE if you do ObjC work, though.
Recently, JetBrains (the company), their ReSharper product, and their JVM language Kotlin were all deleted from the English language Wikipedia.
I can't follow the deletionists' logic. I hope nothing else is going on -- like a competitor trying to remove information about them.
Kotlin's removal in particular is strange, since several other JVM languages persists at Wikipedia, some of them much less well known than Kotlin. Still there are: Gosu, Ceylon, Fantom, Ioke, Seph, Groovy, Boo, Nashorn, Frink, Pizza, Pnuts, X10, Xtend, etc.
It's certainly better known than any of those other languages you mentioned. In fact, the two greatest innovators on the Groovy language, James Strachan (original creator of Groovy), and Alex Tkachman (original creator of Groovy's static mode), were "encouraged" to move on from Groovy by its present leadership, and are both now contributors to Kotlin.
I'm confused by this. If you had a particularly good IDE in a particular OS, why wouldn't you use a VM and run that OS for the purpose of the IDE? Especially if its on Linux.
Well, the only good C++ IDE (according to many people) is Visual Studio, which is tuned for Microsoft-flavoured C++ (which should follow standard, but like always, some slight difference with g++ I suppose). Also not being able to run the code on the platform where you code is incredibly annoying.
I recommend checking out Qt Creator. It's cross platform, has code completion, live syntax checking, supports regular Makefiles, C++11, and much more.
Plus, if you're looking to build a cross platform GUI app, Qt is a great toolkit, and Qt Creator (as the name suggests) supports drag&drop UI building, QML etc.
Last time I tried Qt Creator, it was very slow as compared to Visual Studio. I ended up practically giving up on it entirely. Please someone tell me I am wrong about this. I liked the interface for Qt Creator very much and would prefer it as such.
I use Qt Creator and Visual Studio 2010 on the same medium size code base and Qt Creator has a much faster UI.
I find that compilation in Qt Creator is possibly slower if you are on windows (using mingw) but on Linux its around 10 times faster (through the use of ccache and make -g4).
It does not fully support C++11. For instance, I still get squiggly underlines for brace initializers in 2.6.2. Renaming is very unreliable. Code navigation doesn't recognize the standard library that's actually used according to the .pro file. Every compile gives me spurious warnings about missing directories on the Mac.
And the documentation is awful. I still haven't figured out how to make precompiled headers work with clang (but that may be my fault).
Unfortunately I can't. That's why I welcome the JetBrains announcement. Xcode doesn't even attempt to do the most basic things like renaming and code completion is entirely broken. Eclipse was too slow to be usable last time I checked and code completion didn't work properly either.
There is a relatively new clang based vim plugin that I haven't tried yet. Using clang to parse C++ into an AST is the right approach, so it sounds promising.
The Creator folks have had a version with clang replacing their own C++ code model for about 18 months ago. Apparently it's too slow for them to merge in. :/
Both MSVC and g++ have some C++ language extensions enabled by default. Examples include msvc allowing you to drop 'typename' where the compiler can deduce that a token is actually a type, and g++ allowing variable length arrays.
Visual Studio works great on cross platform code bases. It is so much better than Eclipse, but I'll stick with vim :)
Nor did I imply it was, but the point is that if you want to do cross-platform development from Windows to Linux, not recognizing those extension is a show stopper.
I don't see where it said they would support multiple compilers. It does say they are integrating with Clang analyzer, but no indication of native support for MSVC idiosyncracies
frankly, I think Visual Studio is a sub-par IDE for C++. Code highlighting is pretty bare bones. Debugging often misses stack frames and it regularly loses access to local variables. There is practically no refactoring support. The compiler has a weird non-standard feature set. Auto completion as usually not context aware. "Find usage" usually does not find every reference. I could go on...
When people rave about Visual Studio, they are mostly talking about C# development. And even there, they often talk about Resharper.
That said, install Visual Assist X and Visual Studio becomes quite a decent C++ IDE. That does not fix debugging or the compiler of course, but refactoring, highlighting, code navigation, contextual cues and auto completion are mightily improved.
This is great! Looking forward for it, there are very few mature C++ IDEs around and this would be a nice addition, specially if it matches their offering in other languages.
Huh. I'm surprised by how many comments here are of the "but we already have XYZ" flavor.
You're right. We don't need more. Let's just stop trying to make things better.
Wakey, wakey. JetBrains is investing time and money (or is that the same thing, anyway?) to develop a new C++ IDE, a market (though I don't like that word) where nothing new has sprung up in a while. That's __good__ news, what's the matter with you? Can it harm you?
I am really looking forward to this IDE.What I am missing is a good profiling tools integration. So hopefully they have this in mind.MacOsX gives them a lot of stuff for free with DTrace and clang, so I am excited how this will work on Linux. (does it have DTrace?) Maybe I will be better off using this new IDE with Solaris or FreeBSD.
10 years ago, I have used SNiFF+ (from windriver). This seams to have disappeared. It was very flexible for cross-platform (MSVC and HP) development in C++ and java.
I think there are many good ideas in SNiFF+ that could be taken.
I don't know the precise answer to the original question. But with regards to AppCode it's pretty much a standalone product that has features IntelliJ doesn't.
IntelliJ incorporates everything found in all the other IDEs like RubyMine and PyCharm but doesn't include the additional stuff found in AppCode.
I've heard that the reason for this is the XCode project format. The purpose of AppCode is to be a better IDE for iOS/OSX development. But if the future version targets cross platform development, not meaning cross platform on the host side, but cross platform on the compiler target side; it would probably mean that the project format support should support Makefiles and other build systems; and hopefully that would be integrated in IntelliJ.
Is only me or they missing a trick by skipping C#? Or are they concerned it'll disrupt Resharper sales? Or is there simple not a market for C# outside of Visual Studio and MonoDevelop?
I've just downloaded and tried AppCode (which I believe this product will be an extension of). It is written in Java and is rather slow when compared to XCode and Visual Studio 2008. The real memory usage on my system for this product is ~340MB which is rather heavy when dealing with a Hello World project.
When dealing with C/C++ or ObjectiveC I expect something that's very light and quick to load - not something that feels this bloated!
340 MB is heavy? What are you coding on? A netbook?
BTW: measuring memory usage on a Hello world project is pointless. You can't extrapolate this value to memory usage on large projects. Most of this memory is just code of the IDE and plugins, which does not depend on the project size. I work on some really huge projects in IntelliJ Idea, sometimes 3 or more at the same time and it never needed more than 512 MB of heap, which is pretty impressive result, considering how much it actually does (all the inspections / type checking / background compilation / autocomplete come at some price in memory usage; most of the C++ editors you mentioned don't support them to such extent, or sometimes at all).
>340 MB is heavy? What are you coding on? A netbook?
I take it that you haven't tried coding on Visual Studio? Just because you have the memory, it doesn't mean that you should be using as much memory as you can.
> I work on some really huge projects in IntelliJ Idea, sometimes 3 or more at the same time and it never needed more than 512 MB of heap
That's because that amount is set as the maximum heap size. If any more memory is required, the disk swapping becomes heavier and heavier. Have a look at your idea.vmoptions file to see what the maximum allowable usage is set for your install.
> most of the C++ editors you mentioned don't support them to such extent, or sometimes at all
They don't support it for C or C++ due to inherent limitations in the compilation of the language - not because they are unable to do so! Visual Studio does all of what you've mentioned for languages which compile to an IL code (i.e those that rely on the .NET framework) with great ease.
> That's because that amount is set as the maximum heap size.
Nope. My maximum heap size is set to 1GB, but the live memory set does not exceed ~200 MB typically.
> If any more memory is required, the disk swapping becomes heavier and heavier.
If any more memory would be required it would not swap, but OOM. Again - if you ever need to swap, then you must be coding on a netbook...
> Visual Studio does all of what you've mentioned for languages
Nope. Not to such extent as IntelliJ is doing it. You need Resharper for all of that. From JetBrains. And VS can easily grab 500 MB of RAM too, especially after a week of work without restarting it (memory fragmentation, maybe some leaks).
> Again - if you ever need to swap, then you must be coding on a netbook...
Please read up on virtual memory.
> You need Resharper for all of that. And VS can easily grab 500 MB of RAM too, especially after a week of work without restarting it (memory fragmentation, maybe some leaks).
VS2012 includes many of the features provided by ReSharper. What does restarting an IDE have to do with this? My point still stands: an IDE should be light-weight and responsive. A heavy memory footprint (which is a hall-mark of Java-based IDEs) is not helpful in achieving this regardless of what kind of machine you're running it on!
Codeblocks is essentially notepad with a gui for mingw compiler options. It cant be compared with visual studio in terms of development, refactoring, and debugging tools.
Their features page states otherwise: http://www.codeblocks.org/features -- Multiple compilers (Mingw, MSVC, Borland, and more).. Build in debugger, plugin support, etc. I haven't used it, so i'm just assuming their website is accurate
Does codeblocks have advanced code manipulation tools, i.e. refactoring support (in the presence of complex templated code)? It's an extremely complex problem for C++, and JetBrains seem to have the right brains to solve it.
eclipse is the best c ide out there at the moment for non-ms platforms.
intellij idea used to have a third-party c/c++ plugin, which was ok, but it stopped being maintained a while back. this was frustrating because otherwise you can develop in intellij in most popular languages. so c/c++ support had been a strange omission for some time - see this support issue, for example - http://youtrack.jetbrains.com/issue/IDEA-86304
(i haven't seen anything saying that this will be an intellij idea plugin - but afaik that's how all their other products work).
