If I'm understanding correctly, the thing you found offensive in that comment was the JetBrains employee talking about "dragging" people to IDEA. If that's the case, it's important to note that the notion was first suggested by the OP:

> This would not only be beneficial to developers using this editor, but could drag a lot of developers to IDEA when seeking out for a full-blown IDE eventually.

In this context, the JetBrains employee was not saying "it won't sell licenses and therefore we won't do it", they were saying "this won't do what you think it will do".

JetBrains is a company, and like any other company their focus will tend to lean toward where the money is. But my experience with Kotlin over the last several years is that JetBrains is very responsive to the community and their needs.

They public stated that a reason why Kotlin exists is to sell licenses.

> The next thing is also fairly straightforward: we expect Kotlin to drive the sales of IntelliJ IDEA

https://blog.jetbrains.com/kotlin/2011/08/why-jetbrains-need...

I call this skin in the game. If making a good programming language is a monetary incentive for them the i'm fine with that.

Couldn't this also lead to a language that's only really usable with IntelliJ?

That's what they're currently attempting with Java. Kotlin is basically JetBrains' attempt at dominating the ecosystem,

Only if you think you need an IDE for a language to be usable. People sometimes make that argument about Java but kotlin is far less verbose.

No, Kotlin is open source.

Intellij Idea Community Edition with Kotlin support as well. Also free as freedom and free beer.

What exactly is the problem with this? How is it different from C#? Or even Java ?

Java was never created to sell Sun's IDE, regardless of the chosen IDE you always get same support.

C# was created to be the systems language of .NET, although the CLR supports other languages from day one.

Obligatory mention whenever anyone dicusses Sun's true motives for creating Java [1,2]. Sun's motives were anything but tidy. On Patrick Naughton's account, Sun's executive decision-making seems quite haphazard and opportunistic. Draw your own conclusions about the vagaries of individual perspectives or how typical this is of executive decision-making in general.

A line that might become amusing when you read the whole account:

> Thus began a long line of sporadic interjections by Bill [Joy| where he was right. He usually is.

[1]: http://www.blinkenlights.com/classiccmp/javaorigin.html

[2]: https://news.ycombinator.com/item?id=30613578

Sun created Java to go against Microsoft, that isn't the discussion on the table, rather Kotlin and it being a guest language on the JVM, with a community that usually bashes the platform that made Kotlin possible to start with

It sounds like you are trying to find differences where there are none.

It also looks like you're forgetting that Java has been for years (decades) owned by Oracle, which is renowned for taking very public legal fights to milk Java to the extreme.

https://en.wikipedia.org/wiki/Google_LLC_v._Oracle_America,_....

Nah, that is Kotlin fanbase trying to move goalposts.

Java has been owned by Sun, and then Oracle, and it was more closed source during Sun's stewardship than Oracle's.

The first lawsuit was done by Sun against Microsoft, and they only missed the one against Google, because they were out of money by them.

Unfortunately Google got away with screwing up Sun, not happy with that, they keep using they flavoured Android Java when selling Kotlin's push into the ecosystem.

Still in all these years, Java was never used to sell Netbeans commercial licenses, regardless of how you to try to change the music.

> Still in all these years, Java was never used to sell Netbeans commercial licenses (...)

But that's completely irrelevant, isn't it? Cherry-picking aside, don't you understand how loss leaders work, and how companies use that strategy to push the sale of their cash cows?

Microsoft created the LSP to go against JetBrains :)

But Sun did invest in the creation and development of Java for the financial benefit of Sun. Jetbrains invested in Kotlin for the financial benefit of Jetbrains.

JetBrains wants to be like Borland, and like Borland is now getting beyond themselves and better not trip over.

Regardless, Jetbrains is in the business of selling dev tools. Any past present and future investment in Kotlin must be seen in this context.

They better take care not to fly too high with their Kotlin Platform.

what would flying too high mean in concrete terms? lock themselves into a tiny ecosystem?

> JetBrains wants to be like Borland, and like Borland is now getting beyond themselves and better not trip over.

I don't understand what Borland's history has to do with JetBrains' decision to invest their resources on adding support for a programming language to a third-party text editor.

Sounds like a non-sequitur of an unwarranted cheap shot that adds nothing to the discussion besides noise.

Touch grass. JetBrains is trying to be like Borland in the sense that JetBrains is doing with Kotlin what Borland did with Delphi. Create their own all-in-one-place programming ecosystem. You can see it slowly coalescing.

C# and .Net was for a very long time a Windows only thing, they were created to fight against Java so Microsoft can keep selling Windows licenses.

IMO this Microsoft stupidity to not open source .Net and FUD the open source alternatives costed them and the entire dev community a lot, we would have a good alternative for cross platform high level languages with a big framework (as alternative to JS+node+electron+npm+framewoks)

First class languages for the Windows Platform.

Sure, but they linked a good dev platform with an OS, this prevented .Net to become a much more used platform because most developers developed for Linux server using anything else then .Net (java,PHP,Python or the super shitty at that time JS and node). The open source community might have implemented an open alternative but only some parts of the language and platforms were open and there was a lot of fear that Mono that implemented some non open API could be a liability.

I personally was a big fan of C# and I can't forgive MS stupidity , because of the Windows Team a good language and platform was sabotaged, as I said it could have been a worthy competitor to JS/node especially in the past when JS was shit and even now where npm is filled with leftPads and colorRed packages.

They're pushing hard in that direction with https://dotnet.microsoft.com/en-us/apps/aspnet/web-apps/blaz...

I don't think we've heard the last word yet.

JS/node are no competitors to .NET, not even close, only in the minds of script kiddies.

I only done desktop .Net apps so I can't judge, but even if I love the language and the standard library in .Net I would never had considered using it on a server if I had a choice, not because of quality but because of Microsoft bad treatment of the licenses an, the FUD and how they handled it. They managed to drag this platform down that js and node has probably more users and mind-share, they even had to "port "C#" and create TypeScript.

Btw, i did not implied anything about node or npm quality, someone that worked with both seriously in recent years might add their thoughts (so I am not a node fan just a C# lower disappointed on MS behavior).

Kotlin wasn't created to sell intelliJ, it had been the dominance IDE long before Kotlin inception. You found an article that happens to have that wording, that fits you hatred for some programming language. So you parroted the same argument all over this thread. Get a life.

C# was created in response to Java to keep developers in the Microsoft ecosystem.

Its effectivly the same thing, even though Microsofts goal wasn't selling visual studio, because they've got a much more lucrative cash cow: an operating system

Wrong.

.NET was going to use Java, when it was still codenamed as Ext-VOS.

It was the lawsuit against J++ that made C# a reality.

You didn't contradict my statement with that...

The motivation behind c# was keeping people in the Microsoft ecosystem. Wherever they attempted to use a rebranded jvm before that is entirely besides the point

Exactly. They ignored the Microsoft JVM, J++, J#, and the lawsuit around it that forced them to make C# and compete - rather than extinguish

> What exactly is the problem with this?

What if I want to continue using Emacs?

Don’t use Kotlin? Or just deal with the lack of language support.

Or use it, and accept that the language support is about as good as it usually is for Emacs? Emacs has never had the full range of features an IDE has.

That's a weird thing to say when for example Emacs+SLIME has had everything you wanted from a Lisp IDE for more than a decade.

There's literally no reason for not having full IDE experience in Emacs.

That's another reason why I don't like programming languages that need a specialized IDE. PLs should be simple. Not being able to use a language efficiently in any editor of your choice is like working with a programming language that needs specialized proprietary hardware to compile.

From 2011. I think their motivations have expanded quite a bit in the past 11 years, as has their commitment to the language, compilation targets and use cases.

Ironically that blog posts mentioned they created kotlin to not accept compromises in terms of compilation speed. I have found kotlinc's performance to be really bad

Does the LSP implementation [1] linked by the JetBrains employee in that thread not work? It pushed a new minor version release a little over a week ago.

It seems pretty reasonable to me for them to not pay employee salaries to build a plugin for a competing product, especially when they already provide a comprehensive IDE solution available for free (in both senses). What other companies are doing that? I don't mean that as a challenge. I'd love to know what the better options are.

[1] -- https://github.com/fwcd/kotlin-language-server

Read the README: https://github.com/fwcd/kotlin-language-server#this-reposito...

What you said would make sense, except they do build a plugin for Eclipse.

Better options would be any language where the stewards are not trying to extract money from you by forcing your IDE choice. Or where they view fostering community good will as being in their best interest. Ex. MS offers an official LS rather than saying "we don't support other IDEs because Visual Studio licenses."

There's lots of choices here for compile to JS languages: https://github.com/jashkenas/coffeescript/wiki/List-of-langu...

> What you said would make sense, except they do build a plugin for Eclipse.

I don't know a single person who used Eclipse after 2020. Don't you think that supporting Eclipse might be a viable marketing strategy to get people who are stuck in the past on board with newer tech, as if anything, they will probably move on to IDEA?

> Ex. MS offers an official LS rather than saying "we don't support other IDEs because Visual Studio licenses."

MS is a bad example because they recently literally took away a feature from dotnet to push it into VS and drive sales, which was met a HUGE backlash from the community. Dotnet IS the driving force behind Visual Studio. JetBrains actually came in and took a piece of that from them(thankfully, because I personally hate vs/vscode). Like other answer to your comment said, JetBrains doesn't owe anything to anyone. If there is already a Language Server for Kotlin, great, I don't see how a product-based company could benefit from making something that drives people away from their (already free) product...

> I don't know a single person who used Eclipse after 2020.

So your circle of acquaintances doesn't include anyone who used an IDE in the past year, and you extrapolate your personal anecdote how far?

> Don't you think that supporting Eclipse might be a viable marketing strategy to get people who are stuck in the past (...)

Can we spend a minute discussing how idiotic is this fad-drive development belief? I mean, why is anyone expected to be perceived as smart if they drop something that works in favour of an unproven tool just because it's new?

That’s a fair statement but given that IntelliJ is over 20 years and the IDE of choice for many, if not most, professional Java engineers, it doesn’t apply here.

> (...) and the IDE of choice for many, if not most, professional Java engineers (...)

The same baseless assertion can be made regarding Eclipse, and it would be less doubtful given Eclipse's FLOSS nature.

Again, can we spend a minute discussing how idiotic is this fad-drive development belief? It's weird how, unlike in any engineering field, there's this cargo cult faith that new and untested is automatically better than old and reliable,and anyone who hasn't mindlessly jumped into a bandwagon is somehow the fool in the story.

> I don't know a single person who used Eclipse after 2020.

What happened in 2020? Did I miss the end of the world?

In my bubble, Eclipse : IDEA is about 50:50, and luckily it doesn't matter because of Maven. I am one of those Eclipse users, and I am still waiting for someone to show me a feature that IDEA has and Eclipse doesn't. From my perspective it seems like the same thing, with different aesthetics (e.g. whether you can open multiple projects in the same window, or you need different windows) and keyboard shortcuts (which can be redefined on either side).

So I wouldn't try to convert people to Eclipse, but I also see no reason to convert to IDEA. I have a tool that works and does everything I need, and that makes me happy. Show me a functionality I am missing, and I may change my mind (some people already tried, and then it turned out that Eclipse had that, too); otherwise I am not interested in novelty for novelty's sake.

Uhm, I am not developing for Android. There, I imagine the situation may be quite different.

They don't owe anybody anything.

It works. At least, it works well enough for me to use on a daily basis, and I'm pretty hard to please.

Do you happen to use Java and Kotlin in the same project? This seems to not work well for VSCode when I tried it a while back.

Mixed language projects is something that only IntelliJ can really do. It’s actually the reason I switched over to it from VsCode for Java since we mix Scala in our project.

That is actively being worked on currently, but is very WIP still

I'm curious, how do you see this as being adversarial to their community? It's not like they are taking down kotlin language servers, there are community language servers and extensions for kotlin in vscode and they're linked here as well, by jetbrains employees.

They need users to pay for IDEA to survive, so being open about not wanting to spend developer time to make it easier for people not to use IDEA that could be used to make IDEA better seems sensible from a business perspective. Seems like the community stepped up regardless.

on the contrary, I found their response very fair and reasonable. Quoting:

You can code Kotlin on any device, using any IDE, anywhere, at any time, thanks to the fact that Kotlin source code is stored in plain text files and not in a proprietary binary format. You do have a language server for that. The language server happens to be not developed by JetBrains, but it doesn’t actually restrict you from being able to use it in any way.

In my book, “lock-in” means “you have to pay a single vendor or you can’t use the tool”. You seem to be defining it as “you have pay the vendor or live with maybe slightly worse code completion and no refactorings, until someone else supports these features in a free tool”. I don’t believe your definition to be justified.

Just use jetbrains. VScode has properietary features which aren't available to other editors too.

For me, it has basically nothing to do with being open source. Despite all the constant hate about electron apps, I've consistently found VS Code to be much snappier to use than any time I've tried using Jetbrains IDEs (whether on beefy desktop or slimmer laptop), and that's even after disabling a huge number of plugins and features that I don't want. That's not even talking about the actual features of each; I think I just prefer a smaller initial feature set with a rich, well-supported ecosystem of third-party as well as first-party plugins rather than a huge default feature set (which inevitable comes with a bunch of things I don't want) and third-party plugins being mostly an afterthought.

> Despite all the constant hate about electron apps, I've consistently found VS Code to be much snappier to use than any time I've tried using Jetbrains IDEs (whether on beefy desktop or slimmer laptop), and that's even after disabling a huge number of plugins and features that I don't want.

I use both vscose and intellij, and I must say that even though vscode can sometimes feel snappier without any plugin running, it's missing a whole lot of features even with dedicated Microsoft plugins running, to the point it feels half-baked. I'm talking about things like basic refactoring support and even symbol recognition.

IDEs like intellij and Clion may have slightly longer startup times, but that doesn't really matter as you're only going to start the app a few times throughout the day.

Ultimately vscode is nice if all you want to do is open text files and Run regex searches, but the minute you want to run the most basic refactoring steps then it's faster and less frustrating to just start intellij, refactor, save files, and quit the app.

I think this probably depends at lot on language. I mostly code in Rust, and for a simple example of one of the "most basic refactoring steps", renaming a type/function/variable/etc. and updating all the uses work quite well using rust-analyzer. I'm not doubting that Intellij might have a lot of nice refactoring features that VS Code doesn't, but I'm definitely able to do a lot more than just regex searches.

Just my experience at work (I don't intend to change your mind or invalidate your opinions) I can see from reading code what IDE the developer used, this is because I investigate bugs and I see trivial JS bugs that Intellij highlights but the author used VS Code and an avoidable bug was put in. Intellij is slower because it actually parses your project and dependencies and even with a dynamic language as JS it can infer many types and show you the error.

Same here. Open a JS project in a Jetbrains IDE and things start going red all over the place. Asking the JS devs about it, they're like "oh we didn't us TS on that file" or "oh yeah we know about that, just ignore it". And the best one "oh yeah, that's a bug, we haven't finished that part yet."

Honestly happens with python devs too when you open their project or code in a "real" IDE that checks for all these things.

That's fair! I don't program in dynamically types languages on a regular basis, so it's possible that I'd notice more of a difference if I did.

We hate electron apps because native apps are much faster

But Java/Kotlin is not native. Before electron, we hated Java apps because native apps are much faster

I develop in Pascal and Kotlin. When I had a laptop without SSD, Jetbrains IDE would take almost 30 minutes to start, while the Pascal native IDE could start in 30 seconds.

Yep. Lately, it seems like a lot of people think “native” means “not web technologies”. Way to many people think that Jetbrains apps are native because they are written in Java.

Yeah, I briefly tried using nvim for csharp dev and discovered that even though csharp lsp is open source, the razor lsp integration is not (or was not at the time) and the vscode plugin downloads some proprietary binary.

Or if you care about open source, use VS Codium. It's literally VS Code minus the proprietary crap, and with a different branding.

But the "proprietary crap" part is where they've implemented all of the Python support, among other things, isn't it? And last time I looked the license prohibited using Microsoft's proprietary plugins with VS Codium.

The Python extension is open source but Pylance isn't. Use Pyright (type checking ext which is essentially Pylance without the ML stuff) instead of Pylance.

Instead of Microsoft's C/C++ extension use clangd.

Remote SSH and Remote Containers have alternatives as well but nothing as good.

Google and Red Hat's extensions work out of the box along with several thousand other extensions.

> Instead of Microsoft's C/C++ extension use clangd.

Didn’t know about this one, thanks.

Go on…

It's fine to prefer M$ lock in to other lock in. I just take issue with blaming Jetbrains for lock-in while at the same time praising VScode which also has lock in.

I personally just use emacs.

Go on… what Microsoft lock ins in VSCode are you referencing?

The vast majority of vscode is opensource actually. I'm unaware of any major feature that is not part of their OSS project.

https://vscodium.com/

Isn't LiveShare proprietary and closed source?

Pylance is for sure, but it's built on the open source Pyright they provide, which is still pretty decent.

I think there's other things too but I don't recall the comprehensive list.

OP is referring to some of Microsoft's intellisense language plugins. They are not bundled with VS code by default but they are the best-in-class in terms of language support for autocompletion.

Embrace, extend,...

… Trebuchet?

IMO Fleet¹ from JetBrains is their answer to VSC, and hence it doesn't make sense for them to invest in VSC. What people are arguing for is the difference between the interests of JetBrains vs the interests of Kotlin, very similar to the kinds of conversations that went on for early Rust governance.

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

Programmers spend an inordinate amount of time thinking about languages and tools, but don't want to pay for better ones, even when they are extremely cheap, drastically increase their productivity and save many headaches. Every other week, there is a post on HN complaining about funding open source. One of the few languages offering halfway decent tooling support is bad because... it makes users more dependent on tools? This makes no sense. Same story for Wolfram. If you want nice things, pay for them.

It doesn't have anything to do with price. The point is that I've invested a lot of time knowing my IDE (vscode) very well. Switching IDEs on the basis of a language which I've never used is a huge leap. You could make that leap a lot easier by allowing me to use it somewhere I'm comfortable first.

As others have mentioned in this thread, you are absolutely allowed to write Kotlin in VSCode! There is a perfectly good VSCode extension [1] for it. You may not receive the same extensive support that IntelliJ IDEA provides, but as Kotlin developer who occasionally writes in VSCode, I find it's decently usable. Once you're familiar with the command line, you'll probably be more productive running Gradle commands than fiddling with buttons and UI widgets anyway.

[1]: https://marketplace.visualstudio.com/items?itemName=fwcd.kot...

Seems like a no brainer - who wouldn’t want to use an awesome language like Kotlin and have it shared across iOS, Android and Frontend?

However, the actual experience is full of sharp corners. Get ready for nonexistent documentation, hacky plugins, poor debugging support, lack of proper native libraries and head spinning errors.

In general, it feels like doing carpentry using your plumber’s tools.

I use Kotlin without a license. Just the community version of the IDE, they also released an eclipse plugin that is currently unmaintained. But still open source. I think they did their best to help but without hurting their business model.

Groovy has no Netbeans support anymore. Who is to blame. Groovy? Groovy is better as a PL than Kotlin. But Kotlin is no match in terms of performance and pragmatism. I use both instead of Java and I never looked back.

Developers using VSCode are not their community, they are not being adversarial to their own community but maybe a potential future one.

> Kotlin for JS is really about selling IDEA licenses

Kotlin the entire language is about selling IDEA licenses.

Ever tried to read Kotlin in plaintext? It's terrible. The language makes you need the IDEA hints they give you to read it.

Can you elaborate on why you think it’s terrible to read in plaintext compared to other languages? I’ve been writing a lot of Kotlin recently and the only memorable extra hints (compared to other languages/IDEs) I see on IDEA are named parameters, smart casts, and the type of `it`/`this`. Sometimes I browse GitHub from my phone and I find Kotlin code very easy to read.

Both lambda-with-receiver and `it` code are a lot harder to read without IDEA giving you hints

Huh? Kotlin code tends to be very compact, often functional, and immutable and non-nullable variables (both by default) severely reduce cognitive load when reading code.

I've not done much kotlin, but whatever little I did was entirely in vim and it was a perfectly pleasant language to work with.

Indeed and they aren't shy about it.

If it wasn't for Google giving wind to their sails, the Kotlin ship wouldn't have gone anywhere.

> If it wasn't for Google giving wind to their sails, the Kotlin ship wouldn't have gone anywhere.

I disagree. While the Google announcement to officially support Kotlin surely gave it a big boost, Kotlin was already in widespread use for Android development well before Google announced their support for it in May 2017. Additionally, it was also gaining traction for server side development since before the Google announcement. I had been evaluating Kotlin closely during this time, and made the decision to start using Kotlin in our (primarily Java and entirely server-side) company codebase in late 2016 because I was already convinced Kotlin had a bright future. We weren't the only ones who thought this, I was tracking multiple other companies in our space (financial tech) that were evaluating and/or already moving to it too.

As much as Scala, or any other alternative language. You have to thank some certain Kotlin advocates for Google's decision.

https://talkingkotlin.com/the-first-kotlin-commit-in-android...

Kotlin is gaining momentum outside of Android, which is the only platform that Google helped with. In other areas, like Flutter, Google is actually competing with Kotlin (KMM).

Wishful thinking, enjoy your 8%.

https://www.infoq.com/news/2022/03/jrebel-report-2022/

So Kotlin is already more popular than Scala and now the most used JVM language except Java itself, and is used almost as much as Java 12, 13, 14, 15, 16, 17 and 18 combined. Not sure you should be that dismissive..

Nope, Kotlin is behind Scala on reaching the peek of the adoption curve.

Nice play there with the Java version numbers, it is still Java.

You have poor reading comprehension (in addition to a real hatred for one particular language, which seems unhealthy). I never stated that it was among the most popular languages, just that it was gaining momentum.

In 2019, 41% of Kotlin devs claimed to work on web back-ends. In 2020 it was 47%. In 2021 the survey changed wording but "server-side development" had increased to 52% of Kotlin devs.

https://www.jetbrains.com/lp/devecosystem-2021/kotlin/

Ah, a survey from the company whose goal is to sell Kotlin, really conclusive.

sorry that's not it, Kotlin was created as a better Java, and is growing out of that niche. If it wasn't for Android, Kotlin is still a good back end language, especially with so much JVM stuff that isn't going anywhere soon out there.

> If it wasn't for Android, Kotlin is still a good back end language

It certainly would. Like so many other JVM languages. Android is what makes kotlin stand out from that crowd.

Arguably "particularly well supported by IntelliJ" is another thing that makes kotlin stand out from the crowd, but that's a two-edged sword. I'd expect the average JVM person to see that as roughly a tie between a quality and a cost (more lock-in).

I don't see any alternative JVM language competing with Kotlin right now to even have options. Scala 3 is in a very different space. Before Kotlin 1, scala 3 was no where near release. I remember eclipse X10, which was like a "transpiler for java" but it wasn't as ambitious as Kotlin with multiplatform planned.