Poll: What features would you like to see added soonest in your favorite C++ compiler?

I just got back from teaching a class, and I’m always amazed at the breadth and diversity of C++ developers. As Bjarne Stroustrup famously says: “No one knows ‘what most C++ developers do.'”

In particular, I’m surprised at how strongly some people feel about certain features, such as refactoring or safety or raw performance or exhaustive conformance, that don’t matter much at all to other people, and it made me wonder how a cross-section of the C++ developer community might prioritize them if I ran a poll.

So let me pose a question: Whether you use gcc or Clang or VC++ or Intel C++ or any other compiler, if you could only pick five of the following for your compiler to implement in its very next release, which would they be? Note that this is intended to be purely an “urgency” or ordering exercise, not an “importance” or eventually-will/won’t-do exercise — assume that your compiler vendor would eventually add everything possible from the list in their next few releases, and ask yourself only what would you just love to have in your hands the very soonest, right away?

(This is not intended to be a complete list, by the way, just picking some things I’ve again recently heard people mention, to validate how broadly interesting they really are.)

Thanks in advance for your participation. I’m really curious to see the results.

[Updated to add: Several people have asked to change the poll to add an option for “faster build times”. I won’t change the poll while in progress which would skew results, but for now if you want to vote for “faster builds” please post it as a comment and I’ll manually add those comments up since that seems to be a popular request.]

92 thoughts on “Poll: What features would you like to see added soonest in your favorite C++ compiler?

  1. +1 for (3a) — faster builds are great, but this would give us the ability to debug the build process and understand which part of the program is slowing down the build the most.

  2. I’ll comment separately because some of my items aren’t on the list:
    1) Conformance 1
    2) Conformance 2
    3) Compile time improvements on large code bases, esp. with heavy template use.
    3a) As part of this, supply better diagnostics about where the compiler is spending its time (preprocess/parse/template processing/compile/optimize)
    4) Static Analysis improvements: This isn’t a canonical part of a compiler, but there are functions performed by static analysis tools that could be done much more effectively if they could draw on the information a compiler has available. For example:
    4a) Dependency analysis: Aside from providing a dependency tree itself, where are header files being #included when forward decls could suffice? Where are header files *not* being included where they should be? Are all of my header files properly guarded against multiple inclusion?
    4b) PCH analysis: How many times is each header file getting compiled? How much time is this wasting?
    4c) Value tracing: Where did the value of this variable come from? Let me trace it back for some distance.
    5) Template debugger: Compiling templates is like running a program, but our ability to debug this process is still stuck in the equivalent of the printf() days. It would be very nice to be able to single-step the metaprogram as it runs, and to see the virtual program that is being created, before it gets handed off to the main part of the compiler.

  3. Faster builds! Our VS2010 compile/link times are much slower than gcc/clang. Also, some of the headers (I’m looking at you, ), add significant compile times per translation unit (something like 500ms on my reasonably fast desktop)

  4. 2. Other stuffs: Still, your compiler makers can implement anything with fewer side effects. btw: the v.t.(it’s important like lambda expressions, please!) may be hard to decoding but also with few side-effect. Another stuffs like ‘= default’, ‘=delete’ (aka. Explicit Defaulted & Deleted special member functions) and Explicit Conversion Operators almost do nothing to the rules of compiling (because I can manually define anything I don’t like as private privilege) can be implemented first also.

  5. 1. About the variadic templates: I’m not sure why implementing this is so hard but as my imagination(sorry! I have no source of the cl.exe so I have no clue about ‘how’) you may implement a v.t. decoder into the compiler rather than analyze the code during compiling(because it take long time and highly memory occupation). Comparisons to the direct compiling of v.t., the analyzing can be arranged after finishing macro decoding and before code-compiling. exports every necessary specialized templates into external temporary-headers(but should be generated by compiling system automatically rather than user). because this method can cut off any unnecessary overloaded function-templates and specialized templates classes. It may reduce the time and memory usage when the real compiling process occurs.
    I can see you already having been with this temporary-header compiling method when compiling COM codes, which has been deployed several years ago.

  6. @Rick Yorgason: I largely agree, yet I want to explain while I still have different priorities.

    I am on Windows all the time, and I know that Conformity should be most important, and slacking on this certainly is harmful in the long run.

    However, build times hit me all day every day, and untangling a header mess is one of the most unproductive time-wasters.

    Even when excluding secondary effects (like more frequent builds and test executions) it would be the one thing that would result in a broad scale, immediate improvement for the entire dev team.

    Even with the effor of a “final untangle” and moving to modules, it would be a comparedly quick improvement that beats all the fun I am planning to have with, say, variadic templates. It is the one thing where I could get the OK for upgrading our dev env immediately.

    This may be in part a result of the project size, history and devs, but the build model of C++ simply falls flat of everything that came in the last two decades. As C++ modules isn’t finalized yet, I am sure there is a time window for the VC++ team to close the most glaring omissions in the C++ standard. However, there is no single(!) other feature in the standard I am waiting for as much as this.

  7. Anything that can improve the speed of Test, edit, compile, test, refactor, compile, test loop. So that would be refactoring tools, as well as compile/link time improvements, language features that help produce correct code faster, etc.

  8. It’s kind of hard to vote without the context of the compiler. On Linux, where GCC and Clang are rocking the C++11 features, I would have to vote for better better graphical debugging and code completion (eg Intellisense). Unfortunately, on Linux there’s less interest in IDEs, and what interest there is is fractured, resulting in less progress.

    On Windows, where VC is king, it’s obvious to any C++ developer that it’s sorely lacking C++11 features. And of course, this being the blog of a Microsoft dev, that’s going to colour the poll results.

    The term “compiler package” doesn’t even make sense outside of Windows. Microsoft is the only vendor that so tightly couples compiler, IDE, and libraries.

  9. I’m not sure about “iterator safety”. Last time I looked at this, it needed to lock its data structures, and those locks perturbed multi-threaded code to an unacceptable degree. (I gather they tended to hide bugs.)

  10. @Ivan if perf optimizations for certain usage patterns were not worthy of std, why is there deque ?

  11. C99 features.

    It is often painful to port legacy C code from Unix to Windows because of the missing C99 feature. It shouldn’t be too difficult to implement. I have feeling this is pure negligence from MS.

  12. I put “faster build times” in the comment field of Other in the survey, but let me say it here, too, to make sure it counts.

    Like SvenC, I’d like to press on both compile _and_ link times.

  13. Oh, +1 vote for build-time performance here. That’s really the only other thing I can come up with which matters as much as conformance here. Refactoring tools have never bothered me overly much, I just refactor by hand. Performance (and GPU performance) is obviously great, but I don’t object to getting my hands dirty and doing that manually for the few performance-sensitive spots in the code. (a few silly issues in VC10 notwithstanding, like its habit of not inlining empty constructors, literally giving me a ‘call; ret;´sequence which just seems like a waste of time)

  14. @PH
    Feature is intended only for debug builds.
    @Chip – flat_map is perf optimization of map that satisfy certain usage pattern and tbh i dont feel it belongs to std

  15. @Kim: Amazingly I agree with almost none of your suggestions. Simple parallelism (e.g. Cilk) is great. Nothing else you named belongs in C++. Of those things, only std::net and std::http have any value, and the third parties have stepped up so there’s no real need IMO.

    OTOH I do think the boost flat_map should be in std. It’s a great idea, has a lot of uses.

  16. Things that would have made C++ better:
    1. StdGui. I am amazed that this havent yet to be standarized in C++
    2. StdNet. I just want to send/receive data from computer to another computer, one solution would have been an integrated type e.g. an int where “int” knows where to send it.
    3. True and simple parallel processing, have you ever wondered how to make several while() loops by just telling the main program what the subprogram IS ?
    4. What if C++ could have an integrated script language python/lua alike? Making it both statically and dynamically typed.
    5. StdFile. Just a pain to get the path of the program. (Cross platform issue)
    6. Stub. Just like in Python you have the if(__main__) to make the stub so you could make components pretty easy!
    7. Make a new type called “text”, where it is an UTF-8 string type.
    8. StdHttp. Why not have a full set of tools availible to read and write to the web? hin and hout :)
    9. Ability to have the binary contain a zip-file with files inside it. Much like in OSX. I know it’s possible but is really a hassle to do. I would like to see it in the main().

    Those things already exists in Java and Python today!
    Make it happen, please.

  17. I’m quite happy with the compilers I use to develop (g++, clang). Unfortunately, as an organisation, we still have to support VC++, which is somewhat behind. I’d like to see cmake integration in VC++, so that I don’t need to re-load the IDE so often, and for Linux IDEs, better refactoring support, and better IDE performance.
    I’d also like to see C99 for all compilers, and in VC++ proper C++11 support, and support for building Fortran projects in a sane way – without linking a separate static library.
    I’d also like to see an end to platform specific extensions, and on Windows, a proper make program (MSbuild is crap, nmake doesn’t do parallel builds, and devenv is pretty flaky with huge projects).
    I’d also like to see library versioning on Windows handled in a sane way, with better options to control library search paths (no more setting PATH, side-by-side assemblies, or bundling lots of libraries in executable directories). I’d like to see a nice way to handle late symbol binding on Windows (like RTLD_LAZY on Linux).

  18. Another problem with adding features to C++ is that it’s already an insanely complex language. I can’t think of any other language which is so complicated that it can easily surprise even those programmers who have used if for years.

    Template meta-programming is an interesting idea, but the resolution process can be very complex, and programmers can’t watch it unfold. So it can be nearly impossible for programmers to figure out what went wrong when a template can’t be instantiated, or when unexpected runtime behavior occurs. This is compounded by the interaction of template instantiation, function/operator overloading, and automatic type conversion/promotion. At this point

    I think the language is so complex, and templates can lead to such crazy problems, that a overhaul is in order. The creation of Java was a step in the right direction, but Java’s “write-once, run-anywhere” approach precluded applications requiring the fastest-possible performance, or precise control over memory and low-level hardware details.

  19. Sometimes I think new features actually hold a language back,rather have less features but reliably implemented ones across multiple environments. So more IDE enhancements and faster compile get my vote.
    If talking VS then it’s got to be the fix for the worst user interface ever, bar none, on VS2012

  20. Lot’s of people have problems with compilation times. I do my fair share of template code but I didn’t even know it was a problem these days. What are you compiling that makes it a problem? What hardware do you run on?

  21. I had to mark “other”.

    There is no box related to less memory bloat. That probably ties in to well-defined ABI, which is something that goes out the window as soon as the speed freaks get concerned.

  22. I voted on performance… and I’d really like to see better threading in the future. Processors are moving away from single core performance to multi-core performance and ease of threading has not gotten that much greater. This means so many people do not utilize threading, or don’t use it properly.

  23. My code is cross-platform, and I strive to have it compile with the current versions of VisualC++, IntelC++, and gcc. At the moment, only VisualC++ is holding be back from starting to use certain features of C++11, and I’d like that to change.

    I don’t care much about the execution speed of the resulting code, because when performance matters, I build with Intel’s compiler anyway.

  24. @Ivan
    > “changes to a pure function require only small patching of the exe instead of compiling the entire source again.”

    That’s not true if the optimizer had a go on it. Code may have been inlined, folded with another method or collapsed to a constant.

    Generally, I’d refrain from adding “special case speedups” since incremental builds are unreliable enough already, and rather speed up the build process as a whole.

  25. C99 should be a priority. Sometimes it appears that there is a willingness to burry the C programming language. As it can’t be done in technical terms then the next best thing is to force cruft to the standards and then display a complete unwillingness to implement the cruft that was introduced by yourself.

    So, yeah… C99. And C11 too. Get your act together.

  26. “Re C++11 conformance: There is not yet any 100% conforming C++11 compiler — even the gold-standard EDG compiler has not implemented it all; they don’t have raw string literals for example — but all of us vendors are working on it, and based on what I’m hearing I continue to expect to see *multiple* reasonably-fully-conforming implementations (i.e., including all the big things like variadics, initializer lists, async/future, atomics, etc.) shipping in 2013.”

    The latest info I can find on EDG is from back in December 2011 and doesn’t actually indicate all that much C++11 support.

    Judging by this page (http://wiki.apache.org/stdcxx/C%2B%2B0xCompilerSupport) at the moment Clang seems to be at the top (sort of amazing considering that two or three years ago clang didn’t support C++98) followed closely by gcc.

    Although really I’m just glad that things seem to be progressing so much faster across the board than implementing the original ISO standard did (at least for the major compilers; there are still some like the compilers for HP and Solaris that it seems there’s little hope for).

  27. Herb

    Your general comment doesn’t make a lot of sense to me. I’m not clear it addresses my questions either. Being general, though, I take it that it was not supposed to.

    In any case, I stand by my earlier comment, and add a response to your last one. The reason your “general comment” sounds all well and good but leaves me concerned still, is this:

    First, you make it sound like Microsoft is a lot less far behind (than the rest of the field that matters), than I believe Microsoft really is, r.e. C++11 language features. But we’ll “soon” see on that, won’t we?

    Second, when you seed your poll of “what people want on all compiler products and platforms”, as you have, with at least 3 *critical* things, and ones your main competitors already have – and you are lacking in – you invite readers to infer that if they voted for refactoring (for example), over implenting all of the C++11 language features, then that’s what we’d get. i.e. the language features might get delayed even further. When MS/we are already working with an already unknown timeframe for full C++11 language features, that’s a worry.

    Also, when 2 things are essential, arguably 3, so let’s call it 2.5. and we can only pick 5 things in total, then to my mind 50% of my votes are “wasted” having to vote on things that everybody else has. That’s less of a deal than it first seems! Just saying! And who cares about the answers for those 3 criticals – other vendors have already answered the call. They are here. Where are you?

    But the main issue is giving the impresssion you’d delay C++11 language features. They are too much of an enabling thing for everyone. To let people infer those criticals are up for negotiation by having them in the list is a mistake; and even more so, when you mention “real soon now” when it’s really “real soon now, for what features, exactly?”. The implication that the C++11 language features could be voted off of the island is unthinkable. You must see that?

    So simply put, Conformance Part I and Part 2, just shouldn’t be in your list because they should not be negotiable because they are a must for the good of the C++ community. Keeping them in your list suggests anything could happen to them, and is praying to the same god that lets common sense slip right past focus groups. The same way those crazy capital letters and colours got approved. Don’t let that happen here.

    This is a gut call, and the reason for my post and why I am asserting that even the idea of delay here calls Microsoft’s commitment to C++ into question. Please clarify that with times and rough dates for exactly what of those language features.

    In my view, you should be driving the C++ language features hard, as critical, non-negotiable items that will get done as soon as possible at any (reasonable) cost and at the expense of any other feature (except bug fixes). To do other, just hold’s up the industry because C++11 languages features are the number 1 must have and you are best disposed to deliver those for Windows. If for some outside reason you believe any specific language feature is a bad idea to implement and shouldn’t be delivered, I’d be open to hear that as an excuse, but that’s about it.

    The other fluff, particularly re-factoring, anyone can deliver, and probably will. If you don’t want to leave yourself open to competition on those other fronts whilst being tied up implementing C++ language features, hire more staff!

    I am interested in the other items you mentioned such a checked pointers (an eventual inevitable *option*) etc. but only as nice to have, so I’ll save that for another post as this one is already long enough.

    Thanks for the poll, I’ll be keenly interested to see what other view points show up.

    Thanks
    Glen

  28. General comment: I really did mean this poll to ask about what C++ developers want on all compiler products and platforms, not just VC++.:) In particular, it was prompted because several people have recently again prompted me about refactoring, and I’ve just never felt the need myself, but maybe I don’t get out enough, so instead of assuming I thought I’d ask the question. I will be sharing the results of this poll with the C++ committee in general as input into our October 15-19 meeting as it will help inform our post-C++11 work which is really accelerating now.

    Re C++11 conformance: There is not yet any 100% conforming C++11 compiler — even the gold-standard EDG compiler has not implemented it all; they don’t have raw string literals for example — but all of us vendors are working on it, and based on what I’m hearing I continue to expect to see *multiple* reasonably-fully-conforming implementations (i.e., including all the big things like variadics, initializer lists, async/future, atomics, etc.) shipping in 2013. As for Microsoft’s product specifically, we’ve said we’re planning to ship out-of-band releases “soon after VC++ 2012” (which is soon indeed now!) and particularly that we want to take advantage of that capability first to deliver more and more batches of C++11 features, first in a CTP (community tech preview) or similar form. Based on that, one could divine that the first batch shouldn’t be far away…

    I plan to share more information about both of the above — ISO C++ standardization progress going strong this year that will benefit C++ on all platforms, and a concrete update on recent VC++ progress since VC++ 2012 recently shipped in particular — in a talk around the end of this month. I’m not sure yet whether that talk will be broadcast live on the web (decision not yet final), but it will be recorded for on-demand viewing (usually with a few days’ delay to get it up on the site) and I’ll provide information and links here as they become available. Stay tuned.

  29. Herb

    I’ll do my own poll here.

    Does anyone else thinks it’s frankly insulting to keep being asked about language conformance priority at a time when everyone else has already conformed?

    I’m absolutely all for asking my priorities in advance, so credit there, but repeated dumb questions about language conformance really just attack Microsoft’s credibility.

    Just do the conformance already!! At least regarding part I, and II. I don’t know what else you had in mind for part III, you weren’t specific.

    I think this poll could have been better explained/organised but that’s no big dea compared to my real beef:

    To keep asking about conformance in terms of priority, when your competitors are already there on those C++ features, suggests a lack of resources – or why ask?

    Except Microsoft doesn’t/shouldn’t lack resources. If you say it does, I’ll tell you that must mean what Microsoft is really lacking is commitment! – exactly for the reason that everyone else already has conformance, even open source! So what is the real reason here?

    Is it because you don’t want to put those resources into an old compiler while you develop a new one, and want the rest of us wait around forever while you catch up, or what?

    It also doesn’t make sense not to do conformance first, because when those C++ features are done (which you voted for so I assume you value them), you, and more importantly, we, can use them in improving and writing code easier that will create better versions of all the other features you talk about.

    What exactly is wrong with this logic?

    I want to be pro Microsoft but I find Microsoft’s credibility constantly on the line, stumble after stumble, while everyone else quietly get’s on with it. It may seem harsh but Microsoft wouldn’t be here if it wasn’t for it’s own dumb fault. Even if you get there in the end, what a drama on the way!

    You’ll probably tell me other people don’t value conformance as highly as me, but just so you know in advance, that wont wash with me – that whole pre-text of this vote is misguided. I’ve given you good reasons why. If that ends up being your best answer, I’ll watch the ensuing flame fest and we can both count votes. I think Microsoft lacks common sense.

    Anyway, here’s my 5 votes. If the public agrees, vote for me!

    Stop breaking things that already work is number 1.
    Fix your bugs is number 2.
    C++11 language features is job number 3.
    Build/link performance is number 4.
    Hiring a clown off the street to fix the icons/colours that the last clown messed up would also be a nice to have. 5
    Anything after that is up to you!

    That’s my priorities list. Now, people, vote for me!!! I want to be in charge! :)

    PS
    I’ll switch my “other” vote for modules to build/link performance instead. I’m pragmatically assuming you’ve got no chance in hell of getting anywhere near preparing for modules in my lifetime and when you do they’ll be a technology lock in. So you might as well get the build/link performance up sooner however you can while we wait for ever for perfection.

    Glen

  30. constexpr is something that I would use a lot more if it were available across more compilers. Particularly if it were extended to allow any pure function. Stuff like being able to compile down string identifiers used in code into a hash at compile time.

  31. I’d like to see better project generation for libraries from MSVC. On Linux this is a solved problem with package management etc, but on Windows even building and using zlib is a hassle.
    Won’t say no to faster builds / shorter build times either.

  32. Being in a multi-platform shop, the biggest issues we have are conformance (we’d like to share more code that’s already taking advantage of C++11 features) and build speed (the Windows builds are 2-3x as long as next slowest platform).

    And, of course, we need to do this while still targeting Windows XP.

  33. Language Safety: Fast pointer-safe and bounds-enforced C++ usable in release mode.

    This is very interesting and would be very nice to have. Does this mean that even nullptrs and dangling pointers would be checked for safety?

  34. In which option does Variadic Templates reside? Last I checked they were not available in the RTM release of VS2012, or is that not the case?

  35. The most important feature in my idea is Concept or Require which can define a template and so that can make IDE better.

    Complile time Reflector maybe useful for data serial, but I don’t think it is critical feature.

  36. My voted were for Conformance and Safety. And Reflection, which in some scenarios would be really useful but currently needs to be accomplished with really complicated workarounds. With modern hardware, raw performance is less of an issue than it once was unless you are doing realtime or embedded programming, which – lets face it – most people don’t…

  37. Hi Herb,

    I would have liked to be able to choose object introspection at runtime, object introspection at compile time (because SFINAE is still an hack), better integration of SIMD, concepts, unified ABI between the compilers…

  38. Herb by the power of Haskell Curry I force you to add the option: add proving that changes to a pure function require only small patching of the exe instead of compiling the entire source again. Also restrict would be nice nonISO addition to MSVC, or #pragma pure for portability

  39. Modules, because build times and dependency management is the biggest day-to-day PITA for large projects, and setting up a small project that needs a lib is way more awkward than it should be.

  40. I would kill for “:” range operator found in Matlab/Python. If you do a lot of numerical programming, you understand :)

  41. I agree with the clamor for build time improvement (ccache!) and module support. I develop cross-platform so most of my pain is in the differences between compilers. To offer some radical ideas, I’d love MS support for Clang in VS/Windows. Managing the various makefile formats is also a headache that isn’t improving over time. With CMake support I would no longer have to suffer the ritual of: close VS, sync, rebuild my projects, reopen, wait for parsing.

  42. Yet another one for build time (and safety – a lot of people turn off the useful STL checks because they are too slow). I’m a bit worried about the interpretation of these results, though. The top-5 format without any ranking information may boost certain consensus items like Conformance I, which is often in the list but probably not something people are passionate about.

  43. Faster build time ! Going toward better error message would also be nice…

  44. I would trade everything on the list for significantly better compile/link times. Even small, incremental builds on a large project can engender a context switch as you wait, again, for projects to compile and link. If tenths of a second are significant for retaining web traffic, imagine what sort of psychological effects minutes/hours long compile times have on programmers who otherwise enjoy C++ as a language.

  45. I only need three choices, not five:
    1) Conformance III
    2) Conformance II
    3) Conformance I

    The other choices may be nice once 100% conformance is reached. Until then, it is too early to consider.

  46. How about fixing bugs **cough*two-phase lookup*cough** before adding more features.

  47. Well I think if the language was compiling faster, more people would work with C++ in different domains where we don’t see it that often, making more people experience more sides of C++, then making such kind of poll even more relevent…

  48. I chose the Conformance I,II,III and GPU Performance and STL Safety. With respect to conformance, I want C++11 completely implemented. With C++’s flexibility, you never know what “least frequently used” feature becomes important. For example, template templates were probably considered “least frequently used” features but became really important after Alexandrescu’s “Modern C++ Design.”

    I like refactoring support, but I can get it easily as an addon-on (for example VisualAssist) and it should get even easier with Clang becoming popular, and it is orthogonal to everything else. Whereas having to use a different compiler means IDE/build integration problems, a new debugger, new libraries, etc.

  49. Faster build times, and better error messages should have been included.

    Also, I didn’t vote for language and stl safety, because it wasn’t clear if I would be able to turn them on and off.

    One feature I have always thought would be cool is a “performanceSense.” Something that will on the fly or at compile time let you know you are making a copy, when it looks like you really wanted to pass a reference.

  50. Build time, especially link time, is our number one issue. After that debug performance: the STL is *so* slow when compiled without optimisations. I don’t know if it’s even possible but it would be great if the compiler could somehow selectively optimise library code whilst leaving user code debug frendly.

  51. Faster build times especially with MSVC… Our msvc build is 4 times slower than our gcc build…

  52. Most of the stuff I want isn’t really covered in your list, so here’s my list:

    1. modules (I think this helps the people wanting faster compile/link times, and drastically improves the build system)
    2. C++11 conformance (actually if MSVC caught up to Clang/GCC I would be mostly satisfied with conformance and this would drop to #4 or #5, but still on the list)
    3. opt-in type metadata (I think you need modules for this to work properly so class definitions are compiled exactly once. I’d prefer being able to annotate specific types I want metadata available for. I also want to be able to read the metadata for a module in say a standalone app that doesn’t compile against the code with the types in question)
    4. metaprogramming (*not* template metaprogramming. I think you need modules for this as well. I want to write normal C++ that executes at compile time and has access to a standard C++ AST that I can read/modify/generate)
    5. concepts (I guess static_if is a good start, see what we need after that)

    – I write a lot of cross-platform (game engine) code, so in terms of performance, unless all target platform compilers implement them, I usually have to go platform-specific anyway and this is expected, so I’m not desperately wanting to lean on the compiler heavily to save me here

    – Refactoring sounds nice, but the refactorings you’re talking about are mostly moving text around – I don’t find myself spending lots of time doing this.

  53. It appears using &lt &gt tags was mistake, list should be: Con II, Con I, faster builds, other, Perf1; and then ‘Where other would be”

  54. I hardly care about refactoring 1 and 2, as some other tools (like 3rd party plugins) do that good enough not to be utmost priority. Not that I don’t care at all, just examples presented are low to my interest. Perhaps more static analysis, but once again I can depend on other tools for that for now.

    My list in order would be: Con II; Con I; ; ; Perf 1; (voted con1,2; perf1,2; didn’t spot other)
    Where would be – feedback from compiler to IDE, after build which function got RVO, or inlined (and perhaps why not), “Codegenerated asm” cooperation is still relatively onesided: can’t see asm before debug; could use some small stuff like highlighting; some bigger like dynamic function compilation to see how my code optimizations works or fails; know by looking at code after build which parts were vectorized, etc.
    Generally some more compiler feedback in IDE.

  55. 1. Faster compile+link times (#1 problem with C++)
    2. IDE responsiveness
    3. IDE stability
    4. Better error diagnostics (especially with templates)
    5. Better debugging tools for optimised builds.

  56. +1 for “faster compilation time”, especially when template-heavy code is involved.

  57. I voted for “faster build times”. It would be cool if Microsoft had an experimental “modules” solution available in an optional way, but something tells me it will not happen because you already have tons of work to do. ^^

  58. I chose conformance and refactoring. Although one of the compilers I use already has conformance I and II I figured it’d be cheating to just select conformance III. I really do want things like inheriting constructors and thread-local storage (including the thread-local c-tor/d-tor behavior, which as far as I know no one’s done yet.) Of course I’m also still using some compilers that have yet to achieve enough C++98 compliance…

    Also, refactoring in C++ would be awesome and I’m really looking forward to the stuff coming out of the clang tooling project and IDEs integrating that.

    Next on my list would probably be the language safety issues; more static analysis, more undefined behavior catching (Richard Smith is working on some very cool features…).

    Performance is important but a lower priority because it just doesn’t get in my way as much as poor standard conformance or provide as much visible benefit as things like refactoring and static analysis.

  59. PS – Without changing the poll and skewing results, how about this — if you want to vote for “faster build times” please post it as a comment and I’ll manually add those comments up since that seems to be a popular request.

  60. I’ve enabled to show full results — hopefully the counts will start to show up.

    Several people have asked me to re-poll with compile/link time improvements — I take that as data in itself. :) If I run another in the future I’ll try to remember to add that, thanks.

    Re refactoring and IDE/compiler: Sorry for being sloppy, I meant “compiler” as in the whole compiler product, and besides that refactoring does need some compiler support including a real compiler front-end in the IDE (the IDE needs more than a tag parser, it really needs to fully and correctly parse the code and build ASTs and such).

  61. @David: I’m not surprised. I’d wager that a lot of apps are not compute-bound these days, and those that are already use intrinsics/assembly to improve performance. Variadic templates, on the other hand, would benefit everybody. Then again, I work on servers, where resources are rarely a constraint — and if they are, we throw more servers at it. :)

    One thing I did notice that was missing as an option: faster compilation times, especially in template-heavy code. I’d rank that ahead of all but Conformance I.

  62. @David

    As much as I’d love to see a 20% perf increase over what our current optimizers can do, I just don’t see it happening outside of trivial code, or stuff that is embarrassingly parallel. Other than a few annoying corner cases I’ve run into, the optimizers are pretty damn good. Some of the new C++11 features, however, would allow us to more easily write more performant code — probably for bigger gains.

  63. @David: It’s relatively cheap to buy better/faster machines and relatively expensive to buy back time one has spent on compiler gimmicks trying to write portable code.

  64. Interesting that most people care about adding language features over more speed. Working in RT environments and seeing program bloat in the ‘regular world’ I’d think that performance would be a bigger deal.

  65. Nice poll. The refactoring choices apply more to the IDEs domain, than to the compilers domain, though.

Comments are closed.