DEV Community

Alex Fedorov
Alex Fedorov

Posted on

Why Are Some Developers so Allergic to IDEs?

Countless times I meet developers who prefer simpler editors. And by “prefer” I mean that they have strong negative feelings towards any IDEs, especially the ones that one needs to pay money for.

Now, it’s worth mentioning that my path through coding tools over the last 20 years went like this:

Notepad -> Turbo Pascal Editor -> Delphi -> Visual Studio -> Gedit -> Sublime Text -> Vim -> Emacs -> Emacs (Evil mode) -> Atom -> Vim -> IntelliJ Idea (settled for now).

The switch to IDE had happened when I attended a Software Craft meet-up. I’ve paired with another developer who’ve shown me something that looked like magic to me at a time.

Basically, I’ve felt doubts about the tooling of my choice, since this IDE that was in front of me (in the hands of an experienced user) could allow me to do development at a 5x-10x rate of what I could currently.

Now the question is: why do we, developers, feel such negative feelings towards a paid tool that can boost our productivity so much?

Let’s discuss!

Discussion (137)

Collapse
lampewebdev profile image
Michael "lampe" Lazarski

I used Eclipse, NetBeans and some form of IntelliJ.

And I'm always coming back to a more simple editor like Atom or VSCode.

I'm a web developer and usually, the extensions VSCode and other editors can give you are enough for me.

IDE's tend to be slow and don't add for me the value of having such a big monster installed on my machine.

IDE's feel more like they slow me down and are in my way instead of helping me get stuff done.

Maybe if you have a Java project or other languages where the IDE can be more helpful it makes sense.

It really depends on what field you are working on.

Collapse
waterlink profile image
Alex Fedorov Author • Edited on

I’m working always fullstack (no matter which stacks included), so often, I get to work with frontend (JS/TS/React or TS/Angular). I’ve worked in IntelliJ and VSCode, and I observed people working in IntelliJ and VSCode.

My three observations:

  • Manual import/export management in VSCode vs. automatic imports in IDE (expunging default exports fully contrary to community standard). Less time spent here.
  • Autocompletion in VSCode is dumber than autocompletion in IDE.
  • Refactorings in VSCode are almost non-existent and in IDE there are tons of them and they are safe (lead from GREEN test suite to GREEN test suite).

Now, you mentioned something about slow IDE. you probably didn’t increase the amount of RAM that you allow IDE to use. The default is just too small to index 20000+ npm packages and stay fast. I usually give 8-10GB to my IntelliJ Idea and it gives me back 5-10x boost of productivity because I rely on automated imports, smart completion, and refactorings all the time. Nice ROI. RAM is (supposed to be) cheap.

Collapse
lampewebdev profile image
Michael "lampe" Lazarski

I just have 8GB in total on my machine.

point 1 and 2 work great for me also in VSCode with the right plugins.

I just type something and then press tab and it will be imported.

I'm working on nodejs code and the autocompletion is pretty great

I just type spa and I get spawn or spawnSync and then I press enter and it imports the right thing from 'child_process'.

I would rather say that your problem is that you are having one project with 20000+ npm packages. I try to keep my services small.

This also helps with refactoring.

So yeah maybe if you're working on one big monolith app with a lot of dependencies everywhere it makes sense.

So yeah if your refactoring this amount of dependencies then for me something else is not correctly setup but yeah. No judgment here just guessing.

Thread Thread
waterlink profile image
Alex Fedorov Author

I would rather say that your problem is that you are having one project with 20000+ npm packages. I try to keep my services small.

Welcome to frontend ;)

Thread Thread
waterlink profile image
Alex Fedorov Author

You can get these numbers just when you bootstrap a new empty codebase…

Thread Thread
waterlink profile image
Alex Fedorov Author • Edited on

I’m not refactoring any of the NPM package dependencies. You’re too much focused on that. This is normal in frontend projects.

I’m talking about refactorings that I need to do in the normal course of the proper TDD workflow: write a failing test, make it pass with a simplest (but perhaps dirty) implementation, refactor to make the design cleaner, and then repeat over and over again.

It would be wonderful to be able to point to a YouTube (or Vimeo) video of half an hour of someone doing these amazing refactorings that one should do 20 times per hour as a part of normal development flow. It’s called continuous refactoring. But I don’t know of any at this moment. (maybe I should ask on Twitter if anybody has such a video)

Otherwise, it’s like we’re talking about different worlds.

Thread Thread
lampewebdev profile image
Michael "lampe" Lazarski

I'm doing frontend now for over 8 years ;)

Thread Thread
waterlink profile image
Alex Fedorov Author

And I do 7. A little bit less than you, I guess. In the past the proliferation of packages and dependencies was not as much…

Thread Thread
lampewebdev profile image
Michael "lampe" Lazarski

That's true.

I also try to prevent to load to much packages. When I can I just take the one functionality it of the package and just put it into the project ;)

Thread Thread
waterlink profile image
Alex Fedorov Author

That’s a good tactic :)

waterlink profile image
Alex Fedorov Author

I have 16GB on personal. And at work, I have 32GB. The cost of this RAM is much lower than the potential sacrifice of developer’s productivity.

Thread Thread
lampewebdev profile image
Michael "lampe" Lazarski

I mean this are all valid points but at the end people are different. So if it works for you good more power to you.

I just like to think first about the how I will do stuff. Even on paper and then execute. So maybe that's why I like normal editors more.

Thread Thread
waterlink profile image
Alex Fedorov Author

Makes sense!

Collapse
qm3ster profile image
Mihail Malo

Not sure when you last tried it, but for me VSCode works very well in terms of TypeScript refactorings. And the autocompletion is great.
What specifically did you find lacking?
An example of a refactor would be perfect.

I will be honest, I don't understand the first point at all. What does "expunging default exports fully contrary to community standard" mean? There are automatic import features in VSCode, but I don't use them. I don't find that any sort of automatic import management to be a productivity improvement.

Collapse
sudiukil profile image
Quentin Sonrel • Edited on

I personally dislike IDEs. Or more precisely, I dislike using them. I don't dislike all IDEs in every single case but as a general rule I can say I prefer coding without one. My main reasons are:

  1. They feel bloated. Every time I use one I feel drowned by all the features and settings and the thousands checkboxes everywhere. All those things are sometimes so overwhelming that I end up being less productive with an IDE than without.

  2. Configuration and habit. There is no perfect IDE that can do everything and each IDE is different from the other. And I don't like that. I'm willing to learn a lot of different things when it comes to languages and techs, but when it comes to tools, I want to learn and configure one thing right and be done with it. No IDE can offer me that, but editors can, at the cost of a few features.

  3. I don't need one. IDEs offer a lot of features but sometimes you gotta keep things simple. When I code, the only thing I care about is how clean my code is and where I did mistakes. For the former there are linters, most linters work on most editors, no need for an IDE. For the latter, the language compiler/interpreter does this job, again, no IDE is needed. And that's all I need. I don't need (nor want) autocompletion, integral VCS integration, etc...

  4. They are bottom-less pits in terms of resource. Vim (with my config and plugins) runs everywhere I want to, from my shitty laptop to my remote server. IDEs don't. They are just eating my RAM and CPU away. I don't always work on a powerful desktop and when I don't IDEs are really painful to use.

Now, as I said, in some cases I use an IDE. When I do Java is a good example. Java and the typical Java processes and environments are something I'm not very fond of and that I'm not willing to learn too deeply (because I do Java only when I have to). So in that precise case, I enjoy using Intellij IDEA which is the only IDE I can tolerate. And I'm familiar with it from my Android Studio days. But beyond that, it still features a lot of the things I dislike about IDEs.

Collapse
waterlink profile image
Alex Fedorov Author

On point 1:

I agree with you, the learning curve is slow in that regard. Find action/find everything helps a lot to discover just the things you need right now. Also, no-mouse challenge helps tremendously.

On point 2:

I use IntelliJ Idea basically for the following list of technologies (and much more is possible):

  • Java/Kotlin for Backend/Android;
  • Javascript/ES6/Typescript for Backend/Frontend;
  • Python and Ruby for Scripting/Backend;
  • Objective-C/Swift for MacOS/iOS;
  • Golang for CLI/high-performance-backend.

On point 3:

How do you refactor? How often? What kind of refactoring you do? How much time does it take?

By the way, continuous refactoring is the best way I know to keep code clean. And linters won’t help you with software design and architecture of your application.

On point 4:

Depends on your ROI. I put 8-10GB of RAM into IntelliJ, and I get 5-10x developer productivity boost because I refactor and transform code all the time, instead of typing it too much. Saves me time, and protects me from RSI syndrome. I think this is a great deal. RAM is cheap.

On the final point, you should try to use IntelliJ with other languages that you use. It works great for the ones I listed above (and +some).

Collapse
sudiukil profile image
Quentin Sonrel

How do you refactor? How often? What kind of refactoring you do? How much time does it take?

I refactor by hand, that's how I actually learn how to do good code by myself, I don't need an IDE to tell me what to do.

By the way, continuous refactoring is the best way I know to keep code clean.

Indeed, but you don't need an IDE for that, just some common sense and knowledge. People did good code before IDEs even existed.

And linters won’t help you with software design and architecture of your application.

Even so, IDEs don't bring anything new to the table, they are just an aggregation of tools and good practices you can use/apply via other means/by yourself.

Depends on your ROI. I put 8-10GB of RAM into IntelliJ

10Go is what I allocate to the Virtual Machine I work with daily. 10Go for an editing program is simply insane, no desktop software should take as much. Ever.

RAM is cheap

That's irrelevant, I work with the hardware I'm given, I don't buy nor choose what's in my enterprise computer.
(And actually, RAM pricing is through the roof since several months, so "cheap" might be relative)

On the final point, you should try to use IntelliJ with other languages that you use

I just explained why I don't. I'm not trying to convince you of anything, just stating why I personally don't like IDEs. I've been coding for nearly 10 years and tried several and always preferred editors over IDEs, I think it's pretty safe to say it works pretty well for me.

Thread Thread
waterlink profile image
Alex Fedorov Author • Edited on

I refactor by hand, that's how I actually learn how to do good code by myself, I don't need an IDE to tell me what to do.

I don’t let my IDE tell me what refactoring to perform too. In fact—it doesn’t have such a feature.

It only automates what I would otherwise have done by hand. And it’s faster this way after you already learned about the refactoring and can do it by hand.

Especially, it’s quite good when you want to perform a complex refactoring that consists of 10-15 simpler refactoring steps, you have two choices:

  • write the new code and remove the old code,
  • perform each single simple refactoring step in a sequence.

With a simple editor, I’d be skewed towards the first option. The problem is that this would cease to be a refactoring by definition of the word refactoring. It’s going to be a rewrite, and it can lead to small hard-to-notice mistakes that will leave me debugging for minutes/hours.

With IDE, I’d be skewed towards the second option, because it’s easy to perform these simple steps—they are at the tips of your fingers. And this would be a true refactoring because it performs small simple steps that go from one GREEN step to another GREEN step. The likelihood to need debugging after such refactoring goes down to ~zero.

I just explained why I don't. I'm not trying to convince you of anything, just stating why I personally don't like IDEs. I've been coding for nearly 10 years and tried several and always preferred editors over IDEs, I think it's pretty safe to say it works pretty well for me.

Sure, no problem. I think my original question is imbuing too many assumptions about refactoring and how people (should) program. With these assumptions, it just doesn’t make sense to not use IDEs when they are present.

Maybe I ought to ask questions about how people program first :)

Thread Thread
sudiukil profile image
Quentin Sonrel

Maybe I ought to ask questions about how people program first :)

Your question was ok (and I hope my answers didn't seem too... curtly, I just tried to be concise) but these kind of things are indeed related to how people code more than just whether or not IDEs are good and why (because they are of course, they are awesome tools).

Also, even though IDEs can indeed increase productivity, that's a relative thing. Some will get a huge productivity boost, some others won't (for various reasons). The fact is: most people who code are also passionate about it, so they need to actually enjoy it. I know I enjoy more coding with my preferred editor rather than IDE and I want to keep it that way simply for the sake of it, I don't care about the potential (and most likely small) productivity loss.

Thread Thread
waterlink profile image
Alex Fedorov Author

Also, even though IDEs can indeed increase productivity, that's a relative thing. Some will get a huge productivity boost, some others won't (for various reasons). The fact is: most people who code are also passionate about it, so they need to actually enjoy it. I know I enjoy more coding with my preferred editor rather than IDE and I want to keep it that way simply for the sake of it, I don't care about the potential (and most likely small) productivity loss.

Thank you for reminding about this!

Everyone is passionate about their own things. My passions force me to find ever-more efficient, cleaner and successful ways to develop high-quality software. This is what brings me joy.

Others find joy in other things. Very well, thank you, I’ll keep this in mind.

Collapse
hamatti profile image
Juha-Matti Santala

I think IDEs are often an overkill. If I'm building something small, I don't need a heavy IDE. If I'm building something larger, I prefer using the same tools I do for smaller ones because I have learned them.

I also like an Unix-like philosophy of small tools that do one thing well and then I get to combine my toolchain from different tools based on my preferences. And I prefer to run my apps, commands, tests, etc from the command line because they then integrate nicely with other command line tools.

Sure, both my Vim and VS Code are heavily customized and extended with extensions and plugins. But that's the way I love it: I'll only have things I need and piece by piece I can make it better. Instead of having a large thing that does everything but makes small things sometimes hard.

Collapse
hamatti profile image
Juha-Matti Santala

Another reason that came to mind from reading other people's replies: I do programming in many languages. I do Typescript, Javascript, PHP, Python, Ruby, Bash, and occasionally something else as well. Most of the IDEs are designed for a single or couple of languages and just don't feel good with other ones.

Collapse
waterlink profile image
Alex Fedorov Author

I use IntelliJ Idea Ultimate and I do all the listed languages in this IDE. So this seems to be a fallacy, or it’s just a unique IDE that beats all others, I’m not sure, I didn’t use other IDEs. Platforms/languages that I use in a single IDE with the same shortcuts and behaviors:

Java/Kotlin for Backend/Android;
Javascript/ES6/Typescript for Backend/Frontend;
Python and Ruby for Scripting/Backend;
Objective-C/Swift for MacOS/iOS;
Golang for CLI/high-performance-backend;
PHP for backend or plugin dev.

Thread Thread
hamatti profile image
Juha-Matti Santala

I used to try Eclipse and PyCharm back in the day and even though I could build Python things in Eclipse, it felt like it was built for writing Java and vice versa. Sure, I have not used IntelliJ Idea Ultimate so maybe my experience is just outdated.

Does the IntelliJ Idea Ultimate have functionality for build tools, running tests, etc that are equally good for all languages or does it feel bit biased to one direction?

Thread Thread
waterlink profile image
Alex Fedorov Author

Yes, it generally does. I can switch seamlessly between different languages and run my build/test with the same shortcuts. Main refactorings are present in most of the languages. As well as auto-imports.

Of course, Java/Kotlin has top-notch support. Then Ruby/Python/Php has 2nd-place support because they are dynamic. Then you have all the other languages with medium-level support: Golang, Swift, etc.

Thread Thread
waterlink profile image
Alex Fedorov Author

Basically, Ultimate edition contains all the other JetBrains product inside of it in a form of a plugin you can install. Used PyCharm/RubyMine/PhpStorm/WebStorm/Goland/etc?—that’s a Python/Ruby/Php/Javascript-Typescript/Golang/etc plugin in Ultimate.

Collapse
waterlink profile image
Alex Fedorov Author

Of course, if you need something simple, a text editor would do. I use Atom for these things nowadays all the time.

While I love the UNIX philosophy I also know that most IDEs are plugin-based where you can disable 90% of the monster and leave only 10% of what you need, and then add few plugins on top of that. You could say that IDE has its own little “UNIX” inside of it.

The difference between a plugin-based text editor and IDE is that one is based on text and the other one is based on the code Abstract Syntax Tree. Refactorings in the latter are much faster and robust. Which is what I value personally a lot, as I do them every 2-5 minutes as part of the TDD cycle.

Collapse
ierika profile image
Erika

You can use vim style editing with Jetbrains and also have a database client, terminal, outline viewer, etc. open side by side or not.

Collapse
moopet profile image
Ben Sinclair • Edited on

I think my problem comes as soon as I hit my first snag. VCS not displaying what I'd expect? Poke around in dialog boxes for a while. Try turning it off and on again. Then... open up a terminal and fix it.

For me, I feel comfortable knowing what's going on.

I'm used to IDEs as wrappers for command-line tools, and I'm used to most of those command-line tools. When a GUI tries to make things simpler, it usually means hiding 1/3 of the options in an "advanced" menu somewhere and not implementing another 1/3 of the options at all. It's all very opinionated.

If I was developing in something like Java, I'd probably use an IDE. But I'm not.

For a couple of years I used Netbeans and PHPStorm and I've dallied with VSCode. I recognise they're good products. I've got VSCode installed and keep meaning to give it another go.

There's not much an IDE gives me over Vim, but I'm aware of a couple of things I'm missing out on:

  • little previews of values of things
  • autocompletion that's aware of context
  • syntax awareness from other parts of the project
  • that fun time everyone has when they try to put a quote mark around something that's already got one and have to do the little dance of "JUST BLOODY DO WHAT I TELL YOU" around their desk

On the other hand, we have terminal Vim, where my mind gets around my workflow. I have multiple Vims running, some of them backgrounded, some in tmux session and some on remote systems. I imagine an IDE proponent would think this was messy and disorganised, but it's my setup and I know what's going on. My bookshelves at home have a system, too. No visitor can understand it but it works for me.

I see pros and cons to each, and think they can co-exist in my life.

Collapse
waterlink profile image
Alex Fedorov Author • Edited on

Surely they can coexist. I use Vim for simple text editing tasks (configuration files, just checking something quickly), and I use IDE for actual development.

You didn’t mention “refactoring” in things that you’re missing when using Vim instead of IDE. Why is that? Are you doing refactoring by hand? How often are you refactoring? What kind of refactorings do you do?

Collapse
moopet profile image
Ben Sinclair

Refactoring for me is generally done inside a single module. The stuff and IDE gives me... if I change the method names that are used externally I have a couple of helper mappings to sort that out for me: I hit // to find uses of the currently-being-edited function in all files and the reciprocal gD to go to its definition. I can then just do a simple search and replace.

Thread Thread
waterlink profile image
Alex Fedorov Author

That sounds quite tedious. A good name is on average achieved on the 9th try.

I want to rapidly rename methods, classes, variables, etc. so that I and my pair can work through at least half of these 9 tries very quickly.

I guess, instead of thinking about the name for a while, I love to just change it on impulse and then analyze how well it reads in the location where I was renaming it.

Without the need to do additional actions except for typing a new name, I can really iterate quickly through different names as I discuss them with my pair.

Thread Thread
waterlink profile image
Alex Fedorov Author

Now, what about other refactorings? Like: move method from one object to another, extract variable/method, inline variable/method, extract delegate object, extract parameter object, pull up/pull down methods along the hierarchy chain, etc.?

Thread Thread
kungtotte profile image
Thomas Landin

Vim can do all of that either out of the box, through plugins, or through custom functions.

Thread Thread
waterlink profile image
Alex Fedorov Author

The closest thing that I could find is this: github.com/apalmer1377/factorus

It’s bearable but it doesn’t have all of what I need. Are there any other plugins that enable this?

Thread Thread
waterlink profile image
Alex Fedorov Author

Also, it’s not supported for a lot of languages: JS/TS, Kotlin, Swift, Ruby are missing

Thread Thread
waterlink profile image
Alex Fedorov Author

There also seem to be this plugin: github.com/Valloric/YouCompleteMe — it looks pretty cool, unfortunately supports only rename refactoring…

Collapse
goyo profile image
Grzegorz Ziemonski

I'm by no means allergic to IDEs but as I have recently switched from IntelliJ to VS Code, I might add my two cents.

My initial reason to give up on IntelliJ was frustration. I had to work with files over 500k lines for a few weeks and got frustrated with IntelliJ freezing and exploding a few minutes later. I probably could've just used another editor for just these files but I wasn't thinking clearly and decided to give VS Code a go.

My experience with VS Code has been overwhelmingly positive. It's fast, it looks good (can't say that about IntelliJ, sorry), and it's quite powerful. After installing a bunch of plugins and learning a few keyboard shorcuts, I feel nearly as productive as if I were using IntelliJ.

To be 100% fair, let's explain the "nearly" part of the previous sentence. Refactoring capabilities of VS Code are nowhere near the ones in IntelliJ. A file-scoped rename or method extraction work most of the time but that's about it. In this area, IntelliJ is still close to my heart. The reason it hasn't swayed me back so far is probably that my project involves a lot of research and experimentation lately, so I'm more in "need for speed" than "need for a code tank".

Collapse
waterlink profile image
Alex Fedorov Author

I understand you.

500k SLOC files require quite a bit of refactoring…

But the right tool to perform such refactoring can’t handle them 😅

I’m practicing continuous refactoring because I apply proper TDD. I’m refactoring every 2-5 minutes, so I can’t generally live without it.

If I needed to tackle 500k SLOC files, I’d use a separate tool as well. And I would also push for separating them into multiple ones whenever we touch them. It’s hard work, but worth it. And it guarantees the more often we touch them—the more refactored they’ll be.

Collapse
goyo profile image
Grzegorz Ziemonski

These ain't code files, it's a job's output to be processed by another system ;)

Thread Thread
waterlink profile image
Alex Fedorov Author

Oh, sorry for the misunderstanding…

I wouldn’t even try to open these in IDE. This is clearly a job for a robust text editor like Vim, Emacs, Atom, Sublime or Code.

That wouldn’t trigger a full switch for me personally, I’d just open another tool, do what I have to there, and switch back.

In fact, on my previous project, we always had IDE + TextWrangler open at the same time, because we had to work with some huge input/output files as well.

Thread Thread
goyo profile image
Grzegorz Ziemonski

No probs.

Looking back, I'd say that making a full switch was somewhat an overreaction. I inherited this nasty project with giant SQLs producing gigantic XMLs and on top of that the tool I'm working with is blowing up (despite the fact is supposedly supports large files by disabling certain features). I was sad, I made the switch and I'm pretty happy. Probably as soon as I need to spit out some production-grade Java/Kotlin I'll be back to rocking IntelliJ.

Thread Thread
waterlink profile image
Alex Fedorov Author

Makes sense to me!

Collapse
itr13 profile image
Mikael Klages

Though I generally prefer IDEs due to them usually being more out-of-the-box when it comes to features needed to start programming, but I assume people dislike how bloated they might become.

For example, if I'm using VS Community + Resharper, formatting a script takes several seconds, as opposed to liteIDE which (through go format) can format in less than a second.

And countless of IDE's I've had graphical bugs or features that don't work until I restart the IDE, as opposed to most simple text-editors where such issues occur much less, and mostly only when opening a too big file.

Collapse
waterlink profile image
Alex Fedorov Author • Edited on

I definitely can agree that with larger codebases I need to restart my IDE from time to time. I guess, for me, I became accustomed to that and started tolerating it. That is because I still get tons of value from complex automated refactorings because I use TDD and I need to refactor in small atomic steps every few minutes.

The famous quote “Have you tried to restart it?” works well here.

What I did notice is that when you have a simple editor, or library, tool, or framework, whenever such blasphemy happens, we, as developers, go to GitHub (or another tracker) and report an issue. We also help with all the details for the developer, and engagedly help them fix the problem.

I see myself (and others) do that much less with a paid tool for some reason even though the support (that we’re paying for) is exactly for this purpose.

Why do you think is that?

Collapse
arne_mertz profile image
Arne Mertz

I think it's a mindset when we engage with Big Companies vs. individual developers. Smaller open source projects like simple text editors feel like individual devs we'd like to help, because we know the struggle if being a dev getting their project bug free. Large IDEs that we pay for feel more like anonymous companies that don't deserve our help. I've seen a change of my mindset toward some of the Jetbrains IDEs: I've met a few of the people behind CLion, and I'm much more inclined to file bugs and provide repro steps for that IDE, but not for others.

Thread Thread
waterlink profile image
Alex Fedorov Author

Yes. This!

The people behind it are small teams of developers. If they don’t have the feedback loop closed—there is no way that the bugs will be fixed. And also, in this complex world, it’s not possible to write bug-free applications from the get-go without the feedback loop.

Collapse
itr13 profile image
Mikael Klages

Usually when I have a problem with a bigger tool the issue tracker points to a several years old issue that's either marked as solved or wontfix. In addition, some are hard to describe or recreate, and it feels strange to complain about a project not being optimized enough.

Though I must admit I'm often too lazy to report issues, so I can't really answer your question well :-P

Collapse
frmadiputra profile image
Firmansyah Adiputra • Edited on

IDEs or text editors are just tools in my tool box.
I use the tool that I consider suitable for my task at that time.

If I want to edit my Linux configuration I usually use simple editor like nano or vim because they always available and can be used through ssh.
When I'm creating Java project, I'm using IDEs like IntelliJ or Netbeans, because I can directly start to code without having to configure the build system.
For R project I also use IDE (RStudio).
I'm very comfortable using VSCode or Atom for web app projects.

Just pick the one that you feel comfortable with and suitable for your task.

Collapse
waterlink profile image
Alex Fedorov Author

I agree so much with your comment.

What should I do if I disagree with the best tool for some of the jobs?

For example, doing JS/TS for web frontend projects is much better and more efficient in IntelliJ/Webstorm. But you have to break community guidelines concerning the import structure because you don’t manually manage imports/exports anymore and you let the tool do it for you (just like in Java/Kotlin, imports just happen automatically).

I mean, I really cringe when I see people crafting their export * from './somefile.js' inside of index.js inside of the package directory, so that it is available under a cute import, that will be easier to manage manually later.

Time wasting.

I don’t have to spend time on that whatsoever. Just create a bunch of JS files grouped into package/directories and never use export .. from .. construct, and never use default export.

That is of course when I write apps. With libraries the story is different.

Collapse
ogamita profile image
Pascal Bourguignon • Edited on

There are several reasons.

  1. if you consider paid software, it usually means privative software, that you cannot modify when you encounter a bug or a need for a modification or a new feature. You are prisoner of the vendor's whim. (compare that with emacs where you have all the sources, and that you can easily modify while working on it, with emacs lisp).

  2. Each target platform has its own IDE, with of course, different features, different key bindings, etc. So their high level refactoring and editing tools might be good and nice, but having to a different cockpits leads to cockpit errors, and slower workflow than when you can use the same environment to do everything, including all your programming whatever the target. This is further compounded by the ease of customizing, which is usually abysmal (compared to say, emacs).

  3. Composed with the above two factors is the temporal stability of the tool. Vendor's IDE will change every year or two. Not fundamentally, but sufficiently to be quite irritating (new features to learn, but foremost features you used and like that disappear!). Compare that with eg. emacs, which is basically the same environment since 1983 (of course, it has a lot of new nice features, but the custom commands and customizations you could have written in 1983 will still run the same to day and in the future).

Already, you have here very strong points: instead of being a newbie at an IDE that changes every time you get a new project or the vendor feels the marketing need to provides a reformed IDE, you basically start over being a newbie at the IDE again. Some people become experts at being newbies. Compare that with eg. emacs, where you eventually get to have 20, 30, perhaps 40 years of experience, and accumulated personal tools running on it. (and then, there's org-mode!).

But the question is not specifically emacs vs. editor, but also simple editors. And here, there's a more fundamental question that has not really been studied AFAIK. While it is very nice to have for example a structured editor, being able to work at the level of characters, which is a lower level than the syntactic level you would think you'd like to work to edit programming languages seems to be very important and the differentiating feature. Yes, IDE let you edit text too, but their stress is on high level refactoring tools, and with automatic code completion, validation, insertions of whole statements, or code template, etc. They don't have the same powerful tools to manipulate the text at the character level as normal simple editors (and much less emacs) have.

I guess the importance of the character comes from some advantage it has. Compared for example to ideograms (or emojis!), because there are a small number of them (unicode non-withstanding), and that you can combine them easily to make words and other symbols. So the freedom you have normally at the syntactic level, you get it also at the lexical level, which let you switch to different languages using always the same tools, the same character-based editor.

For example, this will let you start from a specification document or some data table, and by editing it and transforming it semi-automatically (search-and-replace, regexps, etc), end up with some program in some language very easily. (Even more easily when you can add on the run your own semi-automatic or automatic transformation code in emacs lisp).

Which is not to say that structural editing is not nice; we have a few such mode in emacs; but it's important to be able to fall down to the character level easily.

Working with an IDE is like playing with meccano or with construction toys like The Source, where you have pre-defined blocks that can be combined only in pre-designed ways. Working with more simple editors at the character level is like playing with play-do (or basic lego blocks) where you can sculpt and model your code in funnier and more various ways.

Oh, and there is also the antagonism between the "Integrated" part and the open side of normal editor, and even emacs retains it (after all, compilers apart from the emacs lisp compiler are not integrated into emacs). This is the big win of the unix philosophy: to have simple tools that you can combine easily one with another to perform your work. So with simple editors, unix is your "IDE", and it's open to all the programs and tools you can have available on your system, while it's usually mode difficult to use external with IDE (some of them are more open than others, but it still doesn't feel all that easy, and foremost, it's always change from one version to the other).

Ankush Thakur Github logo

Collapse
waterlink profile image
Alex Fedorov Author • Edited on
  1. About open/close software. The IDE that I’m using is paid, but the major part of the IDE is open-source as in IntelliJ Platform and Idea Community Edition. Which means that your statement would only be partially true—for the paid features.
  2. I work in the same IDE (IntelliJ Idea) with the same experience and shortcuts for different environments, languages, and frameworks. Let’s see… This includes:

    • Java/Kotlin for Backend/Android;
    • Javascript/ES6/Typescript for Backend/Frontend;
    • Python and Ruby for Scripting/Backend;
    • Objective-C/Swift for MacOS/iOS;
    • Golang for CLI/high-performance-backend.
    • Now, I’m pretty sure I could use even more languages/platforms, I just don’t need them. To me, it seems like the assumption that one IDE per platform seems weak here… For me, it’s single IDE for every platform (that I ever need(ed) to work with).
  3. I’m using IDE for about 3 years now, and I didn’t have this problem. So far it seems like new features only get added. Old ones that I like—stay. Maybe 3 years is not enough, let’s see what happens in 5-10 years time frame. Also, is it a huge issue? I mean our libraries and frameworks change much more often than that.

About the high-level blocks: interestingly enough that these blocks correspond very well to Simple Patterns and Atomic Refactorings. These didn’t change much in the last 15-20 years. So actually, I like these “rails” that allow for the smoother application of what is proven to work well.

I don’t want to have a “custom-crafted style” of my codebase design. The poor new team member who’ll have to understand this unique style…

Good point about the Unix philosophy!

Collapse
thinkslynk profile image
Stephen Dycus • Edited on

1) How often do you actually find yourself modifying the source for emacs? If you never do it, then it's not really important. And if you DO, then perhaps paid software, with a dedicated team of full time developers, provides a more stable experience out of the box that requires no editing. I have never felt the need to modify the source of an IntelliJ IDE, but much of it is open source anyway. And I can always write plug-ins.

2) IntelliJ has an IDE for everything. I use:

  • Pycharm for python
  • Webstorm for javascript
  • Datagrip for sql
  • Android Studio for Android
  • CLion for c++

And they all work the same. They have the same right click menus and keyboard shortcuts.

3) I started using IntelliJ products 5 years ago when Android forced the switch from Eclipse to Android Studio. I have NEVER, in 5 years, experienced what you mentioned. Not from the IDE. I HAVE, however, had third party libraries completely depricate their public API to replace it with something entirely different on numerous occasions (I'M LOOKING AT YOU FACEBOOK.) And in those instances, with an IDE, it was trivial to refactor my code to handle the underlying change. Even when the community switches gear entirely, IDEs help. When Android switched to Kotlin, Android studio added various options for converting your code from java, piece by piece. Sure the resulting code wasn't optimized, but it was good enough to work from. You're not going to get any of this from emacs.

I use vim daily to modify text files and remote source files, don't get me wrong. But an IDE of some sort would benefit most developers. From static code analysis that prevents runtime errors, to point and click breakpoints, to code coverage highlighting, to code macros, autocomplete, automatic PEP8 formatting, right click refactor, alt enter for auto import, spell check, etc. These are just everyday features that every developer could benefit from. Some of which can be made available in emacs or vim via plug-ins or using other tools, but it's far simpler to have everything in one place.

Collapse
koenigscode profile image
Michael König

To be honest, I feel like I switch my "main" editor/IDE every two weeks.

The tools I settled for a long time are intellij/pycharm and vs code.

I've been doing almost exclusively web dev for like a year, mostly front-end and not a lot of JS, so a text editor (vs code) was totally sufficient.

The biggest downside of intellij imo is - even though it may sound a little silly - the start-up time. I'm annoyed when a program takes like a minute to start (I'm on a laptop w/ i7-8550U) and as soon as I don't need it opened anymore, I close it, just to reopen it 5 minutes later as I've realized I've got nothing better to do.

Also, editors like vs code feel faster to me and I feel like vs code just has the biggest variety of plugins available.

Besides all that, I think that I just don't need an IDE (yet).

Actually, most people are considering vs code a text editor - I did so before, too - but as I'm writing this I'm wondering why, as vs code provides a debugger and all that fancy stuff you'd expect from a full-blown IDE 🤔

Collapse
waterlink profile image
Alex Fedorov Author

The biggest downside of intellij imo is - even though it may sound a little silly - the start-up time. I'm annoyed when a program takes like a minute to start (I'm on a laptop w/ i7-8550U) and as soon as I don't need it opened anymore, I close it, just to reopen it 5 minutes later as I've realized I've got nothing better to do.

Yes. IDE is not used like this. On the work machine, I would usually launch it and never close it for the next 2-6 weeks.

Great points of using IDE is to let go of handling imports/exports on your own manually, and safe automated refactorings.

Collapse
koenigscode profile image
Michael König

yeah, refactoring is a good point.

I'm currently learning python and don't need a lot of imports atm, so vs code is more than sufficient.

However, we learn Java at school (I'm 16 y/o and learning it for about one and a half year so far) and use netbeans. I couldn't image writing java and manually adding all the import statements.

Also, I'm really surprised to see how low people's expectations are when I mention that I'm learning programming (and networking, databases, project management etc.) at school.
I'm one of few people in my year that's really into tech (especially programming) in my free time. Most of them seem like they're just looking for a high-payed job, which actually is totally fine and they've got a right to do so, but I'd enjoy having a little more tech-enthusiastic people as my real-life friends.

Thread Thread
waterlink profile image
Alex Fedorov Author

Also, I'm really surprised to see how low people's expectations are when I mention that I'm learning programming (and networking, databases, project management etc.) at school.
I'm one of few people in my year that's really into tech (especially programming) in my free time.

Start freelancing as soon as you can, and whenever people have wrong assumptions, you can tell them that this is actually your passion, and you’re coding to make your clients happy—you’re a small business owner. I think the respect will bump up higher immediately.

Collapse
nuclearnic profile image
nuclearnic

Because you see developers clicking buttons and not knowing what they do. I've seen someone be flabergasted about a situation where tests were passing locally but not on CI - turned out his heavy IDE was set to run a different type of test suite. And it wasn't obvious.

Because people who like Unix and Bash like spending time in a (non-integrated) terminal.

Because you learn the languae through the IDE vs learning the language raw and being able to use Sublime/Atom/VSCode/Vim/whatever.

Because most people who don't like IDEs very much are also not very fond of those verbose, enterprise language that require an IDE - otherwise most devs would be useless.

Because it means that my life and my work is staring at something which is out of my control.

We like freedom.

Collapse
waterlink profile image
Alex Fedorov Author

Yes, I hear your point: to be a well-rounded developer you need to master both IDE and non-IDE way. IDEs exist there to boost the productivity of what you already can do without them. It’s not a good idea to use IDE to perform what you can’t do without them.

I was lucky as I started out in an environment where I could do a lot of in-terminal work, learning all the Unix tools, using powerful text editors, etc. When I came to IDE world, I’ve seen only benefit, because they supplement my existing skills and automate what I’m bored to do manually.

Collapse
nuclearnic profile image
nuclearnic

What if I'm not developing in a JVM language, C# or XCode? You're not wrong - a good developer should learn all the tools. But your question was "why do devs dislike IDEs", and if I'm writing Ruby, Python, Golang, Elixir, JS, and many other languages then you really have to prove to me that using this ridiculously heavy tool is worth it.

"Hacker" types don't necessarily dislike IDEs, but every single non "hacker" type is wholly locked into their IDE. It's all they ever see.

If a random developer comes along and shows off something new he/she did over the weekend, what would you bet that they're not an "IDE person"? I'd bet on it.

If I was working on a huge Java codebase I'd have to use an IDE. As long as I don't have to I won't. There are different types of developers with different goals, and if I had to point at someone and say, "I'd like to be like that", then it would be somoene like Gary Bernhardt. And falling in love with an IDE simply isn't part of that path.

If you really enjoy working in an IDE then awesome for you.

"(IDEs) automate what I’m bored to do manually."

Right. Well that sounds like generating classes. That doesn't exist in many languages. Clicking into classes through call paths are super useful, but such code is (again) a symptom of the languages that require these features.

Thread Thread
waterlink profile image
Alex Fedorov Author • Edited on

What if I'm not developing in a JVM language, C# or XCode? You're not wrong - a good developer should learn all the tools. But your question was "why do devs dislike IDEs", and if I'm writing Ruby, Python, Golang, Elixir, JS, and many other languages then you really have to prove to me that using this ridiculously heavy tool is worth it.

I’m using IntelliJ Idea Ultimate heavily for Ruby, Python, Golang, and Javascript. Works almost as well as for Java/Kotlin/Swift/Typescript/etc (from my humble polyglot developer experience).

"(IDEs) automate what I’m bored to do manually."

Right. Well that sounds like generating classes.

Sorry, no. I automate imports, syntax sugar suggestions, cycle through alternative forms of the same code (different syntaxes of lambda, if <-> case/when, add/remove code block, change signature of the function etc.). And most importantly I use automated refactorings every few minutes.

I did such refactorings manually when I was coding in the powerful text editor. The problem is that you can’t do a lot of them, because they are tedious, especially if the codebase is anywhere big enough.

80% of these refactorings can be automated, and what might’ve taken minutes of search/replacing + hours of debugging what I’ve missed, now takes just seconds. That enabled me to use higher-order refactorings—a sequence of small atomic transformation that can take me from design A to design B, and all the tests will pass after each small step. Also, every step takes seconds to perform.

such code is (again) a symptom of the languages that require these features

Well, that’s a wonderful note. What is the problem with classes and objects? Most of the languages that you’ve listed above will have those (except Elixir).

Collapse
busbyra profile image
Ryan Busby

While I prefer working in vim, I don't hate IDEs. IntelliJ is a resource hog, though, so I USUALLY stay away from that one in particular.

Collapse
waterlink profile image
Alex Fedorov Author • Edited on

For me, personally, I give IntelliJ about 8-10GB of RAM easily (out of my 16GB present on this machine).

I don’t mind it hogging so many resources if it makes me 5-10x more productive at refactoring—something that I do every 2-5 minutes because I practice proper TDD.

It’s good ROI, I think.

Collapse
busbyra profile image
Ryan Busby

Haha, on my Pixelbook, I car 8 gigs. When running a Linux VM, I think I have 4 split off. On my old laptop, it shows 6, which boggles my mind, but yeah.

Your reasoning is exactly why I still do use it on my workstation, though! It really is extremely useful.

Thread Thread
waterlink profile image
Alex Fedorov Author

On my laptop I give it a bit less memory, that's it. That prevents me from opening 4 projects at the same time, but I guess it's alright.

Collapse
waterlink profile image
Alex Fedorov Author

Actually, If I had to give it 60GB, I’d do that as well. I’m quite happy it’s not there yet, though ;)

Collapse
vergeev profile image
Pavel Vergeev • Edited on

I'm actually actively use IDEs, but here's the list of things I don't like about them:

  1. Non-native user interface. I can't put my finger on why exactly I love native widgets, but if two pieces of software offer similar functionality, I'll go with the one that implements things natively.

  2. Heavy memory and CPU consumption. On macOS, unused memory gets filled with cached files. So the more free memory I have, the more files are cached by the OS, and the more responsive the whole experience is.

  3. The Law of Leaky Abstractions. I love my GUI git in PyCharm, and if the GUI abstraction breaks for some reason, I know how to fix it in CLI. Not true if you started out with IDE and don't know how things work on a lower level.

Collapse
waterlink profile image
Alex Fedorov Author

These are all valid and good points.

I rarely use IDEs VCS, I just type Git commands in terminal. It’s much faster for me this way since I learned all of git way before using modern IDE.

Also, this point keeps reocurring—learning development is better without IDE because you have to learn the build system, auxiliary systems like Git, etc., to be a proficient programmer who can deal with unexpected issues that are so prevalent in software development.

Or beginner can learn to code in IDE, but then they still need to backfill the knowledge they’re lacking by going through some sort of #NoIDE challenge for 100 days or something like this.

Collapse
bgadrian profile image
Adrian B.G.

from observing these kind of devs I have found they have any/all of:

  • work mainly with small projects that are fine with a simple text editor
  • stubbornness
  • rigid personality
  • resistance to change
  • laziness (to learn something new and better)
  • Sadomasochism
  • lack of professionalism (you know you can deliver more with an IDE but do not)
  • subjective reasons (love to a specific text editor)

yeah, I'm looking at you vim priests 👀

Collapse
waterlink profile image
Alex Fedorov Author

I agree with all the points. There is another kind:

In other threads here, it seems that some people had experience seeing some other developers using IDE and flailing as programmers. It seemed that IDE users that never had non-IDE experience may have a not-deep-enough understanding of foundational concepts of the language, build system, etc.

Also, there are some notions about “for people working on Enterprise languages/platforms.” (used in a bad sense)

Collapse
nuclearnic profile image
nuclearnic

laziness (to learn something new and better

You're saying this to people who have learned Vim?

Collapse
fuyuriseiji profile image
SBBG / S. Fuyuri • Edited on

When I was not familiar with my core lang, I usually start with an IDE. But after that, I will gradually fall back to Emacs with a custom mode.
I found that I cannot stand using a different tool for a specific platform/language too long. And I personally consider it as a virtue - less software on your machine, less memory consume, and much uniformed shortcut, interface, whatever you name it.
I know it's not that much of big deal nowadays to use multiple IDE on 1 system. But probably I'm just too used to that.
Recently, I just did a unreal mode since I'm developing in UE4. It's quite a cool ride if you can configure a mode or something to fit your own need without other bloating funcs you don't want.
And of course, it's still extraordinarily awesome that I can boot into Linux with a frame buffer console and Emacs in less 10 seconds to just simply rock.

Collapse
waterlink profile image
Alex Fedorov Author

I think that this is a very good strategy for learning a new programming language 👍

Collapse
joshhadik profile image
Josh Hadik

I think for me I’ve found that most IDEs don’t handle the they way I code well. I’m the type of programmer who types fast, has a hundred files and folders open on my screen, flips between programs with the stroke of a key, and has my whole computer rigged to help with my workflow.

Maybe I’ve just used bad IDEs but every time I use them I’ve noticed some amount of lag. A key will take a couple extra milliseconds to show up on the screen after I press it, or a file will take a half second to load when I click it. This just ends up irritating me and throwing off my whole rhythm.

I don’t think IDEs are bad and I don’t have any disrespect for people who use them, I just don’t think they work well with my programming style, so that’s why I generally try to avoid them.

Collapse
waterlink profile image
Alex Fedorov Author

I think IDEs don’t work for you because they are optimized for different flow: where you type as least as possible. Basically, the IDE should from the context show you the most suitable options, and you should choose 1st or 2nd one. Then you have a bunch of code to which you can apply a few transformations using live templates or shortcuts. Then you start refactoring this code with shortcuts, etc.

So yeah, if you love typing fast and produce a lot of code—great text editor is the best tool for you!

I love to type as least as possible, and make decisions in which direction I want to steer the transformation/growth of the code, and let the machine do the hard work.

Collapse
joshhadik profile image
Josh Hadik

Yeah after reading some of your comments it seems like you were more asking from the perspective of projects with bigger teams / larger codebases which I totally agree can benefit from using IDES.

Most of my programming right now is done in the small team / prototype phase of projects which I think has a totally different set of requirements than more established projects and apps.

Thread Thread
waterlink profile image
Alex Fedorov Author

I agree!

Collapse
okdewit profile image
Orian de Wit

Because IDEs are opinionated, and devs love customization and control.

I use a few of the Jetbrains IDEs every day, and I consider a "full IDE" a necessity when working on a large complex codebase.

But my frustrations still stand: IDEs can be slow, bloated and buggy, and it's often difficult to get things working exactly to your liking.

So I fully understand that those working on nicely separated JavaScript components or a single Python script choose VSCode, Atom or Vim — I personally don't find it viable though when working on a large & sometimes messy backend framework.

Collapse
waterlink profile image
Alex Fedorov Author

In these environments, I sometimes would choose such a tool as well. “Right tool for the job” as they say.

Collapse
madhadron profile image
Fred Ross

It's a form of social identity. "I'm a hardcore unix guy, I don't use an IDE!" It's the same mindset that keeps people thinking that teletype emulators are somehow a fundamental way of interacting with a computer in 2019.

Collapse
waterlink profile image
Alex Fedorov Author

For some that may be true. Others have other interesting reasons, pains, feelings, thoughts, and assumptions.

Collapse
madhadron profile image
Fred Ross

I was too glib. Let me unpack this further.

I see two distinct views of a program. On one side you have people who regard the actual program text, its representation as characters in a file, as the fundamental construct they are manipulating. On the other you have those who regard the program text as an authoritative representation of a data structure that they are manipulating.

If you regard the characters in a file as fundamental, you begin with a text editor and integrate capabilities based on running that text through a program. This is what Thompson had in mind for Unix as a programming environment: manipulate text streams. Some tools like ctags are going to build a cache of information about the program, but the idea of setting up a big, memory hungry cache of everything about the program seems wasteful.

If you regard the data structure as fundamental, then having to work with it as text streams feels like sorting an array in your program by serializing it and running it through the sort command. This is the world that Smalltalk programmers inhabit.

Today most of people live in some netherworld in between. Turbo Pascal and much of Visual Studio were on the unix side. Eclipse was a rewrite of VisualAge (which was Smalltalk) in Java, and was still on the Smalltalk side. IntelliJ kind of sits in the middle, a very comfortable place for people to get work done but a very uncomfortable place intellectually.

Thread Thread
waterlink profile image
Alex Fedorov Author

Thank you for pointing out this fundamental difference in the approach to programming! Even though I’ve never done Smalltalk in production, I’m absolutely on that side right now.

Collapse
nepeckman profile image
nepeckman

I think one reason some developers look down on IDEs is that IDEs offer an abstraction away from the reality of building and maintaining an codebase. It's possible to write in a language like Java and never really understand how the Java language builds and runs. I know some older IDEs even handled the deployment of code, so you could build a whole app without leaving the IDE.

I remember seeing some data from coding interviews that compared performance by the tools a person used. IDE users were much more likely to fail than Vim or Emacs users. I think this is because on average, IDE users are more likely to let the IDE do everything for them, and less likely to learn the platform intricacies. That said, this doesn't mean any individual IDE user is not smart, and I do use intelliJ when writing Java (though not for anything else).

Collapse
waterlink profile image
Alex Fedorov Author

That is an interesting thought.

In some platforms/languages that would be definitely the case. So to be a well-rounded professional a developer needs to be able to proficiently wield both types of tools: a simple one and advanced one.

Collapse
rrampage profile image
Raunak Ramakrishnan • Edited on

I think it depends heavily on the language. I use Eclipse when working with huge (Java) codebases, vim for small shell or python scripts / quick edits and VS Code for medium sized projects (Python) and when learning a new language (currently Haskell).

Java lends itself very well to IDEs. We can fearlessly refactor and make big changes. Python OTOH is very dynamic, so I rely more on linting and unit tests.

Collapse
waterlink profile image
Alex Fedorov Author

That is a nice use case: learning a new language.

If you don’t have 20+ languages behind your back, it’s actually a good idea to do this without IDE to gain a deeper understanding of the syntax, import system, build system and how it works in general.

I love IDEs for great automated refactoring capabilities and I always work with tests (TDD), so for me, fearless refactoring is a must in my workflow. Even for things like Python or Ruby.

Collapse
melezhik profile image
Alexey Melezhik • Edited on

Hi Oleksii ! The statement "boost our productivity so much" needs some prove. There is nothing in IDE I can't achieve through my convenient tools. But IDE almost always brings tradeoffs, such a CPU consumption and limits you to GUI that is IMHO is far less efficient then scripting.

Collapse
waterlink profile image
Alex Fedorov Author • Edited on

“boost our productivity so much” is a feeling that I, my colleagues and members of a community are experiencing. The feeling doesn’t need to have proof. They’re just there. They might not match the reality. But they surely exist. ;)

Now, I’m pretty sure there are things that text editor can’t do. Surely correct me if I am wrong:

  • Safe complex automated refactorings (extract/inline variable/method; pull-up/push-down method; extract delegate class; move method from one class to another with all dependencies; rename refactoring; etc.)
  • Auto-imports that just work, so that we don’t have to bother with imports at all. Just specify which import we want when there are multiple candidates. Also, I don’t want to manage my exports and hand-craft them (like people in the JS community do for whatever reason). That includes any refactoring that affects any import/export. I want these to be resolved automatically.
  • Auto-fixes for warnings that static analysis produced.
  • Smart completion that takes current context into account and orders the options accordingly so that in 95% of the cases what you want will be the first option and you can just press ENTER.
  • Ability to stop writing text and start growing/transforming code at the AST level quickly and rapidly.

Because I do refactoring all the time, and I want to transform my code instead of writing/rewriting it, the tool indeed makes me more productive.

This is probably a different approach to coding/development at all. IDEs enable one way, advanced text editors enable another one. If you use the wrong approach for the wrong tool the productivity will dip down.

So if I come from IDE to text editor I’ll be less productive because I’ll do the thing that is enabled by IDEs (but manually, instead of automatically). If I come from the text editor to IDE, I’ll be less productive because I’m not doing any of the things that IDEs enable, so I’ll be missing out on value and productivity.

Collapse
nyarlathotep77 profile image
Davide Schembari #QueueJumper #FPBE

I do not use anything else but Android Studio for my daily work, but it can be a huge productivity drain far too many times. Its memory hunger is spectacular and can easily hung your machine. It simply not good enough that a IDE is not able to run on a machine with 16Gb of RAM. It'd be great if you could selectively disable bits and pieces of the IDE to make it a Lite version. There you go JetBrains, please give us a "Lite Mode" for Android Studio.

Collapse
waterlink profile image
Alex Fedorov Author

In IntelliJ, I can go to a list of plugins and usually disable 80% of them because I don’t need them. Can you do the same within Android Studio (same IntelliJ platform)?

Also, there are some rumors in circulation that IntelliJ Idea + Android plugin is more stable than Android Studio (but it may be 6 months behind feature-wise).