[advocaat23]

I had a look at the video and it really seams nice, but for me the cost (learning yet another tool, integrating it into your workflow, dependance on yet another big-size software project) is too high.

The fancy stuff they show you are in my opinion just short-comings of C++ [activate flame-war prevention system] or not THAT important in development. E.g.

- implementing getters/setters: just make the thing public, the whole private/public bullshit is too shallow

- implementing methods: inheritance is normally used with caution and is just a small part of your application (e.g. a core that uses it); you will think about getting this abstraction right (your inheritance tree) and the time it needs typing the text to implement the methods is often small in comparison to the thinking over inheritance.

- completion: IMHO there are different modes you are in, while coding: (0) prototyping (researching the problem, reading API documentation) and (1) implementing a robust solution; In the first case, again, the time it takes you is more constrained by the thinking you do, and in the second case you probably know the API and important functions already (from the previous step) so the auto-complete is not needed anymore.

The coolest thing is the renaming which really might help you tackle one of the hardest CS things (naming things). Furthermore I would not use the Shape example as it is too far fetched from reality. It's like the "let's implement fibonacci numbers" in the FP world. And how do they manage "Makefile" only projects?

[shadowmint]

Sounds like you've never used a jet brains product before. Seriously, it's worth a download just to play with even if you only do it for ten minutes and then throw it away.

You may be surprised at how much of a productivity boost it is (and yes, intelliJ can be slow; but it's nothing like as rubbish as visual studio).

[gchp]

I use PyCharm quite a bit, and I find it great. To me though slowness is a big issue. I often switch back and forth to vim, and occasionally find the slowness of pycharm quite jarring. Had I not been using vim, perhaps I would not have noticed, but it does have quite an impact at first.

Their autocomplete is second to none, however. And once that has parsed the codebase it is lightning fast. Definitely recommend giving it a try.

[philjohn]

I was suffering slowness in PHPStorm, but I've disabled all of the plugins that I wasn't using (mostly things like support for frameworks I don't use) and it's now much more responsive.

[x0x0]

more ram (and make sure the jvm is allowed to use it)

Deep inside I wonder if the ram usage isn't wasteful, but then I use "find usages" in a medium sized python codebase and I'm just happy pycharms saved me 30+ minutes of poking through code. I found it a big productivity boost.

[pionar]

> and in the second case you probably know the API and important functions already (from the previous step) so the auto-complete is not needed anymore.

I don't know about you, but I don't memorize functions/classes when I program. I don't always remember proper capitalization (is it HttpClient or HTTPClient?)

[anastasiak2512]

Makefiles are not supported yet. But we plan to: http://youtrack.jetbrains.com/issue/CPP-274

[lmedinas]

Eclipse CDT project import is also planned ? What about remote debugging ?

[anastasiak2512]

Remote things are in plans after 1.0 release: http://youtrack.jetbrains.com/issue/CPP-744

As for the Eclipse we don't have such requests but may consider if it becomes popular.

[squeaky-clean]

>IMHO there are different modes you are in, while coding: (0) prototyping (researching the problem, reading API documentation) and (1) implementing a robust solution; In the first case, again, the time it takes you is more constrained by the thinking you do, and in the second case you probably know the API and important functions already (from the previous step) so the auto-complete is not needed anymore.

I find in the first case, I can be much faster when I can just think. Instead of having to switch mental contexts between "What's my logical process" and "How does that translate specifically into this language/framework/whatever." A simple example is if I want to iterate through every item in a container, I'd like to just type 'for', tab, the first few letters of the container variable, tab, and have it all set up. Resharper does this, and will even name things appropriately for you (if the container is something like myInts or intList, it will name the item myInt).

I used to do most of my planning on paper, or in a text file for this reason. But it's much nicer to be able to merge planning and coding as early as possible.

In your second case, well (1), maybe this is true for you and others. But not for everyone, myself included. I have a pretty poor memory for specifics. Is it myList.length(), myList.length, myList.Count, len(myList), count(myList)? On top of this, every one of the previous examples is valid in a language or framework I use at least on a weekly basis, if not daily. I may be doing python and javascript all day at work, then go home to work on a game in C++. It leads to a lot of confusion. (And about 30 minutes until I remember I need to use brackets and double quotes again, haha).

Everyone has their own ideal purpose of an IDE, and JetBrain's goals are pretty much in line with what I want. I agree that many of the fancy features they show off are just getting around the short-comings of C++. But to me, that is the point. I like the IDE to remove the actual "coding" aspect as much as possible. Allow me to think through the logic and control flow. Not whether the current item has to be dereferenced or not. Let me think of the actual data structure, and not whether it needs to be called .push_back() or .append() or .add().

[advocaat23]

>A simple example is if I want to iterate through every item in a container, I'd like to just type 'for', tab, the first few letters of the container variable, tab, and have it all set up. Resharper does this, and will even name things appropriately for you (if the container is something like myInts or intList, it will name the item myInt).

Yeah, but e.g. in C++ there are many styles of for-loops. How does the IDE find out what you want to do? Different projects adopt different for styles (size_t, iterators, etc.).

>Is it myList.length(), myList.length, myList.Count, len(myList), count(myList)?

That's a legitimate question, but how does your IDE help there? I solve the problem using a

"<language> get length of list"

web-search. Can your IDE answer this question? If I just type

myList.

I will get usually a drop-down menu of all the methods. But then I have to try "c" for count, "l" for length, etc. In particular I have to assume that the size function is a method which is the case in Java, C++, but e.g. not in Python. Or does JetBrains Python version (PyCharm I think) rewrite a.length to len(a)?

My main IDE complaint is that IDEs lock you into languages, libraries and workflows. If you work with a text editor your have to know

  - the language
  - the text editor
  - your build system
  - your version control system

If you work with an IDE you have to know

  - the language
  - a text editor (e.g. remote sessions without X)
  - the build system
  - the version control software
  - the ide
  - probably a plugin that makes your ide editor behave like your text editor
  - a plugin for your language
  - a plugin for you build system
  - in general: how does the IDE's plugin system work

So I like the idea of IDEs, but for me the abstraction always fails and I struggle with its plugins. I give them a try sometimes but most of them are locked into eco-systems:

  - qtcreator: QT, C++
  - eclipse: Java
  - netbeans: Java
  - PyCharm: Python
  - Clion: C/C++

If you work with different languages, libaries and workflows it is often not trivial to make the IDE adapt (in particular, most of them have their own definition of "projects" and scatter you directory trees with hidden files) and the whole dev-setup gets more complicated. What do you do if you have to use a language that's not supported by the IDE?

The text editor abstraction feels more honest: "Look your project is a bunch of text files. I give you the following interface to explore/change this text blobs." Again, I like the idea, but good IDEs were always locked into eco-systems and these change so fast that the IDE seems always behind. I think Smalltalk had an advanced IDE but it locked you into ... Smalltalk.

[pjmlp]

eclipse: Java, Scala, Clojure, C, C++, Ada, D, OCaml, Haskell, ...

Netbeans: Java, C, C++, PHP, Ruby, Groovy, ...

> I think Smalltalk had an advanced IDE but it locked you into ... Smalltalk.

Which shows you never used it.

Smalltalk is an environment. Workstation OS, IDE, REPL and programming language.

Only the whole experience is gratifying.

Same goes to Interlisp-D, Mesa/Cedar, Lisp Machines and Oberon systems. All Workstation OSs that mix all these concepts together.

UNIX developer experience might sound great, but only for those that never had the experience to touch such systems.

[advocaat23]

It is true that there are systems (Lisp Machines, Oberon, Smalltalk, etc.) with a more integrated approach and there are great ideas, but what I meant with the term "IDE" is classic IDEs on Windows, Linux and OSX. These OSs are heavily UNIX influenced and for those systems I consider text tools (editors, shells, command-line tools) the easier development UI.

[coldtea]

>I had a look at the video and it really seams nice, but for me the cost (learning yet another tool, integrating it into your workflow, dependance on yet another big-size software project) is too high.

Yeah, it's for people who doesn't ALREADY have a compelling solution to what it offers.

[surye]

Getters and setters are not just there to work around the visibility system. Just making everything public doesn't change the fact that C++ lacks properties, and you cannot change a concrete value into a calculated value without changing the API.

[kryptiskt]

Even if you know the API perfectly, and who does these days, autocomplete is still very useful so you don't have to type out clang::AbstractConditionalOperator, just to take the first identifier to catch my eye, every time.