Comment by geophile | Hacker News Reader

Comment by geophile | Hacker News Reader

As many on this discussion have noted, JetBrains tools not only don't collect dust, they are widely used, and the company is profitable. The company is privately held. I hear that they are constantly turning down investments. This proves 1) there is money in tools; 2) The VCs who routinely say "there is no money in tools" are insufficiently imaginitive, which is not surprising if you've spent any time with VCs.

Why is JetBrains so successful where others have failed? A few thoughts:

- Intellij was released in 2001. Eclipse was a close competitor for a while, which made no sense to me. Intellij just worked, and it was intuitive. I found Eclipse to be uglier, slower, flakier, crashier, and far less intuitive. Haven't heard of it in years.

- It was always the case that at least some version of Jetbrains tools are zero cost. I got hooked on it early on. I have been using emacs far longer, and yes, while a sufficiently dedicated developer can make emacs behave like an IDE, it really isn't one. Intellij just worked out of the box. In the preceding two decades, there were high-end development tools available (Lisp machines and their all-encompassing environments, Lucid for C++, Purify for C/C++ memory problems, Atria, Rational. Trivia: Did you know that Purify was founded by Reed Hastings, the guy who went on to found Netflix?) The tools were expensive, and I don't think there were free versions. These companies all went out of business, or were acquired.

- Jetbrains is incredibly focused. Having been through several VC-funded technology companies, I can easily see how VC brain farts can destroy a company's focus. (This dynamic isn't entirely the VCs fault. Founders stretch the truth to get funded, and then VCs insist on the fairy tales they've been told.)

- Jetbrains has expanded to other languages, and other kinds of tools (besides just refactoring Java code). The number of languages, technologies, and frameworks that they support is just mind-boggling.

- Consistent focus on improving developer's lives, through steady improvements in functionality, performance, and quality, over 20 years at this point. They started far ahead and have widened the gap.

OPs tools look useful. I suspect they would attract a much wider audience if made available through Jetbrains products.

I always have this weird sensation when people talk about Jetbrains.... I feel like some in some circles, usage of Jetbrains tools is ubiquitous, while in others it is unheard of. I have been a professional software developer for 15 years, and have never seen the tools in use anywhere I work. But I read things on the internet where people will say things like “well, every ruby developer uses Jetbrain” and seem to not even question this.... weird how circles like this form.

Yes, odd. Data point: me and most of my SE friends/coworkers pay for JetBrains IDEs (I was pretty deep into emacs and vim for many years prior to switching).

I definitely haven't "switched". In fact, I have a key binding for escaping to emacs to work on the current source. I find that useful because emacs kbd macros are so much less clunky than the Jetbrains equivalent. But yes, Jetbrains products have taken over much of what I used to do in emacs.

> I have a key binding for escaping to emacs to work on the current source.

Are you aware that you can set the Jetbrains editor to use emacs key bindings?

Not OP but they're not saying they want to use emacs keybindings, they're saying they want to use emacs keyboard macros [1], which I agree really are a very handy feature having no equivalent in JetBrains.

[1] https://www.gnu.org/software/emacs/manual/html_node/emacs/Ke...

Emacs keyboard macros have an inferior equivalent in Intellij (and, I'm assuming, their other products). But also, emacs just somehow feels faster. Maybe keystrokes are marginally faster, maybe it's my expectations, but there it is.

I know that Intellij has emacs key bindings, that's not the issue, I'm happy with the Intellij default bindings.

Oh, wait, I just figured out part of it.

In Jetbrains products, I am CONSTANTLY hitting Esc to Tab to deal with the helpful predictive suggestion. I find that feature sometimes useful, so I have not turned it off. But it definitely produces a different and maybe slower experience than typing in emacs. Maybe there is a mental mode switch between typing and handling the hint?

I suppose it depends on your comfort level in the stack you’re dealing with. I’ve been writing software for 40 years. I’ve been doing Rails since almost the start, and find RubyMine slow and overwrought. However, I had to do some Java work (which I had never done in anger before) and found that IntelliJ really is worlds better than Eclipse. So much so that I paid for it out of my own pocket, even though I knew the project was doomed to failure. I hear good things about Rider, but I have yet to try it, as, after all these years, I’m pretty comfortable with VS. Rails work is EASILY done with a terminal and a text editor; the others not so much.

It's really stack dependent. In Java & Android, it's jetbrains IDEs, iOS is Xcode, etc. I think it comes from what that subindustry has converged on the best served dev stack for them. If jetbrains isn't the most used, then it's not the best.

" If jetbrains isn't the most used, then it's not the best."

Oversimplification, when comparing free software and paid software.

I was talking about an industry stack. Plenty of open source java software devs use IntelliJ to develop their open source modules and libraries, not to mention there are free editions of their IDEs on top of that.

It's similarly shocking to encounter entire companies where nobody uses a debugger. Millions in revenue, dozens of programmers, and the level of debugging is still sprinkling printf-statements and desperately perusing source code

My hot take: Schools don't touch the practicalities of professional programming enough. Homework is mostly small-time enough that you can keep the entire codebase in your head, and solve issues with printing variables. At least my CS master's degree was very much limited to 1950s level tool use.

Colleges generally teach computer science, not programming. They're different arts with different goals.

Bootcamps teach ... I don't know, really. I keep seeing an ad to "become a developer in 14 days," and I waver back and forth between amused and angry.

I think there's room for a happy medium, some kind of trade school for software development. A curriculum that teaches you practical skills like debugging and clean architecture, and prepares you for an actual job.

I found that my use of debugging peaked a few years into my software career, and then fell off rapidly. Debuggers are great for single-threaded code, less useful for multithreaded. And close to useless if your problem spans processes.

As the problems I was debugging got more complex, I found that log files became far more useful. The logging is always there (assuming you do a run with the right logging levels selected). You can get a high-level view of what's going on far more easily than in a debugger, which has you rooting around at a very low level. You don't have the phenomenon where you just miss the critical thing while in a debugger, and then you have to laboriously start over. If you miss the critical thing with logging, you turn on more of it and run it again.

If you have one of those bugs that occurs extremely rarely, just keep running the code, and turn on logging. When the problem occurs, you have the evidence leading up to it.

This assumes you have the right logging there to start with. I put a lot of development time into my logging code -- making it informative, compact, readable, carefully selecting what to log and where and at what logging level. I make sure that I get log rotation right, and then I use some simple scripts to download, consolidate, split and search the log files.

"Desperately perusing source code": Yes, you need to read and understand code in order to debug it. You obviously know that, so I'm not sure what "desperately" is meant to convey.

>You don't have the phenomenon where you just miss the critical thing while in a debugger, and then you have to laboriously start over. If you miss the critical thing with logging, you turn on more of it and run it again.

This is rather confusing to be honest. Are you saying restarting the software is hard, or that restarting it is easy? If you just missed the critical thing, just add a conditional breakpoint ("Stop here if ptr is null") and restart the software.

Restarting is easy. But you know how it is. You get to your breakpoint, go forward carefully, and then step over something you should have stepped into. Oops, start again.

I think a very important point you are missing is that JetBrains was founded in Eastern Europe. Their developer costs when they were founded were probably ~20-25% (if that) of what developers cost in Silicon Valley, yet still at an amazing skill level.

I honestly don't think JetBrains would have been able to succeed if they were founded in the US.

A thing which made Jetbrains successful probably was their deal.with Google. By making AndroidStudio free they got a large userbase. This also was my first direct encounter with them.

I see that AndroidStudio was released in 2013. Intellij was pretty well established by that point. No doubt this deal helped them grow far faster than they would have otherwise.

No. They were popular and making money before AS.

Yes, they were known and used especially in Java-Sprache before and had a good quality product.

Having a company like Google pushing it into the AppDev community and offering it for free certainly have attention and certainly a nice financial contribution from Google.

> Intellij was released in 2001. Eclipse was a close competitor for a while, which made no sense to me. Intellij just worked, and it was intuitive. I found Eclipse to be uglier, slower, flakier, crashier, and far less intuitive. Haven't heard of it in years.

Eclipse is still in use.

And don't let the above scare you: it is not as beginner friendly as VS Code or Netbeans but it is a walk in the park compared to learning emacs or vim from scratch.

It is just different, and if you come frome a file-centric and line centric workflow you should probably just as well get used to thinking about classes, functions interfaces etc: i.e. don't think "I'll open this file, look for that line", instead you jump to a class or a function or even better just go to the implementation of the function you are looking at. It just works.

And you mostly don't cut, paste and update manually, you just ask eclipse to move it and then verify it in the scm commit view before you commit: "Moved x to y to make z possible"

Reply on news.ycombinator.com