C++ IDEs – a rant | Hacker News Reader

C++ IDEs – a rant

gamedev.net

24 pointsdouche51 comments

This article was interesting, showing a completely different world-view than the one I experience. Compiler from vc++6? That's ancient! Misses loads of fun C/C++ features (and I'm not even talking about the massive shift in new C++ versions). Sure, you can be productive even in c89, but why... These days I don't trust code which doesn't pass modern compiler's all-warnings run, and tools like clang-analyzer.

Author also has an interesting view of QT Creator development / doesn't seem to be familiar with OS projects. "Or perhaps the guy who wrote it (denis mingulov I think?) will improve it, but I think he developed it in 2010." - meanwhile 6 different people committed new code to the QT Creator in the last 24h.

There's a few more fun things to spot if you read carefully. But what I'm saying is: it's worth remembering developers work in very different groups / environments.

Side note: `-Wall` is not "all warnings". gcc(1):

> -Wall

> This enables all the warnings about constructions that some users consider questionable

Personally, all my Makefiles use `-Wall -Wextra -Wpedantic -Wformat-security -Wshadow -Wconversion -Wfloat-equal -Wpadded -Winline -Wvector-operation-performance` by default, adding or removing some depending on the project. `-Wconversion` is specially useful.

There's -Weverything in clang, but it's not available in gcc.

He is talking about the IDE, not the compiler. The IDE itself is a big thing,compare with compiler.

I think MS drop the MFC based VC6,then move to C# based VS2002 till now is a big mistake.

The Office team still using their own tech stack, it is good.

He's talking about both actually, even in the first section. The whole review has been triggered by trying to add SSE operations to code compiled with VC6.

> a completely different world-view than the one I experience

No kidding! I'm still bewildered and vaguely horrified by the idea that in some worlds changing your text editor means you have to modify your projects to work with the new one.

While this is terrible, it can be easily explained at least. If your IDE doesn't own the build process, you have no idea which defines are valid and what's linked to what. You could monitor the build process to get that info out, but that means you need one full build before your autocompletion starts working.

That's only because C++ makes this hard. It's not fundamentally true that you're editor needs to own the build process to be a useful tool.

Heh, here is where i write most of my 3D game engine's code (slightly older image, but still applies):

http://i.imgur.com/8mp0vLL.png

The same image provides the reason too :-) (hint: look the compile time, it is for a full build).

Although the code is very portable and compiles under any Windows compiler i've tried (including MSVC, MinGW/GCC, OpenWatcom, Digital Mars C/C++, Pelles C and of course Borland) as well as GCC and Clang under Linux and OS X (both compilers under both OSes). I often use VS2015 for debugging.

I think the article also tells a lot about the C++ style the author uses. Probably mostly class and inheritance oriented, no big uses of templates. That kind of style somehow worked with VC6. VC6 never liked the template-oriented style (boost-style), and even when it compiles intellisense would mostly not work. In my experience this was first improved with VS2013, which together with VS2015 provides a quite good experience for those codebases which use a fast amount of C++ features.

Personally don't think VS13/15 are noticeably slow, on a halfway modern development PC the experience is quite ok (lots better than using Atom for anything). I also had good experiences with QT Creator, although I used it mostly for QT related projects.

Why use an IDE, specially for C++? What's to gain from Emacs/Vim + Makefiles (or CMake)? I used Eclipse for a while several years ago when I didn't understand linking and it compiled and linked everything for me (same for VS under Windows). I did not understand how Qt worked when I started using it, but I could build semi working stuff with the Dreamweaver-like tools of Qt Creator. Eventually I learned how to use it and dropped Qt Creator. CodeBlocks is closer to Notepad++ than to an IDE for me. So... Why? But then again I don't understand why people use C++ in the first place, my only use for it was when working on projects built with it.

To the first question: A rather well known C++ developer used to wonder that too, until he got older, and couldn't remember everything about the language and his projects in his head any more. At which point intellisense type features began to make sense to him.

So if you can't see the use, you are either still extremely clever, or haven't worked on complex enough projects to see how it could be useful.

Why use C++ in the first place - because not a single language/ecosystem has come to exist yet that can replace it when performance is really important. If you are trying to make Doom5, you can't waste a single instruction. You can't miss the cache unnecessarily ever. You can't waste a byte of memory. You wouldn't believe the kinds of things AAA game developers (or the developers of the engines they use) have to do, to get done what they do.

Rust can't quite do it yet. D can't quite do it yet

Java/C# et DEFINITELY can't do it yet. And yes I know Unity uses C# for it's scripting language, but someone has to make Unity.

I assume you're talking about Carmack... Do you have the quote about intellisense?

not Carmack, I think he has always liked IDEs, even when he was young.

Won Chun is the guy I'm talking about.

I haven't worked in very complex projects, true, but I don't see how an IDE would be any better than standard *nix utils (find, grep, sed, etc). Well, maybe time will tell me :)

C++ is not what I'd go for if I could not waste a byte of memory, though.

People use C++ because for some projects (like 3D games) it's pretty much the only (mainstream) language that is capable of outputting a fast enough binary, yet still keeping the code somewhat maintainable.

Off topic but in case you might consider it helpful, I think you used "What's to gain from..." incorrectly. "What's to gain from X?" always means "What benefits will X bring me?" I think you meant, "What's to gain compared to..." or, alternatively, "What's to gain over..."

Thanks, I appreciate the correction!

For me it's mostly about all the contextual information VS shows. I've been away from C++ for some time and now again working with VS2015 and was impressed how intuitive the presentation of contextual information was, especially when running/debugging the program. For example, pointing the cursor at a complex container type object with smart pointers etc. resolves everything nicely with that (+) popup menu. Tried the same thing with XCode and had to click through thousands of smart pointers etc.

Also tried to set up vim to have all the features that I typically use in VS... took me days and, lot of headache and then forgot about that again.

Visual Studio 2015 Update 3 has some performance improvements and some big C++ compiler improvements.

You can also make it less visually 'noisy' with some of these settings: https://jackmott.github.io/programming/tools/editor/ide/visu...

visual studio 2013, represents the point where vs was pretty usable for c++ again, 2015 is better. But they both pail in comparison to how quick vc++6 was.

Yeah I know, but on a modern PC, with the latest VS and silly settings turned off, I'm not often annoyed by slow UI issues. I know some people who use the debugger a lot are annoyed more often than I am.

The only thing worse than debugging in VS is debugging in any other IDE - or even worse, via the command line.

Clion is decent, especially if you work with cmake. Kinda sucks you cant get the functionality as a plugin with IntelliJ.

(Free for open source projects)

I wanted to like clion. It is so good looking and had the standard set of jetbrains magic, but wow is it slow. If I'm trying to wrestle the ideas from my brain and squash them into the editor, and then I'm suddenly interrupted with another line of thought wondering what this beautiful IDE is churning away at and I hope it's getting all these keystrokes that aren't appearing yet...that's not going to work.

Agreed. Thats my problem with pretty much all the jetbrains IDEs. I have a high specced modern MBP and its still slow and the UI locks up. Meanwhile VS and Xcode preform awesome.

I've had the exact opposite experience - all the JetBrains IDEs have been super responsive, whereas Visual Studio could never keep up with moderately fast typing and regularly hung for minutes at a time.

There are ways to make it faster. On Linux at least, putting my /tmp into a ramdisk, tuning the JVM parameters and disabling features like animations and plugins made it a bit better.

If you really care about the process and how everything works, I don't see how you can beat vim/emacs + command-line. Ultimately text interfaces will always be easier to manage and give the lowest resource utilization

> If you really care about the process and how everything works, I don't see how you can beat vim/emacs + command-line. Ultimately text interfaces will always be easier to manage

A few things I think text interfaces are, or tend to be, terrible at:

  Profiling information (can't beat flame graphs)
  Graphics debugging, previewing UI layouts (text is terrible at displaying the results of pixel shaders)
  Discoverability (VS has so much UI up front to discover that it's literally overwhelming for some, a vim user will hit the manual to figure out how to even get into insert mode...)
  Manipulating and viewing many tree and node based structures (shader graphs, parallel stacks, ...)
  Even basic scrolling (map style scrollbars are wonderful for large files in alien codebases...)

Even basic intellisense requires text interfaces to awkwardly pretend they're a real user interface with ncurses or the like. VS has it's drawbacks - it's a hard-to-extend monolith, there are too many blocking operations are on the UI thread, it hits the disk too much, etc. - but I've seen these issues in text based tools as well. The problem isn't that it should be text based.

> Ultimately text interfaces will always [...] give the lowest resource utilization

I want to maximize the useful utilization of my time. "Lowest resource utilization" is not a goal. "Most efficient resource utilization" might be getting there, but I'll happily eat some wasted CPU time on the off chance it'll mean less wasted mind time. Powered down silicon is a wasted investment.

Although I can't contend the other points, I've had good experience with profiling in the command line. I find that quantified tick counts/cpu time is actually easier to read than are flame graphs

edit: but yeah, if you're doing graphics work, you certainly want a graphical editing environment

I mean sure, if you're manipulating data that isn't textual, you're going to want some non-textual interface to it. Code is text. Editing it as text makes a lot of sense.

As for your points about map scrollbars and completion UI, I can't speak for Vim, but Emacs has had graphical capabilities for a long time and does both of those things quite handily. I don't see the point of map scrollbars and I use code completion only sporadically, but they're there if you want them, as are many other perhaps surprising things, and Emacs doesn't feel a need to show off and get in my way as I've found more heavyweight tools like Visual Studio to do. (And what a world we live in, where Emacs can reasonably be called lightweight by comparison with anything...)

I wonder if with the new ref improvements in C# 7.0, there will be more adoption of it for game development (even amongst these sort of C++ people, who think C# is 'tacked on' to VS, rather than it being the other way round).

I don't see a huge win there. Since RyuJIT C# has been a reasonable option for game dev. Value types are already there to help avoid GC and get fast array iteration over small things.

There is some SIMD support. What is there, is pretty good. But not everything is exposed. That would be nice.

Better array bounds elision would be good, and that may be coming, I know they are looking into it. It does it but only in the most obvious cases.

Some kind of official graphics library support would really be needed. XNA is dead, and has been for years. Managed DirectX is even more dead. The community-supported options are Monogame (an open-source version of XNA), SlimDX (a kind-of-no-longer-supported wrapper around DirectX), and SharpDX (a more-actively-developed DirectX wrapper). I think there are also some options for OpenGL wrappers on .NET, but I'm not familiar with them and they don't seem to be that popular.

The main C# killers for gamedev are:

- Portability (to consoles - you basically need to port Mono yourself, as NDAs prevent upstream from receiving all the necessary changes...) - Legacy (lots of C++ libraries they want to use - you can write C stubs to PInvoke, but this can be awkward...) - GC collections (with little control over the timing of latency spikes other than to avoid all allocation during gameplay - again possible, but awkward.)

Many of these are more ".NET Runtime" problems than C# problems.

Game development, as far as cutting-edge AAA-looking games, will never adopt a language with automatic memory management.

I guess Rust is the only language that has a fair shot at that right now.

Swift uses reference counting and does not suffer from latency spikes. So it can also be used.

Reference counting is still a form of automatic memory management and has performance implications. Remember, when dealing with data volumes along with performance constraints of a typical modern video game, cache misses are CRITICAL.

There is also CLion — an excellent C++ IDE from always brilliant JetBrains.

Netbeans is pretty good: https://netbeans.org/features/cpp/

https://www.cevelop.com/ this one works well for me.

Source insight is pretty good although it's more an editor than IDE

Xcode is an absolutely amazing C++ IDE! I wonder why the article did not mention it?

Did you noticed he is speaking the whole time about the Windows infrastructure? There is no Xcode.

He was comparing Windows-specific IDEs. I do agree, XCode beats a lot of IDEs out of the water when it comes to C/C++.

Gamedev.net is not really an Apple place. It almost dates back to the MS-DOS days, and has pretty much tracked with Windows-centric game development.

OMG, please no. Xcode is one of the worst and most buggy IDEs ever. The sheer number of times one has to restart the IDE, clean up the "Derived Data", go through git merging clusterfuck because of Xcode's peculiar project file format is staggering. In addition to all of that, it's extremely stateful, so when you are having problems it's almost impossible for your colleagues to reproduce them on their instances. With every new release of Xcode I hope the Xcode team has understood and fixed these basic problems, but all they mostly do is just introduce new bugs. Xcode is the single worst aspect of my daily programming.

That has only been my experience around swift. Have you used it for C++?

This expression only parses if its type is inferred to be "Troll"

Reply on news.ycombinator.com