from Hacker News

The decline and fall of Java on the desktop

by shannah78 on 3/2/22, 6:29 PM with 357 comments

• by alex_suzuki on 3/2/22, 7:13 PM

  Successfully using JavaFX (or OpenJFX as it is now called) in a mission-critical cross-platform app with 50k+ installs.

  It’s not that bad really. Package size and RAM usage is a bit of an issue, as we bundle it with a jlink’ed (stripped down to what is needed, thanks to Java 9 modules) JDK.

  Other options like Electron or native Windows/macOS wrappers around a shared core written in C++ were discussed but ultimately discarded.

  Still happy with the choice, although it feels a bit dated and IDE support (IntelliJ) is so so.

• by mjevans on 3/2/22, 7:30 PM

  IMO the real decline was Oracle.

  Java used to be a slowly rising language and set of platforms with benevolent oversight from SUN and at least the outlook that it was one of a few things you might want to add after Microsoft's Windows or Apple's OS (Macintosh or later OSX).

  Then Oracle bought SUN and everyone knew all of the good would eventually be strangled out by the lawyers and models that sought to dominate and extract for revenue control.

• by geophile on 3/2/22, 7:51 PM

  This article seems quite off. First, it conflates browser and desktop. Yes, applets died an early and deserved death. That is different from what happened with desktop apps.

  A univeral GUI (e.g. Swing) was wrong-headed. I don't actually know what happened after people moved away from Swing. But even in the time range TFA discusses, Intellij IDEA, an IDE written in Java, was a success. It has always been multi-platform, and never had worse than acceptable performance in my experience. It has grown into a large suite of products, and I think it is widely considered to be the best IDE, for pretty much any language you can name, by a wide margin.

  Java has become the new COBOL -- the language for business applications, which means backend development. But the continuing success and improvement, and broadening of the JetBrains products pretty much demolishes the argument that Java has declined and fallen on the desktop. JetBrains is an existence proof that it is a very capable platform for anyone who chooses to use it there.

• by lacker on 3/2/22, 8:06 PM

  What happened in the years leading up to 2005, or perhaps in 2005 specifically that caused this blackout? Where did all of the Java desktop developers go?

  Before 2004, there was a much wider perception that web applications were fundamentally limited by their latency, and if you wanted a really rich, interactive user experience, like Winamp or Outlook, you had to make a desktop application.

  Then Gmail launched in 2004 and Google Maps launched in 2005. At that point, if you wanted to make a web-enabled experience with a high-quality user interface, it became more and more clear that you should build the client side in HTML + JavaScript and the server side in whatever you wanted, possibly Java.

• by sebazzz on 3/2/22, 7:03 PM

  As a C# developer I remember the first time I developed a GUI java application. In C# you have a code-behind file with your own code and event handlers, and a "designer file" with the generated code to set-up the GUI itself.

  Then I used Netbeans for a Java app, and the code file contained weird sections of artificially not editable code, and event handlers were so much more complex and cumbersome - with inner classes etc. Felt really like a step back.

• by cosmotic on 3/2/22, 6:47 PM

  Java Swing still lets you make native-looking-and-feeling apps (with some care). I don't know of any new GUI frameworks that let you do the same. I consider this a killer-feature of the framework. It's also very fast, backed by OpenGL and DirectX. It also ships with source code and isn't declarative, so it's trivial to step into as a means to debug why your code isn't working.

• by joshmarinacci on 3/3/22, 5:37 AM

  As a member of the Swing/JavaFX/Netbeans teams during the 2005-2010 period (I left the day before Oracle took over), I can tell you that this story is broadly correct, but with many missing subtleties. At the time we thought of Silverlight and Flash and Adobe Air as our mortal enemies. We were all wrong. After AJAX and HTML Canvas the web essentially killed desktop app development. All of those internal corporate apps (which were 95% of the desktop Java apps written) migrated to the web. We certainly all made mistakes and could have done some things differently (I begged to write the Applet plugin from scratch), but in the end none of those changes would have mattered. The future of desktop was the web.

• by thrashh on 3/2/22, 7:52 PM

  IMO the real reason why Java never took off on the desktop is because making a cross platform Java app is pretty easy but distributing a cross Java platform app is super hard. There’s all these situations that you have to account for, there’s no de facto way of doing anything, and you’re basically on your own finding a solution that fits your app. On top of that, you have to distribute the JVM and licensing for that used to not be that clear cut.

  Literally the only obstacle to any language being on the desktop is the lack of someone creating a reliable, well-supported, cross platform, and easily licensed distribution method for that language.

• by leftbit on 3/2/22, 8:53 PM

  I've been coding Java since 1.2, mainly UI. 20 years we built a really complex control system visualizing thousands of graphical states on six monitors on a Pentium, quietly ticking away at 20% CPU usage... all in Swing. Which I still find very impressive.

  Swing suffered from two central weaknesses: the tutorials provided by Oracle were... often insufficient. And you could pick up some bad habits by following them. And then there were the UI builders where anybody could draw up something mediocre.

  Real strength were the lightweight components where you could about change everything in your Look&Feel. Hexagonal radiobuttons? No problem. Want the drop down button of that combobox a bit larger? There you go.

  SWT... wouldn't really categorize that as an UI toolkit. SWT is mainly driven by eclipse, not developed independently. All controls commonly used by eclipse run reasonably well. Using anything else, especially cross platform is risky. 2D graphics is especially slow. So it's only a reasonable choice if you want to build something that looks and behaves like eclipse. There's some styling of components via CSS, but it's not complete...

• by TeaVMFan on 3/3/22, 4:55 AM

  Code signing killed Web Start for anything but big $$$ projects. And asking people to download an application and run it with full privileges is a huge barrier to entry.

  Contrast with the web deployment model:

  * Deploy with a free SSL certificate

  * Click Once, Run Anywhere (CORA)

  Luckily for Java fans, you can make great Java apps for the modern web. Tools like TeaVM (and its Flavour toolkit for SPAs) make it possible. Code in Java, bind to real HTML templates, compose your app out of reusable HTML components, style with CSS. All the benefits of the modern web, with a single strongly-typed language top-to-bottom.

  * TeaVM: https://teavm.org

  * Real 5-letter word app made with TeaVM/Flavour: https://frequal.com/wordii/

  * Migration Guide from Swing to TeaVM: https://frequal.com/TeaVM/migration/MigratingFromSwingToTeaV...

  * Java Magazine article on TeaVM: https://blogs.oracle.com/javamagazine/post/java-in-the-brows...

• by lildata on 3/2/22, 10:42 PM

  Bottom line today if you can't deliver your app on the web only, you will most likely end up at best with:

  - An Electron (Desktop) app

  - An React Native Mobile app (that needs to be delivered through both Google & Apple proprietary channels)

  Whether you loved or hated Java the language, it is hard to deny we ended up in a terrible place:

  - We lost all freedom on mobile

  - We rely way too much on Blink & Webkit

  - We traded Java for Javascript

  - It's still relatively slow

  - We haven't fixed the security problem on desktop

  - Devs now have to manage a lot more technologies & moving parts

• by shiado on 3/2/22, 7:29 PM

  On the other hand Minecraft is the best-selling PC video game of all time and it was originally written in Java and the Java client is the definitive experience of the game.

• by bullen on 3/2/22, 8:44 PM

  Many things you don't know are Java are and they are VERY widely used.

  Java simply wont go away because it works.

  For serverside it's a nobrainer, but also for client if you have a niche consumer base.

  Average joes don't understand the overhead of writing native applications and they are paying for it without knowing.

  Here is my only contribution to the "desktop" Java eco system: http://move.rupy.se/file/logic.html

  It has worked flawlessly on Windows, Linux and Macs for over 15 years.

• by thangalin on 3/3/22, 2:51 AM

  My desktop text editor[1] is written using JavaFX and leans on Warp Packer[2] to create installer-free, multi-platform executable binaries (without jlink). A user contributed a new dark theme[3], which blends nicely with the desktop.

  The JavaFX-based WebView (an HTML rendering component) is lauded, but has no direct API to control the scroll position and is itself a memory hog. Scrolling must be handled through JavaScript, and that indirection is as unwieldy as you can probably imagine. FlyingSaucer is a workable alternative to WebView, but comes with numerous technical issues that rear themselves when embedding a Swing widget inside a JavaFX application---as I discovered during development.

  Were I to start from scratch, I would definitely seek out alternative cross-platform programming languages for desktop application development. The JavaFX event-based model is top-notch, but there are too many technical gremlins to make implementation a smooth ride. (Such as improper handling of Alt+Tab, which leaves focus on the menu bar when returning to the application[4].)

  [1]: https://github.com/DaveJarvis/keenwrite

  [2]: https://github.com/dgiagio/warp

  [3]: https://i.ibb.co/QpqS0NS/screenshot.png

  [4]: https://stackoverflow.com/q/65765656/59087

• by throw7 on 3/2/22, 8:10 PM

  The issue with java was users don't care about write once/run anywhere. They care about the program running perfectly on their OS of choice i.e. the java program better look and perform just like a native program (and who can blame them?!).

  I run tuxguitar once in awhile and it still gets multiple monitors wrong which makes reading music sheets awful by default. (the "fix" is to hard code a resolution in a startup config file which is awful ux).

• by phplovesong on 3/3/22, 7:56 AM

  Java on desktop in 2022 seems like a lost cause. It's always slow and hogs resources like crazy. A good example is all the Jetbrains IDE's. Try running any of them on a low powered laptop and you end up having a bad time.

  Luckily there seems to be a push for fully native.

• by marcodiego on 3/2/22, 9:02 PM

  IIRC, Java had difficulties during the late 90's and early 2000's for advanced desktop applications mostly because of performance. As time passed, although jvm implementation's performance improved, so did C++, multi-platform frameworks and other programming languages. Other phenomenons also occurred: Linux continued with a very small fraction and the desktop effectively turned into a duopoly of windows and mac and new developers shifted to web and mobile. You can clearly see that there are very few examples of new desktop packages that thrived recently, specially compared to mobile and web equivalents.

  The development of the described scenario strongly devalued java's most advertised advantage, which was portability.

• by Tommabeeng on 3/2/22, 7:52 PM

  I've made a few desktop apps in https://github.com/cljfx/cljfx (e.g., https://www.chronos-desk.com/), and cljfx (JavaFX + Clojure) is amazing and makes for rapid development, not to mention fun. I'm keeping an eye on https://github.com/HumbleUI/HumbleUI, which promises to be a step up.

• by Naac on 3/2/22, 6:47 PM

  >> This history is neither meant to be comprehensive, nor necessarily chronological. I’m recounting my own journey through the Java desktop landscape, and it will be biased towards Mac

  This paragraph should really be right in the beginning of the post, instead of in the conclusion.

• by grandinj on 3/2/22, 8:02 PM

  The company I work for is happily delivering Java Swing desktop apps every day.

  Works great, easy to debug, tons of open-source components to plug in when we need, sufficiently performant, thoroughly battle tested.

  And these are medium update rate apps, not games, but not static forms either.

• by antihero on 3/2/22, 7:53 PM

  I think Java had a bad reputation on desktop for a long time. Every application I remember using back in the day was extremely sluggish, felt like a skinwalker with regards to UI, and hogged memory.

• by bouncycastle on 3/3/22, 3:27 AM

  Not just Java, there's been a decline of desktop apps in general.

  It's kind of ironic, because most of our apps are now running in an even slower language with "Java" in the name (JavaScript)

• by commandlinefan on 3/2/22, 10:49 PM

  In a way, desktop apps themselves declined - right now, besides the browser I'm using, I only have an IDE and an email client open (and I'm a bit of an oddball for not using the webmail client as well). Most of the corporate desktop apps that would have been written in Java in the 90's have long since been migrated to the web.

• by toolslive on 3/2/22, 8:02 PM

  A Steve Jobs quote: "We want to bring Java back to the desktop in a really big way. I'm here today to personally tell you we are working hard to make Mac the best Java delivery vehicle on the planet. The biggest thing we are doing is we are going to bundle Java 2 SE into every single copy of Mac OS X the upcoming Macintosh operating system that we ship later on this year."

  Apparently, he changed his mind around OSX 10.5 and just removed it.

• by digisign on 3/2/22, 9:33 PM

  The article ends right where my knowledge drops off, so I'm waiting for part two.

  The piece did remind me of the poor Java performance at the turn of the century. If you thought it was bad on a Sun or Wintel, you would have really enjoyed the SGI Irix port I tried to make use of at the time. It was even more unoptimized than the common platforms. :D

  I remember typing into a Swing? text field and the keystrokes not registering for a second or three, basically unusable. Made me stick with AWT for a chat client/server I'd created for learning purposes, which was not quite so bad. Shortly after that I found Python, which was a breath of fresh air at the time and didn't write another line of Java for about 15 years, never again for Perl.

• by sosodev on 3/2/22, 7:47 PM

  Lately I've been working on improving the performance of an open-source HD graphics plugin for the 21 year old Java game oldschool runescape. I have to say it's completely amazing what this ancient Java code has achieved. Reflection allowed the community to build the client they wanted without needing the company to open source the vanilla client and it runs natively on Windows, Linux, and Mac (Intel and M1). It's also ridiculously fast considering how many layers of abstraction we have piled on top of one another. The only thing that sucks is the way parallelism/concurrency works. It's clunky, race conditions are common and hard to manage, there's a ton of overhead, etc.

• by nvmletsdoit on 3/3/22, 9:39 AM

  A little off topic -> I was reading the comments about learning to code through Java. A lot of people are against C/C++ and majority of schools uses Java/Python nowdays.

  Ofc the language at the end doesn't really matters, but I am conviced ( mostly because I only embrace MY learning experience ) that using a language like C helps you get into the programming mindset better.

  I mean, you don't need to understand what a smart pointer is, but once you seen that the object you have created in your own implementation of a vector got copied over and over, you will think twice every time you write a function with a return statement in every language for the rest of your life.

• by gedy on 3/2/22, 7:13 PM

  For its time, Java Swing was a really nice toolkit, and really impressive in its cross platform capabilities. That you could develop a UI directly with code without having to rely on a design file, IDE, or separate tool was very impressive to me.

• by UltraViolence on 3/2/22, 8:46 PM

  Java's only claim to fame is that's the granddaddy of C#, a far superior language and IMHO one of the greatest computer languages ever created.

  In addition, Java was ahead of its time, with mid-1990's computing power not up to the job of letting it run smoothly on lower and mid-tier PC's. It also required, for that time, an egregious amount of RAM memory.

• by jahlove on 3/2/22, 7:39 PM

  Some of the new LookAndFeels for Swing are really slick. Take a look, for instance, at FlatLaf:

  https://github.com/JFormDesigner/FlatLaf

• by pavlov on 3/2/22, 9:17 PM

  The main problems with Java on the desktop were:

  - Obviously non-native look and feel. For many years Java apps didn't even use the system font. At a time when everything was on Windows and its UI was actually reasonably coherent, Java apps stood out as out of place and clunky.

  - Deployment. Each user needed to first install the Java runtime from Sun. This was a deliberate strategy by Sun to get the runtime in place on as many desktops as possible, but it failed colossally. It would have been better to just bundle the whole thing with each app, as Electron does today.

• by jillesvangurp on 3/3/22, 5:29 AM

  Cross platform used to mean, windows, mac, and linux. These days it is web, ios, android, windows, mac, and linux. In that order. And that's before you consider TVs, cars, and other equipment where apps are also relevant.

  These days web is the new cross platform technology. It works everywhere. And mobile is where people focus for native apps. Windows is an afterthought at best. Mac even more. And Linux oddly is now a main source of open source applications that also work on windows and mac. But it's not a big market.

  Unless you consider Android a linux distribution. In that case it's absolutely huge. And Java/Kotlin are the languages of choice on that platform. But they are compiled to native ahead of time so don't require a JVM.

  Otherwise, Applet support for browsers died a long time ago so that blocked Java from being useful on the web. The JVM as distributed by Oracle (and other openjdk packagers) only really covers the traditional three desktop platforms. And it's not really native there and kind of heavy weight. That limits the appeal. Java is not really that cross platform anymore. Sun failed to anticipate and survive the move to smartphones. Up until then J2ME was a thing. These days almost no phone comes with Java support. That's the real reason Java usage on the desktop declined. It did not cover new platforms from about 2007 onwards.

  Despite this there's a new JVM framework on the block: compose desktop. It uses skia (like flutter) and there's a mobile variant supported by Google called jetpack compose. And a web variant called compose web. IOS support is missing. But that looks like it might be addressed at some point.

• by janaagaard on 3/2/22, 7:56 PM

  > That said, we’re roughly circling around the year 2005, which, arguably was a turning point for Java on the desktop. Before 2005, there are lots of questions and answers in online forums about Java desktop technologies like Swing, Cocoa bridge, etc…. After 2005, there really isn’t much. What happened in the years leading up to 2005, or perhaps in 2005 specifically that caused this blackout? Where did all of the Java desktop developers go? Likely many of them moved to the server-side, and the ones who stayed on the client likely shifted their attention to the web, or to native development.

  Could it be the release of Gmail (2004) and Google Maps (2005) showing that you could actually make really great apps written in HTML and JavaScript? For me, these two webapps were turning points in how the web was looked at. As I remember it, things didn't really take off until frameworks like AngularJS were released around 2010.

• by rowls66 on 3/2/22, 9:15 PM

  As I see it, Java succeeded where it was needed, and in the mid-late 90's, that was on the server. When the web emerged, there was no well established development environment for server based applications. The tools for doing much beyond static web pages were pretty limited. Java and a whole bunch of Java based tools emerged to fill this need, and satisfy the needs of corporate customer for intranet solutions.

  On the desktop, Microsoft and C++ were already well established. In the browser, Sun did not offer a browser of their own, so Java depended on support from Netscape, Microsoft and eventually Google. Those companies all had their own technologies for browser development tools, and never tried very hard to support Java. Also Java was a little too much for many 90's era PC's connecting to the internet over dial-up connections, so it was slow.

• by favorited on 3/2/22, 8:44 PM

  > I recall a quote from Steve Jobs around that time that "Java is a giant ball and chain"

  The story I've heard from people who were in the room is slightly different. Jobs acknowledged that Java had its place on the server, but on the client-side: "Java is a big fat pig."

• by cryptos on 3/3/22, 9:39 AM

  Maybe the story is not finished yet. New approaches like JetBrain's Compose (https://www.jetbrains.com/de-de/lp/compose-mpp/) with a React inspired programming model might bring some new interest to the platform. Then there is a Java binding library for Skia (https://github.com/JetBrains/skija), and JavaFX is also alive and high quality.

  As everyone is used to fat Electron apps now, Java applications (especially compiled and packed with new JDK features) might be refreshing.

• by wly_cdgr on 3/3/22, 3:11 AM

  Nice to see that Java works pretty well for indie games these days -it's a more pleasant language & ecosystem to work with than C++, and you don't need to deal with Unity's bullshit. Slay The Spire and Mindustry were written in it.

• by makach on 3/2/22, 7:46 PM

  I used to love Java. Although I think they ruined it with the concept of "Enterprise Java" which only complicating how they were delivering the software. Many good things came out of this work that has been ported to many other frameworks (although, not with the enterprise branding)

  Java is not slow, I use a couple of high quality desktop applications and these will most likely have a future as long as the language is developed. These are not slow apps. Bad developers make bad software regardless of language.

  One of the main things that I always struggled with was the IDE of java. Buggy, slow and overly complicated. I saddens me profoundly that java lost its "je ne sais quoi"

• by nitwit005 on 3/2/22, 9:15 PM

  I'd disagree on the "faith in the power of Moore’s law" part. It was closer to faith in Sun. There were big performance jumps each version from Java 1.3 to 1.6. Some apps became suddenly not terrible.

• by anthony88 on 3/2/22, 10:36 PM

  I've been developing Java desktop app for more than 25 years. I think the problem of the early days was the start up time of Java and the fact that reflection and (de)serialization was causing too much security problems for Applets. Once the applications started, I don't remember them being slow. Hotjava (1995), JDK applets (1996) or Forte (2001).

  The fact that it doesn't look exactly like the OS is not I think a big problem for users. Applications like Google Chrome, Discord and Electron apps don't look native and nobody complains about it.

• by ldargin on 3/2/22, 10:25 PM

  Java's demise on Windows was sealed in 1997 when Sun sued Microsoft. Java remained cross-platform in a technical sense, but couldn't achieve much success on the desktop afterwards.

• by pier25 on 3/3/22, 6:41 AM

  The only Java desktop app I use regularly is Bitwig, a DAW for music production. At least the UI is written in Java and it's fantastic.

• by bastawhiz on 3/3/22, 4:32 AM

  It's interesting to note that probably the best selling Java application for desktop is owned and maintained by Microsoft: Minecraft. It's a testament to the technology that they still after all these years have not managed to make a definitive non-Java version that replaces the Java edition outright.

• by jcranmer on 3/2/22, 6:54 PM

  > As new versions of Java were released, and Internet Explorer entered the scene, the HTML code required to embed your applet became increasingly complex, with different tags used for different browsers and versions or Java. The <applet> tag was advertised as the correct way to embed an applet in a “multi-browser” environment, but Internet Explorer used the <object> tag and Mozilla used the <embed> tag.

  In the time I was playing around with applets (largely after the dates mentioned in this article, mind you), I don't think I came across any site using applets that didn't stick with <applet>. Using <object>/<embed> might have been more "correct," but this is also fervently an era where trying to enforce "correct" HTML usage was at best an attempt to whip the tide into submission.

• by numlock86 on 3/3/22, 6:43 AM

  > The decline and fall of Java on the desktop

  What is this even referring too? Java is everywhere, especially on the desktop. I wouldn't completely contradict and claim "more than ever", but it sure is not on a decline and/or fall. Applets are gone for good, but that's about it.

• by ajuc on 3/2/22, 11:10 PM

  In late 00s I've worked on a pretty big system using C++ and Qt3 for desktop ui.

  For various reasons we moved to Java SWT. It was so much worse it's not even funny.

  Part of it was the absurdly overengineered architecture we used. We moved from 2-layer PL/SQL + C++ app to 3-layer PL/SQL + J2EE + SWT but on SWT there were like 5 additional layers and most of the code was XML configuration on the UI side. That's not Java fault.

  But part of it was just SWT API being so much worse than Qt. Signals and slots make observers and listeners look like ancient technology. The graphical design tools were so much better in Qt. The layouts in SWT sucked. Everything was worse and took more work.

• by rr808 on 3/2/22, 9:01 PM

  Basically everything on the desktop is dying. We still have a heavy C# gui and everyone thinks we're weird. We're due to be replaced with an SPA - good luck with that.

• by avereveard on 3/3/22, 8:05 AM

  imagine an article about the decline of desktop java not mentioning the role of the microsoft bundled jre that basically broke most applications by default. the java ecosystem took a couple years to get out of that issue properly in ways that non techie coulod follow, but the bad experience stuck in the collective user minds up till this day.

• by democracy on 3/3/22, 1:43 AM

  Yeah, webstart was an unusable shit-show.

  I remember writing a first SWT app (with embedded JRE) ~2004 and it looked nice and worked fast enough.

  I think if Sun/Oracle didn't legally ban JRE trimming, added offical Swing browser widget and added a free cross-platform good-looking and developer/user-friendly installer - the story would've been different.

• by IYasha on 3/2/22, 8:59 PM

  In 2020: Admin: Wow, just look at our new 4 CPU server with 1TB super-fast DDR4 RAM! Its capacity is almost infini- Java: Pf-f-f-f! (9_9)

  Jokes aside, the only thing I remember about java on desktop is constantly downloading and installing frmeworks. And lags, lots of lags. Terrible lags. And flickering windows.

• by mrfusion on 3/3/22, 1:15 AM

  What other runtime needs more updates than an OS? Python never asks for updates and breaks my workflow.

• by ramesh31 on 3/2/22, 9:48 PM

  Java is a great language. But it failed to become the universal "write-once" VM that everyone dreamed of in the 90's. Instead, the web browser did that. So there's really no reason to bother with native Java development anymore when browsers can do everything.

• by jlward4th on 3/2/22, 8:57 PM

  I'm definitely biased but I think Kotlin for Desktop apps (https://www.jetbrains.com/lp/compose-desktop/) will take a lot of the energy in this space.

• by hn_throwaway_99 on 3/3/22, 2:27 AM

  The biggest reason for the decline and fall of Java on the desktop is that better alternatives came up that succeeded. Somewhat ironic that Java on the desktop failed, but JavaScript has been wildly successful (despite the handwringing about Electron on HN).

• by eschaton on 3/3/22, 4:05 AM

  The headline presumes Java ever actually went anywhere on the desktop in the first place.

• by jasfi on 3/3/22, 7:19 AM

  Flutter is what replaced it. I'm working on server-based API for Flutter that comes with an easy-to-use SDK: https://nexusdev.tools/

• by loudtieblahblah on 3/2/22, 6:47 PM

  I just wish it'd go away entirely. I'm not a dev. But an admin.

  And I despise supporting or troubleshooting Java applications.

  Unfortunately that's my life these days.

  From an admin perspective, python, php, hell.. Even ruby. All fine. But Java is a nightmare.

• by wanderer_ on 3/2/22, 7:46 PM

  High school AP Computer Science classes are still teaching Java today. I suppose many of the skills it develops are applicable to other languages, but this still needs to change.

  However... Minecraft, anyone?

• by jokethrowaway on 3/3/22, 1:47 PM

  Java was really the precursor of electron.

  As someone who developed a few Java desktop apps and many more Qt + C++ ones, the difference in performance was huge (memory and startup time).

• by ModernMech on 3/3/22, 1:02 AM

  WTF is the java mascot suppose to be. I've never understood it. Is it like some sort of modern art champion? Is it ironic? I have no idea, I just don't get it.

• by nvmletsdoit on 3/3/22, 9:12 AM

  "There was always some guy in the back-row of the class with a trench coat and messy beard who let his feelings about the superiority of C++ be known."

  Reletable

• by kactus on 3/2/22, 7:44 PM

  I still run across Java apps pretty often, but they've all been third-party tools for Eve Online. I begrudgingly installed the Eclipse JRE for them.

• by tus666 on 3/2/22, 7:04 PM

  Eh Java never made it to the desktop. Weird.

• by silver-arrow on 3/2/22, 9:19 PM

  MoneyDance was and is a very good Swing desktop application. I have used it for years and love it.

• by throw_m239339 on 3/3/22, 3:06 AM

  Is there any data that confirms the decline of Java on the desktop?