Hacker News Reader

Comment by scanr | Hacker News Reader

The Jetbrains suite. Lightens the cognitive load, makes it easier to refactor and keep code tidy. All of which allow me build better software.

For almost everything else e.g. git, learning how to use the command line instead of a UI is the best way for me to learn how the tooling works.

View on HN

I'm dependent on Jetbrains IDE for most of my work. It really shines in showing the user best practices and recommendations. A lot of the programming concepts are same across languages and this IDE helps you find the right function/method with its suggestions. And at least for java it'll suggest you variable names, it'll suggest you if a loop can be converted to a stream, it can generate templates for unit tests, it can tell you if a variable might be null, etc. There are a ton of small small features that all add up to a great experience. 10/10 would recommend for a new programmer.

Yes, I would agree with that. If you make websites there is just nothing better than PHPStorm. It is one of the program that just works and makes your life a hell easier. Also a huge shoutout to 'lazyone' on SO for always answering my questions. It's one of the rare companies that actually understand what you're saying instead of just pasting canned replies.

BTW I'm not affiliated with them but they're having a 50% discount sale right now.. iirc 25 birthday sale. They seldom give out discounts, so this is a great time to upgrade too.

Hmmm, I'm not seeing the discount pricing you speak of.

Looks like it’s specific to PhpStorm, and not any other JetBrain products.

I guess it's only for PHPStorm and ending it about 14 hours from now

https://www.jetbrains.com/lp/php-25/

Oh darn, I already have WebStorm and PHPStorm. Cheers.

The discount applies to renewals too.

I agree. I’ve been using IntelliJ ultimate for a few months now and I don’t see myself going back to sublime or emacs. I do work mostly with ruby, typescript, golang and occasionally clojure. I recently found out that with the Ultimate version, you can install all the language plugins and won’t need the other IDE like Goland, rubymine, webstorm etc... They’re just plugins. So all your settings can live in one place

It's crazy how many disparate technologies Ultimate integrates for you. Here's a reddit post I wrote a while ago that lists nearly a dozen different technologies/contexts that I use IDEA for in a single project: https://www.reddit.com/r/java/comments/by2ow0/do_you_use_you...

And that's not the "toolbox" license suite - I do all that for the price of a single Ultimate subscription.

License for Ultimate is cheap enough that if you're going to buy 3 or more of their product, it's better to just buy Ultimate (assuming the tools are provided by plugins in Ultimate).

The way I've seen the 'better software' show for myself is that I see problems that people walk away from that are just too complex or diffuse and their priorities just don't make it worth the struggle.

Tools that eliminate even a little bit of cognitive load moves the point of no return a little bit farther, which means there are kinds of problems you can touch that someone else won't or can't.

Seconded, although to be fair the choice of IDE doesn't really matter as long as it's relatively good. When I moved from vim to Jetbrains, one of the biggest things was seeing all the small errors including spelling mistakes. Being able to easily see and fix minor syntax errors or things like missing variables etc really makes a difference, especially when you are working on a codebase where that was missing for a long time.

If anyone is an emacs/vim user it's certainly worthwhile to enable similar error reporting plugins to get the same effect

The arrival of Language Server Protocol is going to make IDE-like functionality more evenly spread across traditional text editors, "modern" text editors and "IDEs". In Emacs I recommend eglot: https://github.com/joaotavora/eglot

I used to be very gungho on text editors (started my career with Sublime, moved to VSCode later), but I've turned the other way and use Jetbrains products now.

LSP is decent, but I've yet to see any languages with the depth and quality of Jetbrains IDE support, by a fairly large margin. I've had to fight VSCode settings many, many times in to world of Go, but Goland "just works" for the essentials - intellisense and code navigation is just so much better. Python and Typescript are probably the best-supported in VSCode, but they still don't meet the mark. Rule applies doubly so for languages that aren't strongly typed. Breakpoint debugging for code and tests is similarly hands off.

They add all sorts of ecosystem-specific know how to make the experience smooth, e.g. Rails, Rspec in RubyMine.

I still use command line tools for every other part of my workflows, e.g. Ripgrep, git, dependency management, but I haven't found anything else that compares for coding with really excellent intellisense and code nav, other than Visual Studio proper for C#.

Yes I definitely believe everything you say. I will say that currently I'm using LSP (Emacs Eglot) for Python (pyls) and Rust (rust-analyzer) and the difference is (unsurprisingly!) night and day. I love Jedi and I'm sure Palantir did a decent job but... but rust-analyzer on the other hand, I wonder if in a year or two, is it possible that Rust in Emacs might not be so far off the best "IDE"?

Back then (10+ years ago?), IDEs were meant to be bloated and slow having convoluted interfaces and I only used it when absolutely necessary (like Eclipse for Android before Android Studio became the default) but my, JetBrains saves me so much sanity, it changed the definition of IDE for me (or rather IDE was meant to be like that). I only used lightweight text editors before then. (Used SublimeText before the switch.)

Great thing about JetBrains is they work out of the box unlike vim where you need to spend a whole month customizing just to get back on working on the project with 20 random plugins out there and it's still probably only 30% as good as JetBrain's.

VSCode is being developed rapidly and I see many good plugins but it's still quite far behind except for the launch speed. At least it could be seen as a competitor to make sure JetBrains will keep innovating and keep the performance of their IDE sane not to lose customers to VSCode.

VS Code is like 90% good enough for me compared to Eclipse. I was evaluating IDEA and VS Code to switch to and VS Code with its Java extensions was an easy winner considering its launch speed and the responsiveness. IDEA even though tons better than Eclipse still feels clunkier than VS Code.

Unbelievably amazing to be able to shift-click on syntax and jump to the source - even works pretty well in dynamic languages.

I HATE using a Gem then needing to break my train of thought to pull up the official documentation to see what an API interface looks like. Ctrl+click. In and out in 15 seconds.

You just taught me something! I've been using keyboard hotkeys to jump to source. On mac, I can hold down command (probably ctrl on linux) and it lights up like a link, shows the gist, and let's me click to go to source.

This is why I love these sorts of threads :)

Ctrl-B also goes to definition (at least on Linux) if you don't want to leave the keyboard. On definition Ctrl-B lists all usages of the term under caret.

After a while, you'd think why this isn't the default in other editors. (At least VSCode jumps to obvious sources.)

Seconding Jetbrains products. They’re not the lightest weight text editors and have something of a learning curve. However, they have done a lot to improve my productivity

Came here to say the same. It seems to be the most intelligent IDE I have used so far in that it can understand what you are trying to achieve (well, most of the times) and help you write better code. I learnt a lot in Python just by following IDEA's code reviews and trying to understand the rationale behind each suggestion. And it really shines when you are developing in a JVM language like Java or Scala.

Same. I started using it for Java long ago and now just subscribe to the "all you can eat" license [1]. $249/year, and 100% worth it so that I can pop open pretty much anything in a familiar, well-tuned interface.

[1] https://www.jetbrains.com/all/

When I found the jetbrains Ides I really started to enjoy programming again. I could think about what I was trying to accomplish instead of getting bogged down in programming overhead. Also paid for the toolbox, worth every penny.

Interesting that you prefer both extremes of UI design.

Jetbrains UI that shows available options or pops them in real time.

And command line UI; requires reading the docs to learn options, but can be powerful and chained with other commands via pipes, ez automating UI interactions into scripts, etc.

This is myself as well, enjoying the extremes. Having all the whiz-bang guidance is great and really speeds up my work, except when it doesn't work. Then it's great to be comfortable falling back to something rock solid and unbreakably simple. I never have to "fall-back" multiple times in successive frustration. There is one fallback and it ALWAYS works.

To me it's not worth learning the "in-between" tools for the extremely limited circumstances that I'll need something less than IntelliJ but more than vim/bash. I even hesitate to customize my vim much because I need to rely on it as a fallback on nearly any system, and on novel systems I can't rely on my customization.

I'm not dogmatic about only sticking to these - I'm comfortable with VS Code when it's what my employer/workgroup provides, and I'm comfortable with Sublime, as it's particularly portable (can be run off USB). So sometimes Sublime is the fanciest option.

But anything in between JetBrains and vim needs a real "reason" to bother investing the time to learn.

Just downloaded the GoLand 30 day trail. First impressions are I now remember how slow and stuck in goo java based IDEs feel.

What cool stuff should I look at as I am willing to be sold on this.

Jetbrains offerings are quite fast. What are you comparing them to?

Probably Sublime text. It's just too fast and I can't switch to anything else. I open heavier ones like Eclipse, VS Code etc. only when I need to refactor.

I notice the same thing, and I enjoy IntelliJ / Sublime / Vim. IntelliJ often feels sluggish.

Maybe this could help: https://blog.jetbrains.com/idea/2015/08/experimental-zero-la...

Here was a 3rd party analysis from 2015, showing a reduction in latency when editing XML files in IntelliJ IDEA from ~70ms with large jitter to 1.7ms with small jitter: https://pavelfatin.com/typing-with-pleasure/#summary

I wonder if it's turned on by default today, 5 years later.

Some other techniques: https://medium.com/@sergio.igwt/boosting-performance-of-inte...

Seems like the IntelliJ zero latency typing is on by default since ~2017 releases.

https://blog.jetbrains.com/idea/2016/12/intellij-idea-2017-1...

https://blog.jetbrains.com/clion/2017/01/clion-starts-2017-1...

Goland is a Java-based IDE.

I don’t notice slowness on it personally. Maybe you are noticing the initial indexing it does. That doesn’t happen often with GoLand.

Make sure you enable Golang modules in the settings also.

Anyways just mentioning some stuff off the top of my head I enjoy:

Debugging is a great experience.

Can find a plugin for most anything, I use the Kubernetes one for syntax completion and documentation. (alt-q I think)

Also you can create .rest files and compose http requests and trigger them right in the files, which I thought was cool.

The documentation pop up by hitting alt-q in general is pretty cool. Don’t have to run over to godoc.

Then most things you’d expect from an advanced ide. Multi line editing... jump to definitions and implementations... Project wide code search and replacement

I'm not sure about Go's specific characteristics, but for PyCharm I love full project semanticly analyzed code navigation and remote step-through debugging. I use visual studio code for most JS stuff, but it's awful for wrangling many files simultaneously and learning a big codebase. Webstorm allows me to search for function calls and other things in the entire codebase much faster. I prefer VSCode's git UI and use both apps.

I have found most Idea performance issues are either, configured Java heap space, or indexing of project files that could be ignored. The default memory settings are generally pretty conservative, some larger projects run into issues immediately. If your system has plenty of ram to spare, I would recommend just giving it a few gig and seeing if things improve.

at least for JS, the refactoring tools save a lot of headache. write code before deciding on variable or function names and then one click to refactor everywhere in the codebase.

I can compare it with VSCode. Goland is much better at working with multiple Go Versions, which is a big thing in my daily work. Other things that it does better than VS Code are auto-generating unit tests, refactoring function signatures, better package management support, easier to set-up different build/debug profiles ...

I'm a die hard Emacs use but when I need to bounce around a codebase or refactor, I jump into the various jetbrains tools. Friggin awesome

You aren’t die hard enough.

Reply on news.ycombinator.com