Jump to: navigation, search

CDT/survey/2013

< CDT

Are you a CDT user or developer (CDT or CDT-based product)?

CDT-Survey2013-q1-chart.png

  • User 56 (66%)
  • Developer 29 (34%)

On which platform do you use CDT the most?

CDT-Survey2013-q2-chart.png

  • Windows 30 (35%)
  • Linux 51 (60%)
  • Mac OS X 3 (4%)
  • Other 1 (1%)

What would you like to be the focus of the next CDT major release ?

CDT-Survey2013-q3-chart.png

  • Improvements to the UI and usability 27 (8%)
  • Improvements to the user documentation 17 (5%)
  • Integration with other build systems 22 (6%)
  • Integration with other compilers 13 (4%)
  • Integration with other debuggers 14 (4%)
  • More Refactorings and Source generation 39 (11%)
  • More debugging features 22 (6%)
  • Improvements to the build system 14 (4%)
  • Improvements to the editor and source navigation 25 (7%)
  • More code analysis 30 (8%)
  • Better APIs for CDT developers 15 (4%)
  • Better documentation in CDT code 13 (4%)
  • Bug fixes (stability, broken features, etc) 37 (10%)
  • Better scalability and performance 36 (10%)
  • Better support for C++11/C++14 language features 23 (6%)
  • Other 17 (5%)

Detailed Responses

Q1: User
Q2: Windows
Q3: Integration with other compilers, Integration with other debuggers, More Refactorings and Source generation, More debugging features, More code analysis, Better scalability and performance

Details: By better integration I mean make the other toolchain option more expressive. I frequently have to jump through hoops to integrate for instance waf projects to work the way I need them to.


Q1: Developer
Q2: Linux
Q3: More Refactorings and Source generation, Better scalability and performance

Details:

Refactorings:

  • Change Method Signature
  • Inline
  • Override/Implement Method

Q1: Developer
Q2: Windows
Q3: Improvements to the UI and usability, Improvements to the build system, Better APIs for CDT developers, Better stability, Better scalability and performance

Details: user experience and stability would be my primary suggestions.


Q1: Developer
Q2: Linux
Q3: Integration with other debuggers, More Refactorings and Source generation, Improvements to the editor and source navigation

Details:

Integration with other debuggers: lldb

More Refactorings and Source generation:

  • change (update) declaration/definition signature;
  • create local variable (performance and behavior fixture);
  • implement virtual functions of base classes;

Improvements to the editor and source navigation

  • support template classes in types hierarchy

Q1: User
Q2: Linux
Q3: Integration with other build systems, Improved usability with cmake

Details: A major improvement would be if Eclipse would not insist that the directory where the project file is loacted, is the root directory of the project. CMake can generate projects for Eclipse, and it is strongly recommended to use out-of-source builds. This has the effect that the Eclipse project file is not in the source tree, but in the build tree. This confuses Eclipse, e.g. revision control does not work (and it also does not work on a linked resource pointing to the source tree). It would be great if the project file could contain an entry ""ProjectSourceDir"" or something like that, which is then used as source directory by Eclipse instead of the directory of the project file.



Q1: User
Q2: Linux
Q3: More debugging features, More code analysis, Better APIs for CDT developers, Multi-core debugging

Details: I'm primarily a user, but also developing some extensions for our own development environment, so improved and extended CDT APIs, plus better documentation would be a big help.

As we'll be targetting multi-core processors, I'm also very interested in the ongoing work to add multi-core debugging.


Q1: Developer
Q2: Windows
Q3: Improvements to the UI and usability, Improvements to the user documentation, More Refactorings and Source generation, Better scalability and performance

Details: There are many bugs within the bug tracking system that are stale. I think a big push should be made to clean this up fixing what we can.

Improved code re factoring much like JDT would be a massive boost too.


Q1: Developer
Q2: Windows
Q3: Better stability, Better scalability and performance

Details: Focus on bug fixing and stability. Bugs are often open for many years, and still not being fixed.


Q1: User
Q2: Linux
Q3: More code analysis, Better scalability and performance

Details: Code analysis: In my experience code analysis is pretty fragile and un-debuggable - I often get unresolved symbols although the project compiles just fine. At the same time, it seems impossible to find out _which_ parts of my code makes problems, it says N syntax errors, M unresolved names, but how do I find out which ones?

Performance: I'd like to see less memory usage.


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation

Details: generating definitions in "non-standard" source files. Once created, declaration and definition should be synchronized. "non-standard" means, I have my headers in a different location than the source files; I sometimes use multiple source files to implement the declarations of one header file (e.g. for better code encapsulation) even across projects.


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation, More code analysis, Better stability, Better scalability and performance

Details: Performance needs improvement.


Q1: Developer
Q2: Linux
Q3: Improvements to the UI and usability, Better APIs for CDT developers, Better documentation in CDT code

Details:

  • Improvements to the UI and usability
    • Refactoring the UI to improve its behavior and remove unnecessary icons / buttons / short cuts.
  • Better APIs for CDT developers
    • Prodive more API avoiding dealing with internal classes when customizing some feature;
  • Better documentation in CDT code
    • Current documentation is deprecated. We can't find usefull information about new features and how to implement or change this ones.

Q1: User
Q2: Linux
Q3: Improvements to the UI and usability, Improvements to the user documentation, Integration with other build systems, Integration with other compilers, Integration with other debuggers, More Refactorings and Source generation, More debugging features, Improvements to the build system, Improvements to the editor and source navigation, More code analysis, Better APIs for CDT developers, Better documentation in CDT code, Better stability, Better scalability and performance

Details: All of the above


Q1: Developer
Q2: Linux
Q3: More Refactorings and Source generation, Improvements to the editor and source navigation, Better scalability and performance

Details: I would like CDT to assist me in coding as much as JDT does so improvements to editor and new refactorings would be good. Faster indexing would be nice to (multi-threaded, multiple databases for multiple configurations).


Q1: Developer
Q2: Linux
Q3: Improvements to the build system, Bug fixes (stability, broken features, etc), Better scalability and performance

Details: Scalability when building a project with many dependent projects would be nice. I support some users with 1 master project and over 100 libraries it depends on. When you build the master project after a one line change it takes 2 minutes to build all the dependencies (and do nothing on each of them) compared to <15 seconds from the command line.


Q1: Developer
Q2: windows and linux (50-50 split)
Q3: Bug fixes (stability, broken features, etc), Better scalability and performance, less last-minute issues

Details: Big and noticeable performance improvement over current code analysis feature, instead of any more functional enhancement code analysis.

Zero brokeage of APIs.

Complete (aka 100%) test coverage of CDT code before it gets released, not only 100% pass rate of current test cases.


Q1: User
Q2: Windows
Q3: Improvements to the user documentation, Integration with other debuggers, Bug fixes (stability, broken features, etc), Better scalability and performance, Simplify integration with other debuggers

Details:

  • "Improvements to the user documentation" - CDT documentation is really outdated! There's a lot of pages in C/C++ project settings that have no built-in help, and there's no way to know what these settings are affecting
  • "Integration with other debuggers" and "Simplify integration with other debuggers" - It would be great to have some straightforward flow for integrating new debuggers. I'd write integration plugin myself, but I cannot find even where to start!
  • "Bug fixes" - please fix the long-lasting issues before adding new features
  • "Better scalability and performance" - mostly applicable to Indexer performance. It would be great to have some explanation on it's memory usage. Right now it's unclear how much memory should I provide to indexer, is it starving on memory, or is it fine?

Q1: Developer
Q2: Mac OS X
Q3: Better APIs for CDT developers, Better documentation in CDT code, Bug fixes (stability, broken features, etc)

Details: Improved support for embedded systems debugging. For example, being able to specify the memory access size in the various memory views (currently it always reads/write bytes)


Q1: User
Q2: Linux
Q3: Improvements to the editor and source navigation, Bug fixes (stability, broken features, etc), Better scalability and performance, Indexer

Details: Indexer functionality and the most important: performance performance and again performance !!! :-)


Q1: Developer
Q2: Windows
Q3: Improvements to the UI and usability, More Refactorings and Source generation, More code analysis, Better APIs for CDT developers, Bug fixes (stability, broken features, etc), Better scalability and performance

Details: none


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation, Better APIs for CDT developers, Better documentation in CDT code

Details: Looking for better documentation for CDT API in particular about AST manipulations for refactoring.


Q1: Developer
Q2: Linux
Q3: Integration with other build systems, More Refactorings and Source generation

Details: Build system: cmake


Q1: User
Q2: Linux
Q3: More debugging features, Bug fixes (stability, broken features, etc)

Details: Debugger is very unstable, very often it is unable to show current values of variables or expressions.


Q1: Developer
Q2: Linux
Q3: Improvements to the UI and usability, Better APIs for CDT developers, Stop being a hostage of the Eclipse4

Details: Eclipse4 was not made for IDEs - it was made by consultants to sell books on modeling. CDT is one of the victims that takes all the blame for the UI regressions (I see debug toolbar put to the right of the perspective switcher on my system (Mac OS X) and on our intern system (Linux/64). Man up and fork Eclipse3! :)


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation, More code analysis, Better support for C++11/C++14 language features

Details: I'd love to see "Generate method stub from usage" and "generate class from usage" quick fixes. They're great for Test Driven Development or Programming By Intention, where you first use a concept and then based on how you use it, you create it just to fit those usage needs.


Q1: User
Q2: Linux
Q3: Improvements to the UI and usability, More debugging features, Bug fixes (stability, broken features, etc), Better support for C++11/C++14 language features

Details: CDT should not fall behind


Q1: Developer
Q2: Linux
Q3: Improvements to the UI and usability, Improvements to the user documentation, Integration with other build systems, More Refactorings and Source generation, More debugging features, Improvements to the build system, Improvements to the editor and source navigation, More code analysis

Details: Make it easier to import existing projects into CDT. CMake integration would be nice for the whole KDE community.


Q1: User
Q2: Linux
Q3: Improvements to the UI and usability, Improvements to the user documentation, More debugging features, Improvements to the build system, Improvements to the editor and source navigation, More code analysis

Details: Profiler Integration


Q1: User
Q2: Mac OS X
Q3: Objective C

Details: For OSX and ios development


Q1: User
Q2: Linux
Q3: Integration with other build systems, Integration with other compilers, Integration with other debuggers, Better support for C++11/C++14 language features

Details: Better integration of Microsoft tools, to make CDT usable on Windows at all


Q1: Developer
Q2: Windows
Q3: Bug fixes (stability, broken features, etc), Better scalability and performance, Improvements to the Indexer

Details: Indexer Weakness: https://bugs.eclipse.org/bugs/show_bug.cgi?id=376077

Uncustomizable CDT preference: https://bugs.eclipse.org/bugs/show_bug.cgi?id=374620

Comment Formatting: https://bugs.eclipse.org/bugs/show_bug.cgi?id=182973

Format on Save: https://bugs.eclipse.org/bugs/show_bug.cgi?id=241355

Create linked file using template: https://bugs.eclipse.org/bugs/show_bug.cgi?id=329422


Q1: User
Q2: Linux
Q3: Improvements to the UI and usability, Integration with other build systems, Integration with other compilers, Improvements to the build system, Better scalability and performance, Better support for C++11/C++14 language features

Details: Better support for cmake would be great

An easier switching between compilers (gcc, clang, icc) would also be very helpful

Also Eclipse/CDT still feels slow, even on a very powerful machine (but might be a problem of eclipse or Java in general, not sure if CDT can do much about this).


Q1: User
Q2: Windows
Q3: Integration with other compilers, More code analysis, Better scalability and performance, Objective-C support

Details: Official support for clang


Q1: User
Q2: Linux
Q3: Integration with other debuggers, Improvements to the editor and source navigation

Details: Add Qt/QML source code editor; support for debugging QML alongside native C++ code.


Q1: User
Q2: Linux
Q3: Integration with other build systems, More Refactorings and Source generation, Improvements to the editor and source navigation, More code analysis, Bug fixes (stability, broken features, etc), Better scalability and performance

Details: Add support for CMake projects.


Q1: User
Q2: Windows
Q3: Integration with other build systems, Integration with other compilers, Integration with other debuggers, More Refactorings and Source generation, More debugging features, Improvements to the build system, More code analysis, Bug fixes (stability, broken features, etc), Better scalability and performance

Details: Cmake


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation, More code analysis

Details: Generate setters and getters. Find more bugs with static analysis.


Q1: User
Q2: Windows
Q3: Integration with other build systems, More Refactorings and Source generation, More code analysis, Better support for C++11/C++14 language features

Details: should work at least as well with any project with a makefile as java tooling does with a pom


Q1: Developer
Q2: Linux
Q3: Improvements to the UI and usability, Improvements to the build system, Better APIs for CDT developers, Bug fixes (stability, broken features, etc)

Details: Managed make!


Q1: User
Q2: Linux
Q3: Improvements to the UI and usability, More Refactorings and Source generation, Improvements to the build system, Better support for C++11/C++14 language features

Details: test


Q1: User
Q2: Windows
Q3: Improvements to the build system, Improved Makefile analysis

Details: My career history has been filled with companies which create complex/convoluted Makefile-based projects with custom mixture of toolchains, and follow no standards (and produce no documentation for their own "standards"). Additional tools to consume those files and can reveal that complexity would be sincerely appreciated.

Thank you for the excellent work with CDT!


Q1: User
Q2: Windows
Q3: Integration with other build systems, Integration with other compilers, Integration with other debuggers

Details:

  • CLang
  • cmake

Q1: User
Q2: Linux
Q3: More Refactorings and Source generation, Improvements to the editor and source navigation, Better scalability and performance, Better support for C++11/C++14 language features

Details: .


Q1: User
Q2: Windows
Q3: Improvements to the UI and usability, Improvements to the user documentation, More code analysis

Details: Some right-click context menus have gotten too big to navigate easily. We could really use better organization or a different solution here.

More emphasis on the code analysis tools would be good. Still see hiccups when they try to parse templates. I'd like to see them as "in your face" on the toolbar as the Build All button. Remind me and my team to use them. It may not be PC-LINT, but it still has very valuable coverage.


Q1: User
Q2: Linux
Q3: Improvements to the user documentation, Better support for C++11/C++14 language features

Details: I think the documentation needs additional details on how to get CDT working with different tools. Specifically, getting CDT working on Windows is a continual question on the forum. Some specific examples of what needs to be set where if CDT can't find cgwin or mingw would be helpful.

Getting the Indexer and Codan setup for recognizing C++11 is a tricky proposition. There needs to be an option on the project properties to just tick a check box for C++11 support.


Q1: User
Q2: Linux
Q3: Improvements to the UI and usability, More code analysis, Bug fixes (stability, broken features, etc), Better support for C++11/C++14 language features

Details: In general the CDT is great, I think it is far and away the best open source C/C++ dev environment. However, I think the overall experience is just less polished than the Eclipse Java development. There are obvious reasons (e.g. Eclipse is written in Java, Java is easier to parse, etc) but I guess at this point I would like to see a focus on polish rather than adding features.


Q1: User
Q2: Windows
Q3: Integration with other build systems, Improvements to the build system, Better scalability and performance

Details: cmake


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation

Details: It would be great to have one day some of the refactorings that the Java Eclipse has. Anyway, thank you very much for developing CDT. Best regards


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation, Improvements to the editor and source navigation, More code analysis, Better scalability and performance, Better support for C++11/C++14 language features

Details: Nothing else....


Q1: Developer
Q2: Mac OS X
Q3: Improvements to the user documentation, More Refactorings and Source generation, More code analysis, Better documentation in CDT code, Bug fixes (stability, broken features, etc)

Details: nope


Q1: User
Q2: Linux
Q3: Integration with other build systems, Better support for C++11/C++14 language features

Details: CMake. CMake can generate eclipse projects but it is very awkward. Ideally it would be a bit more streamlined. Specifically I cant seem to generate a project outside of the source tree, and when i do in a child of the source tree it doesn't let me use eclipse's built in version control very easily.

Basically, my code compiles. Eclipse forever tells me it does not. No amount to tweaking discovery flags, indexer options, etc seems to make it understand auto, shared_ptr, or any other c++11 stuff.


Q1: User
Q2: Windows
Q3: Improvements to the UI and usability, Improvements to the user documentation, Improvements to the editor and source navigation, Bug fixes (stability, broken features, etc)

Details: Sorry, no further comments


Q1: User
Q2: Linux
Q3: Integration with other build systems, More Refactorings and Source generation, Improvements to the editor and source navigation, Bug fixes (stability, broken features, etc), Better scalability and performance

Details: Better integration with CMake.


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation, Improvements to the editor and source navigation, Better APIs for CDT developers, Better documentation in CDT code, Better support for C++11/C++14 language features

Details: .


Q1: Developer
Q2: Windows
Q3: Improvements to the UI and usability, Integration with other build systems, Integration with other compilers, Integration with other debuggers, More Refactorings and Source generation, More debugging features, Improvements to the editor and source navigation, More code analysis, Better APIs for CDT developers, Better documentation in CDT code, Bug fixes (stability, broken features, etc), Better scalability and performance, Better support for C++11/C++14 language features

Details: ninja, msbuild


Q1: User
Q2: Linux
Q3: More debugging features

Details: The debugger hover window needs some improvement:

  • remember the size of the hover window.
  • allow to customize the the content. At the moment it shows the following for a std::string containing two lines:

Name : myString Details:""line 1\nline 2"" Default:""line 1\nline 2"" Decimal:""line 1\nline 2"" Hex:""line 1\nline 2"" Binary:""line 1\nline 2"" Octal:""line 1\nline 2""

it should be possible to replace the \n with a newline and to hide some interpretations (Octal, ...).


Q1: Developer
Q2: Windows
Q3: Improvements to the UI and usability, Integration with other compilers, Integration with other debuggers, More Refactorings and Source generation, More debugging features, Better APIs for CDT developers, Bug fixes (stability, broken features, etc), Better scalability and performance

Details:


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation

Details: Allow refactorings on incomplete or non-compiling code (as far as possible).


Q1: User
Q2: Linux
Q3: Improvements to the UI and usability, More debugging features, Improvements to the editor and source navigation, More code analysis, Bug fixes (stability, broken features, etc), Better scalability and performance

Details:


Q1: Developer
Q2: Windows
Q3: Improvements to the user documentation, Improvements to the editor and source navigation, Better APIs for CDT developers, Better documentation in CDT code

Details: I am using CDT as a user/developer for quite some time now. What really bothers me is the lack of documentation.


Q1: User
Q2: Linux
Q3: Improvements to the UI and usability, Integration with other build systems, Bug fixes (stability, broken features, etc), Better support for C++11/C++14 language features

Details: Make it easier to work with CMake out-of-source builds. Also take include paths from CMake

Support for Qt style camel case headers without a file extension


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation, More debugging features, Bug fixes (stability, broken features, etc), Better scalability and performance, Better support for C++11/C++14 language features

Details: MORE STABILITY


Q1: User
Q2: Windows
Q3: Improvements to the UI and usability, Improvements to the user documentation, Integration with other build systems, Integration with other compilers, Integration with other debuggers, More Refactorings and Source generation, More debugging features, Improvements to the build system, Improvements to the editor and source navigation, More code analysis

Details: makepp


Q1: User
Q2: Windows
Q3: Improvements to the UI and usability, Improvements to the user documentation, Integration with other build systems, More Refactorings and Source generation, More debugging features, More code analysis, Bug fixes (stability, broken features, etc), Better scalability and performance, more support for C (C11, test frameworks, refactoring)

Details:

  • UI - e.g. Add Include Paths like when importing (tree with checkboxes = multiple selection)
  • Debugging/UI - e.g. multiple Expression/Watch Windows, Show arrays as graphs (look at Lauterbach debugger)
  • Split Editor support
  • Search features in context menu item should only show results for the project and not the whole workspace (e.g. ""Open Call Hierarchy"" etc.), or provide a button for this, instead of creating and switching through ""working sets""
  • Easier support for C externsions
  • Easier support for Assembler and Inline Assembler (maybe by adding through an config file similar to Ultraedit Wordfiles?)
  • Editor support for AUTOSAR like declarations, including Source Formatting/Indent fixes (e.g. FUNC(void, MY_CODE) foo( P2VAR(uint8, AUTOMATIC) arg1))
  • More support for refactorings and testframeworks for plain ANSI/ISO C (without using C++) e.g. check, cunit etc.
  • Support for Build systems like scons, waf, rake

Q1: User
Q2: Linux
Q3: Improvements to the user documentation, More Refactorings and Source generation, Improvements to the editor and source navigation, More code analysis, Better scalability and performance, Better support for C++11/C++14 language features

Details: -


Q1: Developer
Q2: Linux
Q3: Improvements to the UI and usability, Integration with other build systems

Details: cmake, qmake


Q1: User
Q2: Windows
Q3: Integration with other build systems, More Refactorings and Source generation, More debugging features, Better support for C++11/C++14 language features

Details: I work on embedded systems, so integration with build tools and debuggers are very important.


Q1: User
Q2: Windows
Q3: More Refactorings and Source generation, Improvements to the editor and source navigation, More code analysis, Better support for C++11/C++14 language features

Details: .


Q1: Developer
Q2: Linux
Q3: More debugging features, Better support for C++11/C++14 language features, JNI debugging support PLX

Details: It'd be nice to have "seamless" integration of JAVA => JNI => C++ breakpoints.


Q1: User
Q2: Windows
Q3: Improvements to the UI and usability, Integration with other debuggers, More debugging features, Bug fixes (stability, broken features, etc), Debugging C++ in Eclipse completly sucks when compared to MSVC.

Details: Integration with CMake like KDevelop is trying to do.


Q1: Developer
Q2: Windows
Q3: Improvements to the UI and usability, Improvements to the user documentation, More debugging features, Improvements to the editor and source navigation, Better APIs for CDT developers, Better documentation in CDT code, Bug fixes (stability, broken features, etc)

Details: More and better documentation of DSF APIs and internal code.


Q1: Developer
Q2: Windows
Q3: More Refactorings and Source generation, Improvements to the editor and source navigation, More code analysis, Better documentation in CDT code, Bug fixes (stability, broken features, etc)

Details: More refactoring possibilities for the C language. E.g. http://dev.eclipse.org/mhonarc/lists/cdt-dev/msg25890.html

Additional codan checkers for the C language and better documentation on DOM AST and codan.

Ideas for checkers:

  • buffer over/under indexing:
  uint8_t buffer[100]; buffer[200]; <-- error
  • missing guard macro from header files:
  1. ifdef GUARD
  2. define GUARD

--> place code only inside

  1. endif
  • find unused header file includes
  • find same symbol names within one compilation unit on different scopes
  • find undocumented APIs (doxygen documentation blocks for function implementation or prototype)

and so on...

Thanks!


Q1: User
Q2: Linux
Q3: Improvements to the UI and usability, More Refactorings and Source generation, More debugging features, Improvements to the editor and source navigation, More code analysis, Better scalability and performance

Details: Faster startup speed, better code indexing performance and intelligent code assistant.


Q1: User
Q2: Windows
Q3: Bug fixes (stability, broken features, etc), Better scalability and performance, Better support for C++11/C++14 language features

Details: Better stability and incresed speed of basic suff (starting Eclipse, opening/closing a project, opening a file, indexing, jumping around), would be the main attractors for using Eclipse more on our workfloor.


Q1: User
Q2: Linux
Q3: More Refactorings and Source generation, Improvements to the build system, Improvements to the editor and source navigation, More code analysis, Better documentation in CDT code, Better scalability and performance

Details: Ctrl-B often doesn't trigger the build. Pressing it a second time opens a dialog box asking if you want to stop the build that's already in progress. Please fix. Provide code assist when using STL.


Q1: User
Q2: Windows
Q3: Integration with other build systems, Integration with other debuggers, More Refactorings and Source generation, More debugging features, Better support for C++11/C++14 language features

Details: Integration with other debuggers: MSVC Debugger


Q1: User
Q2: Windows
Q3: More Refactorings and Source generation, More code analysis, Bug fixes (stability, broken features, etc), Better scalability and performance

Details: More refactoring support would be great.


Q1: User
Q2: Linux
Q3: Improvements to the editor and source navigation, More code analysis, Bug fixes (stability, broken features, etc), Better scalability and performance, Better support for C++11/C++14 language features

Details: better performance in indexing large codebases, lower memory usage


Q1: Developer
Q2: Windows
Q3: Improvements to the UI and usability, Bug fixes (stability, broken features, etc)

Details: Having a flawless indexer experience....


Q1: Developer
Q2: Linux
Q3: Improvements to the user documentation, More Refactorings and Source generation, More debugging features, Improvements to the editor and source navigation, More code analysis, Better APIs for CDT developers, Better documentation in CDT code, Bug fixes (stability, broken features, etc)

Details: Documentation is something that is really missing in CDT, even in the source files. When searching for particular classes it is sometimes very difficult to figure out which one is the relevant one. If possible, please make it easier for plug-in developers to understand and use the CDT APIs.


Q1: Developer
Q2: Windows
Q3: Bug fixes (stability, broken features, etc), Better scalability and performance

Details: Trying to fix more open bugzilla entries, especially those related to "stability" and scalability/performance


Q1: Developer
Q2: Linux
Q3: Improvements to the user documentation, Bug fixes (stability, broken features, etc)

Details: Generally focus on polishing existing features rather than adding new ones.


Q1: Developer
Q2: Linux
Q3: Improvements to the UI and usability, Improvements to the user documentation, Integration with other compilers, Better documentation in CDT code, Bug fixes (stability, broken features, etc)

Details: llvm integration would be nice, then a number of outstanding issues already in bugzilla should be examined, and the documentation. :)


Q1: User
Q2: Linux
Q3: Integration with other build systems, Integration with other compilers, Integration with other debuggers, Better support for C++11/C++14 language features

Details: Clang


Q1: User
Q2: Linux
Q3: Integration with other build systems, Integration with other compilers, Improvements to the build system, Better scalability and performance

Details:

  • It would be fine if there was a msbuild like tool, that could read the .cprojectfiles and run the compiler, without importing a workspace and the whole eclipse process in the background.
  • maven or cmake support would be fine as well
  • the compilation process is very slow copmared to the same project beeing compiled from the shell, even with same makefiles
  • we have an external tool producing emma files for coverage analysis, if we could integrate that like in the java projects that would be awesome